feat(vscode-companion): support /export session command (#2592)

* feat(vscode-companion): support /export session command

* fix(vscode-ide-companion/webview): prefer ACP session id for export

* feat(vscode-ide-companion): support /export slash command

Add nested /export completion and ACP command availability for the VS Code companion.

Reuse the shared export flow, write to the default path, and show clickable export results in chat.

* fix(export): align slash command messaging

Restore the CLI export description to the existing wording.

Keep the VS Code companion error message consistent with the required /export subcommands.

* fix(webui): support explicit markdown file links

Handle local markdown file links in assistant messages even when automatic file-link detection is disabled.

Normalize encoded paths and line fragments so exported files can be opened from the VS Code webview.

* test(vscode-ide-companion): make export path assertion cross-platform

* fix(vscode-ide-companion): use public session export entrypoint

* fix(cli): replay standalone ESC after early capture

* fix(vscode-ide-companion): resolve rebase artifacts and vitest export alias

Remove duplicate AvailableCommand import caused by merge, and add
vitest resolve alias for @qwen-code/qwen-code/export so the session
export service tests can resolve the CLI export module from source.

* fix(cli): fix getAvailableCommands test mock to use getCommandsForMode

The test mock was only setting up getCommands but getAvailableCommands
calls getCommandsForMode. Add getCommandsForMode to the mock and set up
test data on it instead.

* fix(vscode-ide-companion): fix export file link click and add save dialog

- Fix file:/// URI handling in MarkdownRenderer: normalizeExplicitFileLink
  now strips the file:// scheme before checking isAbsolutePath, so exported
  file links are properly recognized and clickable
- Replace direct cwd file write with vscode.window.showSaveDialog() so
  users can choose the export destination and filename
- Handle cancelled save dialog gracefully (return null, skip success message)

* fix(webui): scope file link handler to file:// URIs only, fix # in filenames

- normalizeExplicitFileLink now returns early for file:// URIs without
  splitting on #, since vscode.Uri.file() encodes # as %23 in the path.
  This prevents filenames containing # from being truncated after decode.
- Explicit-link click handler now only fires for file:// URI hrefs,
  not arbitrary relative paths. This prevents model-generated markdown
  links from bypassing enableFileLinks=false and opening arbitrary files.
- Remove unused KNOWN_FILE_EXTENSIONS constant.

* fix(vscode-ide-companion): update export tests for save dialog, fix stale JSDoc

- Add showSaveDialog mock to sessionExportService.test.ts
- Update existing test to verify save dialog is called with correct args
- Add test for cancelled save dialog returning null
- Fix JSDoc that incorrectly claimed fallback-to-cwd behavior

Author: yiliang114

packages/cli/package.json

@@ -16,6 +16,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./export": {
+      "types": "./dist/src/export/index.d.ts",
+      "import": "./dist/src/export/index.js"
     }
   },
   "scripts": {

packages/cli/src/export/index.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export {
+  collectSessionData,
+  generateExportFilename,
+  normalizeSessionData,
+  toHtml,
+  toJson,
+  toJsonl,
+  toMarkdown,
+  type ExportMessage,
+  type ExportSessionData,
+} from '../ui/utils/export/index.js';

packages/cli/src/nonInteractiveCliCommands.test.ts

@@ -5,7 +5,10 @@
  */
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleSlashCommand } from './nonInteractiveCliCommands.js';
+import {
+  getAvailableCommands,
+  handleSlashCommand,
+} from './nonInteractiveCliCommands.js';
 import type { Config } from '@qwen-code/qwen-code-core';
 import type { LoadedSettings } from './config/settings.js';
 import { CommandKind, type ExecutionMode } from './ui/commands/types.js';
@@ -340,3 +343,43 @@ describe('handleSlashCommand', () => {
     });
   });
 });
+
+describe('getAvailableCommands', () => {
+  let mockConfig: Config;
+
+  beforeEach(() => {
+    mockCommandServiceCreate.mockResolvedValue({
+      getCommands: mockGetCommands,
+      getCommandsForMode: mockGetCommandsForMode,
+    });
+
+    mockConfig = {
+      getExperimentalZedIntegration: vi.fn().mockReturnValue(false),
+      isInteractive: vi.fn().mockReturnValue(false),
+      getSessionId: vi.fn().mockReturnValue('test-session'),
+      getFolderTrustFeature: vi.fn().mockReturnValue(false),
+      getFolderTrust: vi.fn().mockReturnValue(false),
+      getProjectRoot: vi.fn().mockReturnValue('/test/project'),
+      getDisabledSlashCommands: vi.fn().mockReturnValue([]),
+      storage: {},
+    } as unknown as Config;
+  });
+
+  it('includes /export in the default non-interactive command list', async () => {
+    mockGetCommandsForMode.mockReturnValue([
+      {
+        name: 'export',
+        description: 'Export current session',
+        kind: CommandKind.BUILT_IN,
+        action: vi.fn(),
+      },
+    ]);
+
+    const commands = await getAvailableCommands(
+      mockConfig,
+      new AbortController().signal,
+    );
+
+    expect(commands.map((command) => command.name)).toContain('export');
+  });
+});

packages/cli/src/utils/earlyInputCapture.test.ts

@@ -264,13 +264,13 @@ describe('earlyInputCapture', () => {
       expect(input.toString()).toBe('');
     });
 
-    it('should drop standalone ESC on capture end', () => {
+    it('should replay standalone ESC on capture end', () => {
       startEarlyInputCapture();
       mockStdin.write(Buffer.from('\x1b'));
       stopEarlyInputCapture();
 
       const input = getAndClearCapturedInput();
-      expect(input.toString()).toBe('');
+      expect(input.toString()).toBe('\x1b');
     });
   });
 

packages/cli/src/utils/earlyInputCapture.ts

@@ -223,6 +223,9 @@ function shouldReplayPendingAtStop(pending: Buffer): boolean {
   if (pending.length === 0) {
     return false;
   }
+  if (pending.length === 1 && pending[0] === 0x1b) {
+    return true;
+  }
   return classifyEscapeSequence(pending, 0) === 'user';
 }
 

packages/vscode-ide-companion/esbuild.js

@@ -81,6 +81,15 @@ const reactDedupPlugin = {
   },
 };
 
+const publicCliExportPlugin = {
+  name: 'public-cli-export',
+  setup(build) {
+    build.onResolve({ filter: /^@qwen-code\/qwen-code\/export$/ }, () => ({
+      path: resolve(repoRoot, 'packages/cli/src/export/index.ts'),
+    }));
+  },
+};
+
 /**
  * Resolve `*.wasm?binary` imports to embedded Uint8Array content.
  * This keeps the companion bundle compatible with core's inline-WASM loader.
@@ -187,6 +196,7 @@ async function main() {
       'import.meta.url': 'import_meta.url',
     },
     plugins: [
+      publicCliExportPlugin,
       wasmBinaryPlugin,
       wasmLoader({ mode: 'embedded' }),
       /* add to the end of plugins array */

packages/vscode-ide-companion/src/services/sessionExportService.test.ts

@@ -0,0 +1,191 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as path from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  mockLoadSession,
+  mockCollectSessionData,
+  mockNormalizeSessionData,
+  mockToHtml,
+  mockToMarkdown,
+  mockToJson,
+  mockToJsonl,
+  mockGenerateExportFilename,
+  mockWriteFile,
+  mockShowSaveDialog,
+} = vi.hoisted(() => ({
+  mockLoadSession: vi.fn(),
+  mockCollectSessionData: vi.fn(),
+  mockNormalizeSessionData: vi.fn(),
+  mockToHtml: vi.fn(),
+  mockToMarkdown: vi.fn(),
+  mockToJson: vi.fn(),
+  mockToJsonl: vi.fn(),
+  mockGenerateExportFilename: vi.fn(),
+  mockWriteFile: vi.fn(),
+  mockShowSaveDialog: vi.fn(),
+}));
+
+vi.mock('@qwen-code/qwen-code-core', () => {
+  class SessionService {
+    constructor(_cwd: string) {}
+
+    async loadSession(_sessionId: string) {
+      return mockLoadSession();
+    }
+  }
+
+  return {
+    SessionService,
+  };
+});
+
+vi.mock('@qwen-code/qwen-code/export', () => ({
+  collectSessionData: mockCollectSessionData,
+  normalizeSessionData: mockNormalizeSessionData,
+  toHtml: mockToHtml,
+  toMarkdown: mockToMarkdown,
+  toJson: mockToJson,
+  toJsonl: mockToJsonl,
+  generateExportFilename: mockGenerateExportFilename,
+}));
+
+vi.mock('node:fs/promises', () => ({
+  writeFile: mockWriteFile,
+}));
+
+vi.mock('vscode', () => ({
+  Uri: {
+    file: (fsPath: string) => ({ fsPath }),
+  },
+  window: {
+    showSaveDialog: mockShowSaveDialog,
+  },
+}));
+
+import {
+  exportSessionToFile,
+  parseExportSlashCommand,
+} from './sessionExportService.js';
+
+describe('sessionExportService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockLoadSession.mockResolvedValue({
+      conversation: {
+        sessionId: 'session-1',
+        startTime: '2025-01-01T00:00:00Z',
+        messages: [],
+      },
+    });
+    mockCollectSessionData.mockResolvedValue({
+      sessionId: 'session-1',
+      startTime: '2025-01-01T00:00:00Z',
+      messages: [],
+    });
+    mockNormalizeSessionData.mockImplementation((data) => data);
+    mockToHtml.mockReturnValue('<html>export</html>');
+    mockToMarkdown.mockReturnValue('# export');
+    mockToJson.mockReturnValue('{"ok":true}');
+    mockToJsonl.mockReturnValue('{"ok":true}');
+    mockGenerateExportFilename.mockImplementation(
+      (format: string) => `qwen-export.${format}`,
+    );
+  });
+
+  describe('parseExportSlashCommand', () => {
+    it('returns null for non-export input', () => {
+      expect(parseExportSlashCommand('hello')).toBeNull();
+      expect(parseExportSlashCommand('/model')).toBeNull();
+    });
+
+    it('requires an explicit subcommand for bare /export', () => {
+      expect(() => parseExportSlashCommand('/export')).toThrow(
+        "Command '/export' requires a subcommand.",
+      );
+      expect(() => parseExportSlashCommand('/export   ')).toThrow(
+        "Command '/export' requires a subcommand.",
+      );
+    });
+
+    it('returns the requested export format', () => {
+      expect(parseExportSlashCommand('/export html')).toBe('html');
+      expect(parseExportSlashCommand('/export md')).toBe('md');
+      expect(parseExportSlashCommand('/export JSON')).toBe('json');
+    });
+
+    it('rejects unsupported export arguments', () => {
+      expect(() => parseExportSlashCommand('/export csv')).toThrow(
+        'Unsupported /export format. Use /export html, /export md, /export json, or /export jsonl.',
+      );
+      expect(() => parseExportSlashCommand('/export md extra')).toThrow(
+        'Unsupported /export format. Use /export html, /export md, /export json, or /export jsonl.',
+      );
+    });
+  });
+
+  describe('exportSessionToFile', () => {
+    it('writes the exported session to the user-chosen path', async () => {
+      const chosenPath = path.join('/workspace', 'qwen-export.html');
+      mockShowSaveDialog.mockResolvedValue({ fsPath: chosenPath });
+
+      const result = await exportSessionToFile({
+        sessionId: 'session-1',
+        cwd: '/workspace',
+        format: 'html',
+      });
+
+      expect(mockCollectSessionData).toHaveBeenCalledWith(
+        expect.objectContaining({ sessionId: 'session-1' }),
+        expect.anything(),
+      );
+      expect(mockNormalizeSessionData).toHaveBeenCalled();
+      expect(mockToHtml).toHaveBeenCalled();
+      expect(mockShowSaveDialog).toHaveBeenCalledWith(
+        expect.objectContaining({
+          title: 'Export Session as HTML',
+        }),
+      );
+      expect(mockWriteFile).toHaveBeenCalledWith(
+        chosenPath,
+        '<html>export</html>',
+        'utf-8',
+      );
+      expect(result).toEqual({
+        filename: 'qwen-export.html',
+        uri: { fsPath: chosenPath },
+      });
+    });
+
+    it('returns null when the user cancels the save dialog', async () => {
+      mockShowSaveDialog.mockResolvedValue(undefined);
+
+      const result = await exportSessionToFile({
+        sessionId: 'session-1',
+        cwd: '/workspace',
+        format: 'html',
+      });
+
+      expect(result).toBeNull();
+      expect(mockWriteFile).not.toHaveBeenCalled();
+    });
+
+    it('throws when the target session cannot be loaded', async () => {
+      mockLoadSession.mockResolvedValue(undefined);
+
+      await expect(
+        exportSessionToFile({
+          sessionId: 'missing-session',
+          cwd: '/workspace',
+          format: 'json',
+        }),
+      ).rejects.toThrow('No active session found to export.');
+    });
+  });
+});