feat(extensions): interactive multi-tab /extensions manager (Installed / Discover / Sources)

docs/users/extension/introduction.md

@@ -18,6 +18,16 @@ You can manage extensions at runtime within the interactive CLI using `/extensio
 | `/extensions install <source>`        | Install an extension from a git URL, local path, npm package, or marketplace |
 | `/extensions explore [source]`        | Open extensions source page(Gemini or ClaudeCode) in your browser            |
 
+#### The interactive extension manager
+
+Running `/extensions` (or `/extensions manage`) opens an interactive manager with three tabs. Press `Tab` or the `←`/`→` arrows to switch between them.
+
+- **Discover** — browse plugins from your configured marketplace sources. Type to search, `Enter` to view a plugin's details, and install it (you'll be asked to choose an install scope). Press `Ctrl+R` to re-fetch the listings, and `Esc` to go back.
+- **Installed** — your installed extensions, grouped by scope (**User level**, **Project level**, and favorites). Use `↑`/`↓` to navigate, `Space` to enable/disable an extension, `f` to favorite it, and `Enter` to open its details. MCP servers bundled by an extension appear nested under their parent extension with live connection status; you can enable or disable each server individually from there.
+- **Sources** — manage the marketplace sources that feed the Discover tab. Use `↑`/`↓` to navigate, `Enter` to select a source, and `d` to remove one. These are the same sources managed by the `qwen extensions sources` CLI commands described below.
+
+Changes made here hot-reload immediately, without restarting Qwen Code.
+
 ### CLI Extension Management
 
 You can also manage extensions using `qwen extensions` CLI commands. Note that changes made via CLI commands will be reflected in active CLI sessions on restart.
@@ -133,6 +143,34 @@ qwen extensions install /path/to/your/extension
 
 Note that we create a copy of the installed extension, so you will need to run `qwen extensions update` to pull in changes from both locally-defined extensions and those on GitHub.
 
+#### Choosing an install scope
+
+By default, an installed extension is enabled globally (user scope). Pass `--scope project` to enable it only for the current workspace:
+
+```bash
+qwen extensions install <source> --scope project
+```
+
+`--scope workspace` is accepted as an alias of `--scope project`. This matches the scope choice offered when installing from the `/extensions manage` Discover tab.
+
+### Managing marketplace sources
+
+Marketplace sources (Claude plugin marketplaces) power the Discover tab in `/extensions manage`. You can manage them from the CLI as well:
+
+```bash
+# Add a marketplace (owner/repo, git URL, https URL to marketplace.json, or local path)
+qwen extensions sources add <source>
+
+# List configured marketplaces
+qwen extensions sources list
+
+# Re-fetch a marketplace's plugin listing
+qwen extensions sources update <name>
+
+# Remove a marketplace
+qwen extensions sources remove <name>
+```
+
 ### Uninstalling an extension
 
 To uninstall, run `qwen extensions uninstall extension-name`, so, in the case of the install example:

packages/cli/src/commands/extensions.tsx

@@ -14,6 +14,7 @@ import { enableCommand } from './extensions/enable.js';
 import { linkCommand } from './extensions/link.js';
 import { newCommand } from './extensions/new.js';
 import { settingsCommand } from './extensions/settings.js';
+import { sourcesCommand } from './extensions/sources.js';
 
 export const extensionsCommand: CommandModule = {
   command: 'extensions <command>',
@@ -29,6 +30,7 @@ export const extensionsCommand: CommandModule = {
       .command(linkCommand)
       .command(newCommand)
       .command(settingsCommand)
+      .command(sourcesCommand)
       .demandCommand(1, 'You need at least one command before continuing.')
       .version(false),
   handler: () => {

packages/cli/src/commands/extensions/install.test.ts

@@ -10,6 +10,9 @@ import yargs from 'yargs';
 
 const mockInstallExtension = vi.hoisted(() => vi.fn());
 const mockRefreshCache = vi.hoisted(() => vi.fn());
+const mockSetExtensionScope = vi.hoisted(() => vi.fn());
+const mockEnableExtension = vi.hoisted(() => vi.fn());
+const mockDisableExtension = vi.hoisted(() => vi.fn());
 const mockParseInstallSource = vi.hoisted(() => vi.fn());
 const mockRequestConsentNonInteractive = vi.hoisted(() => vi.fn());
 const mockRequestConsentOrFail = vi.hoisted(() => vi.fn());
@@ -22,6 +25,9 @@ vi.mock('@qwen-code/qwen-code-core', () => ({
   ExtensionManager: vi.fn().mockImplementation(() => ({
     installExtension: mockInstallExtension,
     refreshCache: mockRefreshCache,
+    setExtensionScope: mockSetExtensionScope,
+    enableExtension: mockEnableExtension,
+    disableExtension: mockDisableExtension,
   })),
   parseInstallSource: mockParseInstallSource,
 }));
@@ -38,6 +44,12 @@ vi.mock('../../config/trustedFolders.js', () => ({
 
 vi.mock('../../config/settings.js', () => ({
   loadSettings: mockLoadSettings,
+  SettingScope: {
+    User: 'User',
+    Workspace: 'Workspace',
+    System: 'System',
+    SystemDefaults: 'SystemDefaults',
+  },
 }));
 
 vi.mock('../../utils/errors.js', () => ({
@@ -225,4 +237,133 @@ describe('handleInstall', () => {
 
     processSpy.mockRestore();
   });
+
+  it('should re-scope enablement to the workspace for a project-scope install', async () => {
+    mockParseInstallSource.mockResolvedValue({
+      type: 'git',
+      url: 'git@some-url',
+    });
+    mockInstallExtension.mockResolvedValue({ name: 'scoped-extension' });
+
+    await handleInstall({ source: 'git@some-url', scope: 'project' });
+
+    expect(mockSetExtensionScope).toHaveBeenCalledWith(
+      'scoped-extension',
+      'project',
+    );
+    expect(mockDisableExtension).toHaveBeenCalledWith(
+      'scoped-extension',
+      'User',
+    );
+    expect(mockEnableExtension).toHaveBeenCalledWith(
+      'scoped-extension',
+      'Workspace',
+    );
+    expect(mockWriteStdoutLine).toHaveBeenCalledWith(
+      'Extension "scoped-extension" installed successfully and enabled for the current workspace.',
+    );
+  });
+
+  it('rolls back the User-scope disable when the Workspace enable fails', async () => {
+    const processSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never);
+    mockParseInstallSource.mockResolvedValue({
+      type: 'git',
+      url: 'git@some-url',
+    });
+    mockInstallExtension.mockResolvedValue({ name: 'scoped-extension' });
+    // Workspace enable (first call) fails; the rollback User enable succeeds.
+    mockEnableExtension.mockRejectedValueOnce(
+      new Error('workspace enable failed'),
+    );
+    mockEnableExtension.mockResolvedValueOnce(undefined);
+
+    await handleInstall({ source: 'git@some-url', scope: 'project' });
+
+    expect(mockDisableExtension).toHaveBeenCalledWith(
+      'scoped-extension',
+      'User',
+    );
+    // Both the failed Workspace enable and the rollback User enable were attempted.
+    expect(mockEnableExtension).toHaveBeenNthCalledWith(
+      1,
+      'scoped-extension',
+      'Workspace',
+    );
+    expect(mockEnableExtension).toHaveBeenNthCalledWith(
+      2,
+      'scoped-extension',
+      'User',
+    );
+    // The original failure is surfaced and the command exits non-zero.
+    expect(mockWriteStderrLine).toHaveBeenCalledWith('workspace enable failed');
+    expect(processSpy).toHaveBeenCalledWith(1);
+    processSpy.mockRestore();
+  });
+
+  it('surfaces a rollback failure when the recovery enable also fails', async () => {
+    const processSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never);
+    mockParseInstallSource.mockResolvedValue({
+      type: 'git',
+      url: 'git@some-url',
+    });
+    mockInstallExtension.mockResolvedValue({ name: 'scoped-extension' });
+    // Both the Workspace enable and the rollback User enable fail.
+    mockEnableExtension.mockRejectedValueOnce(
+      new Error('workspace enable failed'),
+    );
+    mockEnableExtension.mockRejectedValueOnce(new Error('rollback failed'));
+
+    await handleInstall({ source: 'git@some-url', scope: 'project' });
+
+    // A warning naming the failed rollback, plus the original error, are shown.
+    expect(mockWriteStderrLine).toHaveBeenCalledWith(
+      expect.stringContaining('failed to roll back the scope change'),
+    );
+    expect(mockWriteStderrLine).toHaveBeenCalledWith('workspace enable failed');
+    expect(processSpy).toHaveBeenCalledWith(1);
+    processSpy.mockRestore();
+  });
+
+  it('should accept workspace as an alias of project scope', async () => {
+    mockParseInstallSource.mockResolvedValue({
+      type: 'git',
+      url: 'git@some-url',
+    });
+    mockInstallExtension.mockResolvedValue({ name: 'scoped-extension' });
+
+    await handleInstall({ source: 'git@some-url', scope: 'workspace' });
+
+    expect(mockSetExtensionScope).toHaveBeenCalledWith(
+      'scoped-extension',
+      'project',
+    );
+    expect(mockEnableExtension).toHaveBeenCalledWith(
+      'scoped-extension',
+      'Workspace',
+    );
+  });
+
+  it('should record user scope without re-scoping enablement', async () => {
+    mockParseInstallSource.mockResolvedValue({
+      type: 'git',
+      url: 'git@some-url',
+    });
+    mockInstallExtension.mockResolvedValue({ name: 'user-extension' });
+
+    await handleInstall({ source: 'git@some-url', scope: 'user' });
+
+    expect(mockSetExtensionScope).toHaveBeenCalledWith(
+      'user-extension',
+      'user',
+    );
+    expect(mockDisableExtension).not.toHaveBeenCalled();
+    expect(mockEnableExtension).not.toHaveBeenCalled();
+    expect(mockWriteStdoutLine).toHaveBeenCalledWith(
+      'Extension "user-extension" installed successfully and enabled.',
+    );
+  });
 });

packages/cli/src/commands/extensions/install.ts

@@ -9,11 +9,12 @@ import type { CommandModule } from 'yargs';
 import {
   ExtensionManager,
   parseInstallSource,
+  type ExtensionScope,
 } from '@qwen-code/qwen-code-core';
 import { getErrorMessage } from '../../utils/errors.js';
 import { writeStdoutLine, writeStderrLine } from '../../utils/stdioHelpers.js';
 import { isWorkspaceTrusted } from '../../config/trustedFolders.js';
-import { loadSettings } from '../../config/settings.js';
+import { loadSettings, SettingScope } from '../../config/settings.js';
 import {
   requestConsentOrFail,
   requestConsentNonInteractive,
@@ -28,6 +29,12 @@ interface InstallArgs {
   allowPreRelease?: boolean;
   consent?: boolean;
   registry?: string;
+  scope?: string;
+}
+
+// "workspace" is accepted as an alias of "project" to match enable/disable.
+function normalizeScope(scope: string | undefined): ExtensionScope {
+  return scope === 'project' || scope === 'workspace' ? 'project' : 'user';
 }
 
 export async function handleInstall(args: InstallArgs) {
@@ -87,10 +94,55 @@ export async function handleInstall(args: InstallArgs) {
       },
       requestConsent,
     );
+    const scope = normalizeScope(args.scope);
+    if (args.scope) {
+      // installExtension auto-enables at the user (global) scope. For a
+      // project-scoped install, re-scope enablement to this workspace only —
+      // BEFORE recording the scope preference, so a failed Workspace enable
+      // (which rolls back to User) can't leave the prefs claiming "project".
+      if (scope === 'project') {
+        await extensionManager.disableExtension(
+          extension.name,
+          SettingScope.User,
+        );
+        try {
+          await extensionManager.enableExtension(
+            extension.name,
+            SettingScope.Workspace,
+          );
+        } catch (enableError) {
+          // The User-scope disable already landed. If the Workspace enable
+          // fails, the extension would be left disabled everywhere — roll the
+          // User enable back so it isn't silently dead, then surface the error.
+          try {
+            await extensionManager.enableExtension(
+              extension.name,
+              SettingScope.User,
+            );
+          } catch (rollbackError) {
+            // Rollback failed too: the extension is now disabled at every
+            // scope. Surface this so the user knows recovery also failed,
+            // before the original error is reported below.
+            writeStderrLine(
+              `Warning: failed to roll back the scope change for "${extension.name}"; it may be disabled at all scopes: ${getErrorMessage(rollbackError)}`,
+            );
+          }
+          throw enableError;
+        }
+      }
+      // Enablement succeeded (or scope is user/local with no enablement change):
+      // now it's safe to persist the scope preference.
+      extensionManager.setExtensionScope(extension.name, scope);
+    }
     writeStdoutLine(
-      t('Extension "{{name}}" installed successfully and enabled.', {
-        name: extension.name,
-      }),
+      scope === 'project'
+        ? t(
+            'Extension "{{name}}" installed successfully and enabled for the current workspace.',
+            { name: extension.name },
+          )
+        : t('Extension "{{name}}" installed successfully and enabled.', {
+            name: extension.name,
+          }),
     );
   } catch (error) {
     writeStderrLine(getErrorMessage(error));
@@ -135,6 +187,13 @@ export const installCommand: CommandModule = {
         type: 'boolean',
         default: false,
       })
+      .option('scope', {
+        describe: t(
+          'The scope to install the extension in: "user" (global, default) or "project" (current workspace only).',
+        ),
+        type: 'string',
+        choices: ['user', 'project', 'workspace'],
+      })
       .check((argv) => {
         if (!argv.source) {
           throw new Error(t('The source argument must be provided.'));
@@ -149,6 +208,7 @@ export const installCommand: CommandModule = {
       allowPreRelease: argv['pre-release'] as boolean | undefined,
       consent: argv['consent'] as boolean | undefined,
       registry: argv['registry'] as string | undefined,
+      scope: argv['scope'] as string | undefined,
     });
   },
 };