MLD-1373 - Agent plugin install VS Code support (#533)

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: shay-coh

agent/common/install_flags.go

@@ -45,7 +45,7 @@ func (r InstallFlagsResult) PathMode() bool {
 // InstallFlagsOptions configures harness install flag validation.
 type InstallFlagsOptions struct {
 	// DefaultGlobalScope uses global scope when neither --global nor --project-dir is set.
-	// Agent plugins (claude, cursor, codex) only support global installs.
+	// Agent plugins (claude, cursor, codex, vscode) only support global installs.
 	DefaultGlobalScope bool
 }
 

agent/plugins/commands/install/install.go

@@ -327,31 +327,8 @@ func (ic *InstallCommand) resolveAgentTargetDirectories() ([]plugincommon.AgentT
 	if ic.scope == agentcommon.InstallScopeProject && ic.projectDir == "" {
 		return nil, fmt.Errorf("project directory is required for project-scoped install")
 	}
-	if ic.scope == agentcommon.InstallScopeProject {
-		for _, agent := range ic.agents {
-			agentLower := strings.ToLower(agent.Name)
-			if agentLower == "claude" {
-				return nil, fmt.Errorf(
-					"claude does not support project-scoped plugin installs: " +
-						"Claude plugin configuration is user-scoped only (~/.claude/settings.json). " +
-						"Use --global to install there instead",
-				)
-			}
-			if agentLower == "cursor" {
-				return nil, fmt.Errorf(
-					"cursor does not support project-scoped plugin installs: " +
-						"Cursor only auto-discovers full plugins from ~/.cursor/plugins/local/. " +
-						"Use --global to install there instead",
-				)
-			}
-			if agentLower == "codex" {
-				return nil, fmt.Errorf(
-					"codex does not support project-scoped plugin installs: " +
-						"Codex plugin configuration is user-scoped only (~/.codex/config.toml). " +
-						"Use --global to install there instead",
-				)
-			}
-		}
+	if err := plugincommon.RejectUnsupportedProjectScope(ic.scope == agentcommon.InstallScopeProject, ic.agents, "install"); err != nil {
+		return nil, err
 	}
 	isGlobal := ic.scope == agentcommon.InstallScopeGlobal
 	// Path is "" because harness mode uses project or global scope

agent/plugins/commands/install/install_test.go

@@ -53,6 +53,36 @@ func TestResolveAgentTargetDirectories_DefaultScopeUsesGlobalForCursor(t *testin
 	assert.Equal(t, plugincommon.ScopeGlobal, targets[0].Scope)
 }
 
+func TestResolveAgentTargetDirectories_DefaultScopeUsesGlobalForVSCode(t *testing.T) {
+	globalBase := filepath.Join(t.TempDir(), "global", ".copilot", "installed-plugins")
+	wantBase, err := filepath.Abs(globalBase)
+	require.NoError(t, err)
+
+	cmd := NewInstallCommand().
+		SetSlug("jfrog-plugin-timepass").
+		SetRepoKey("plugins-local").
+		SetAgents([]plugincommon.AgentSpec{{Name: "vscode", Config: plugincommon.AgentConfig{GlobalDir: globalBase}}})
+
+	targets, err := cmd.resolveAgentTargetDirectories()
+	require.NoError(t, err)
+	require.Len(t, targets, 1)
+	assert.Equal(t, filepath.Join(wantBase, "plugins-local", "jfrog-plugin-timepass"), targets[0].DestinationDir)
+	assert.Equal(t, plugincommon.ScopeGlobal, targets[0].Scope)
+}
+
+func TestResolveAgentTargetDirectories_ProjectScopeVSCodeRejected(t *testing.T) {
+	cmd := NewInstallCommand().
+		SetSlug("my-plugin").
+		SetAgents([]plugincommon.AgentSpec{{Name: "vscode", Config: plugincommon.AgentConfig{GlobalDir: "~/.copilot/installed-plugins"}}}).
+		SetProjectDir(t.TempDir()).
+		SetGlobal(false)
+
+	targets, err := cmd.resolveAgentTargetDirectories()
+	require.Error(t, err)
+	assert.Nil(t, targets)
+	assert.Contains(t, err.Error(), "vscode does not support project-scoped plugin installs")
+}
+
 func TestResolveAgentTargetDirectories_GlobalScope(t *testing.T) {
 	globalBase := filepath.Join(t.TempDir(), "global", ".cursor", "plugins")
 	wantBase, err := filepath.Abs(globalBase)

agent/plugins/commands/list/list.go

@@ -184,7 +184,7 @@ func (lc *ListCommand) listLocalPlugins() error {
 		}
 		specs = append(specs, spec)
 	}
-	// claude/cursor/codex have no project-scoped plugin registry to list from — same
+	// claude/cursor/codex/vscode have no project-scoped plugin registry to list from — same
 	// restriction install/update already enforce (RejectUnsupportedProjectScope). Without
 	// this, a non-global list would silently show claude/codex's one global native list
 	// (see buildNativeRows) under a --project-dir the plugins were never actually scoped to.
@@ -260,7 +260,8 @@ func (lc *ListCommand) buildPluginRowsForHarness(registry map[string]agentcommon
 }
 
 // buildDirRows resolves the install dir for agentName and lists installed plugins by
-// scanning it directly. Used for agents with no native plugin registry (e.g. cursor).
+// scanning it directly. Used for agents with no native plugin registry (e.g. cursor,
+// vscode).
 func (lc *ListCommand) buildDirRows(registry map[string]agentcommon.AgentSpec, agentName string) ([]localListRow, error) {
 	spec, err := agentcommon.ResolveAgent(registry, agentName, pluginscommon.RegistryHelp)
 	if err != nil {
@@ -286,6 +287,10 @@ func (lc *ListCommand) buildDirRows(registry map[string]agentcommon.AgentSpec, a
 		projectDir = lc.projectDir
 	}
 
+	if pluginscommon.UsesRepoKeyedLayout(agentName) {
+		return lc.buildRepoKeyedRows(dir, projectDir, agentName, entries)
+	}
+
 	var rows []localListRow
 	for _, entry := range entries {
 		if !entry.IsDir() {
@@ -299,6 +304,32 @@ func (lc *ListCommand) buildDirRows(registry map[string]agentcommon.AgentSpec, a
 	return rows, nil
 }
 
+// buildRepoKeyedRows lists plugins nested one level deeper, one subdirectory per
+// Artifactory repo (<dir>/<repoKey>/<slug>), e.g. vscode.
+func (lc *ListCommand) buildRepoKeyedRows(dir, projectDir, agentName string, entries []os.DirEntry) ([]localListRow, error) {
+	var rows []localListRow
+	for _, repoEntry := range entries {
+		if !repoEntry.IsDir() || strings.HasPrefix(repoEntry.Name(), ".") {
+			continue
+		}
+		repoDir := filepath.Join(dir, repoEntry.Name())
+		pluginEntries, err := os.ReadDir(repoDir)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read plugins directory %s: %w", repoDir, err)
+		}
+		for _, entry := range pluginEntries {
+			if !entry.IsDir() {
+				continue
+			}
+			row, ok := lc.buildRowForPlugin(filepath.Join(repoDir, entry.Name()), entry.Name(), projectDir, agentName)
+			if ok {
+				rows = append(rows, row)
+			}
+		}
+	}
+	return rows, nil
+}
+
 // buildNativeRows lists every plugin agentName's own CLI reports as installed. The native
 // registries themselves don't track a description, but the plugin's own manifest usually
 // exists on disk at its native install path (e.g. .claude-plugin/plugin.json), so Description
@@ -544,7 +575,7 @@ func RunList(c *components.Context) error {
 
 // resolveListScope applies the same project/global-scope default as install/update's
 // DefaultGlobalScope: when neither --global nor --project-dir is explicitly given, list
-// defaults to global scope, not project scope. claude/cursor/codex only support a global
+// defaults to global scope, not project scope. claude/cursor/codex/vscode only support a global
 // native registry/config anyway (see agentcommon.RejectUnsupportedProjectScope), so
 // defaulting to project scope here would just make list --harness (no flags) reject in
 // listLocalPlugins where install/update would have quietly gone global.

agent/plugins/commands/list/list_test.go

@@ -162,3 +162,35 @@ func TestBuildPluginRowsForHarness_CursorUsesDirScan(t *testing.T) {
 	assert.Equal(t, "web", rows[0].Name)
 	assert.Equal(t, "2.0.0", rows[0].Version)
 }
+
+func TestBuildPluginRowsForHarness_VSCodeScansRepoSubdirectories(t *testing.T) {
+	restore := listNativePluginsFunc
+	defer func() { listNativePluginsFunc = restore }()
+	listNativePluginsFunc = func(string) ([]plugincommon.NativePluginInfo, error) {
+		t.Fatal("listNativePluginsFunc must not be called for agents without a native registry")
+		return nil, nil
+	}
+
+	dir := t.TempDir()
+	pluginDir := filepath.Join(dir, "installed-plugins", "plugins-local", "web")
+	require.NoError(t, os.MkdirAll(filepath.Join(pluginDir, ".jfrog"), 0o755))
+	require.NoError(t, agentcommon.WriteInstallInfoManifest(pluginDir, plugincommon.PluginInfoManifestFile, plugincommon.PluginInfoManifest{
+		Repo:             "plugins-local",
+		Slug:             "web",
+		InstalledVersion: "2.0.0",
+		Scope:            "global",
+		Agent:            "vscode",
+	}))
+
+	registry := map[string]agentcommon.AgentSpec{
+		"vscode": {
+			Config: agentcommon.AgentConfig{GlobalDir: filepath.Join(dir, "installed-plugins")},
+		},
+	}
+
+	rows, err := (&ListCommand{global: true}).buildPluginRowsForHarness(registry, "vscode")
+	require.NoError(t, err)
+	require.Len(t, rows, 1)
+	assert.Equal(t, "web", rows[0].Name)
+	assert.Equal(t, "2.0.0", rows[0].Version)
+}

agent/plugins/commands/update/update.go

@@ -106,7 +106,7 @@ func RunUpdate(c *components.Context) error {
 }
 
 // validateUpdateScope rejects project-scoped updates for agents whose native plugin
-// configuration only supports global scope (claude, cursor, codex — see
+// configuration only supports global scope (claude, cursor, codex, vscode — see
 // plugincommon.RejectUnsupportedProjectScope). --path mode and --global are always allowed;
 // a custom agent registered via agent-config.json is not restricted here.
 func validateUpdateScope(flags agentcommon.InstallFlagsResult) error {
@@ -224,8 +224,8 @@ func diagnoseNotFoundError(resolveErr error, slug, repoKey string, targets []plu
 }
 
 // resolveUpdateTargets resolves the install targets for slug and injects the
-// Artifactory repo key into the path for claude/codex, matching install's
-// <GlobalDir>/<repoKey>/<slug> layout for those two agents.
+// Artifactory repo key into the path for claude/codex/vscode, matching install's
+// <GlobalDir>/<repoKey>/<slug> layout for those agents.
 func resolveUpdateTargets(opts update, slug string) ([]plugincommon.AgentTarget, error) {
 	targets, err := agentcommon.ResolveAgentTargets(slug, opts.flags.AbsoluteInstallBaseDir, opts.flags.Specs, opts.flags.ProjectDirAbs, opts.flags.IsGlobal)
 	if err != nil {
@@ -279,7 +279,7 @@ type discoveredPlugin struct {
 }
 
 // discoverInstalledPluginTargets finds every jf-installed plugin (valid plugin-info.json)
-// under each --harness, grouped by (slug, repo); claude/codex scan every repo subdirectory
+// under each --harness, grouped by (slug, repo); claude/codex/vscode scan every repo subdirectory
 // (UsesRepoKeyedLayout), others read the repo from the manifest. repoFilter, when non-empty,
 // keeps only that exact repo.
 func discoverInstalledPluginTargets(flags agentcommon.InstallFlagsResult, repoFilter string) ([]discoveredPlugin, error) {

agent/plugins/commands/update/update_test.go

@@ -382,6 +382,22 @@ func TestResolveUpdateTargets_CursorUnaffectedByRepoKey(t *testing.T) {
 	assert.Equal(t, filepath.Join(globalBase, "web"), targets[0].DestinationDir)
 }
 
+func TestResolveUpdateTargets_InjectsRepoKeyForVSCode(t *testing.T) {
+	globalBase := t.TempDir()
+	opts := update{
+		repoKey: "my-repo",
+		flags: agentcommon.InstallFlagsResult{
+			Specs:    []plugincommon.AgentSpec{{Name: "vscode", Config: agentcommon.AgentConfig{GlobalDir: globalBase}}},
+			IsGlobal: true,
+		},
+	}
+
+	targets, err := resolveUpdateTargets(opts, "web")
+	require.NoError(t, err)
+	require.Len(t, targets, 1)
+	assert.Equal(t, filepath.Join(globalBase, "my-repo", "web"), targets[0].DestinationDir)
+}
+
 func TestRunUpdate_AllRejectsSlugFlag(t *testing.T) {
 	ctx := newUpdateContext(t, nil, map[string]string{"harness": "claude", "slug": "web"}, map[string]bool{"all": true})
 	err := RunUpdate(ctx)

agent/plugins/common/agents.go

@@ -12,22 +12,25 @@ type AgentSpec = agentcommon.AgentSpec
 // User overrides come from agent-config.json -> "plugins-agents".
 var Agents = map[string]AgentConfig{
 	// GlobalDir behavior varies by agent:
-	// - Claude & Codex: The Artifactory repo key is injected as a subdirectory at install time
-	//   so each repo gets its own isolated marketplace directory:
-	//     Claude: <GlobalDir>/<repoKey>/<slug>
-	//     Codex:  <GlobalDir>/<repoKey>/<slug>
+	// - Claude, Codex & VS Code: The Artifactory repo key is injected as a subdirectory at
+	//   install time so each repo gets its own isolated marketplace directory:
+	//     Claude:  <GlobalDir>/<repoKey>/<slug>
+	//     Codex:   <GlobalDir>/<repoKey>/<slug>
+	//     VS Code: <GlobalDir>/<repoKey>/<slug>
 	// - Cursor: No repo key injection; paths are used as-is:
 	//     Cursor: <GlobalDir>/<slug>
 	//
 	// Paths ending in /jfrog are rooted under ~/.jfrog for JFrog-specific plugin configurations.
 	//
 	// All agents support global scope only. Project scope is not supported because:
-	//   - Claude: Plugin config is user-scoped only (~/.claude/settings.json)
-	//   - Cursor: Only auto-discovers full plugins from ~/.cursor/plugins/local/
-	//   - Codex:  Plugin config is user-scoped only (~/.codex/config.toml)
+	//   - Claude:  Plugin config is user-scoped only (~/.claude/settings.json)
+	//   - Cursor:  Only auto-discovers full plugins from ~/.cursor/plugins/local/
+	//   - Codex:   Plugin config is user-scoped only (~/.codex/config.toml)
+	//   - VS Code: Only auto-discovers plugins from ~/.copilot/installed-plugins/
 	"claude": {GlobalDir: "~/.claude/plugins/local/jfrog", ProjectDir: ""},
 	"cursor": {GlobalDir: "~/.cursor/plugins/local", ProjectDir: ""},
 	"codex":  {GlobalDir: "~/.agents/plugins/local/jfrog", ProjectDir: ""},
+	"vscode": {GlobalDir: "~/.copilot/installed-plugins", ProjectDir: ""},
 }
 
 // RegistryHelp configures agent-config.json help text for plugins harness resolution.

agent/plugins/common/agents_test.go

@@ -17,13 +17,13 @@ func TestLoadAgentRegistry_BuiltInsOnly(t *testing.T) {
 	registry, err := agentcommon.LoadAgentRegistry(Agents, agentcommon.PluginsAgentsKey)
 	require.NoError(t, err)
 
-	for _, name := range []string{"claude", "cursor", "codex"} {
+	for _, name := range []string{"claude", "cursor", "codex", "vscode"} {
 		spec, ok := registry[name]
 		require.True(t, ok, "expected built-in %q", name)
 		assert.False(t, spec.FromConfig)
 	}
 	// Built-in registry must be exactly the supported plugin agents.
-	assert.Len(t, registry, 3)
+	assert.Len(t, registry, 4)
 }
 
 func TestLoadAgentRegistry_OverridesAndAdds(t *testing.T) {
@@ -106,5 +106,5 @@ func TestSupportedAgentsList_OnlyPluginAgents(t *testing.T) {
 	testutil.WithJfrogHome(t)
 	got := agentcommon.SupportedAgentsList(Agents, agentcommon.PluginsAgentsKey)
 	parts := strings.Split(got, ", ")
-	assert.ElementsMatch(t, []string{"claude", "cursor", "codex"}, parts)
+	assert.ElementsMatch(t, []string{"claude", "cursor", "codex", "vscode"}, parts)
 }

agent/plugins/common/install_targets.go

@@ -21,11 +21,11 @@ type AgentTarget = agentcommon.InstallTarget
 
 // UsesRepoKeyedLayout reports whether agentName nests installed plugins one level deeper
 // under a repo-key subdirectory (see MarketplaceRootForAgent) instead of storing them
-// directly under GlobalDir. True only for claude and codex, so each Artifactory repo gets
-// its own isolated marketplace subdirectory; cursor/--path have no such nesting.
+// directly under GlobalDir. True for claude, codex and vscode, so each Artifactory repo
+// gets its own isolated marketplace subdirectory; cursor/--path have no such nesting.
 func UsesRepoKeyedLayout(agentName string) bool {
 	switch strings.ToLower(agentName) {
-	case "claude", "codex":
+	case "claude", "codex", "vscode":
 		return true
 	default:
 		return false
@@ -34,7 +34,7 @@ func UsesRepoKeyedLayout(agentName string) bool {
 
 // MarketplaceRootForAgent returns the directory holding an agent's installed plugin slugs
 // directly as subdirectories (filepath.Join(result, slug) is the plugin's install dir).
-// For claude/codex that's <globalOrProjectDir>/<repoKey>, so repos never collide; every
+// For claude/codex/vscode that's <globalOrProjectDir>/<repoKey>, so repos never collide; every
 // other agent uses <globalOrProjectDir> unchanged and ignores repoKey.
 func MarketplaceRootForAgent(agentName, globalOrProjectDir, repoKey string) string {
 	if UsesRepoKeyedLayout(agentName) {
@@ -43,7 +43,7 @@ func MarketplaceRootForAgent(agentName, globalOrProjectDir, repoKey string) stri
 	return globalOrProjectDir
 }
 
-// InjectRepoKey rewrites claude/codex targets' DestinationDir to
+// InjectRepoKey rewrites repo-keyed agents' (claude/codex/vscode) DestinationDir to
 // <GlobalDir>/<slug> → <GlobalDir>/<repoKey>/<slug>, so different repos never overwrite
 // each other's marketplace registration; other targets are unchanged. Callers needing the
 // marketplace root before the slug is known should use MarketplaceRootForAgent directly.