feat: add export command draft for session history with markdown and HTML formats

docs/users/configuration/auth.md

@@ -5,13 +5,11 @@ Qwen Code supports two authentication methods. Pick the one that matches how you
 - **Qwen OAuth (recommended)**: sign in with your `qwen.ai` account in a browser.
 - **OpenAI-compatible API**: use an API key (OpenAI or any OpenAI-compatible provider / endpoint).
 
-![](https://img.alicdn.com/imgextra/i2/O1CN01IxI1bt1sNO543AVTT_!!6000000005754-0-tps-1958-822.jpg)
-
 ## Option 1: Qwen OAuth (recommended & free) 👍
 
-Use this if you want the simplest setup and you're using Qwen models.
+Use this if you want the simplest setup and you’re using Qwen models.
 
-- **How it works**: on first start, Qwen Code opens a browser login page. After you finish, credentials are cached locally so you usually won't need to log in again.
+- **How it works**: on first start, Qwen Code opens a browser login page. After you finish, credentials are cached locally so you usually won’t need to log in again.
 - **Requirements**: a `qwen.ai` account + internet access (at least for the first login).
 - **Benefits**: no API key management, automatic credential refresh.
 - **Cost & quota**: free, with a quota of **60 requests/minute** and **2,000 requests/day**.
@@ -26,54 +24,15 @@ qwen
 
 Use this if you want to use OpenAI models or any provider that exposes an OpenAI-compatible API (e.g. OpenAI, Azure OpenAI, OpenRouter, ModelScope, Alibaba Cloud Bailian, or a self-hosted compatible endpoint).
 
-### Recommended: Coding Plan (subscription-based) 🚀
+### Quick start (interactive, recommended for local use)
 
-Use this if you want predictable costs with higher usage quotas for the qwen3-coder-plus model.
+When you choose the OpenAI-compatible option in the CLI, it will prompt you for:
 
-> [!IMPORTANT]
->
-> Coding Plan is only available for users in China mainland (Beijing region).
+- **API key**
+- **Base URL** (default: `https://api.openai.com/v1`)
+- **Model** (default: `gpt-4o`)
 
-- **How it works**: subscribe to the Coding Plan with a fixed monthly fee, then configure Qwen Code to use the dedicated endpoint and your subscription API key.
-- **Requirements**: an active Coding Plan subscription from [Alibaba Cloud Bailian](https://bailian.console.aliyun.com/cn-beijing/?tab=globalset#/efm/coding_plan).
-- **Benefits**: higher usage quotas, predictable monthly costs, access to latest qwen3-coder-plus model.
-- **Cost & quota**: varies by plan (see table below).
-
-#### Coding Plan Pricing & Quotas
-
-| Feature             | Lite Basic Plan       | Pro Advanced Plan     |
-| :------------------ | :-------------------- | :-------------------- |
-| **Price**           | ¥40/month             | ¥200/month            |
-| **5-Hour Limit**    | Up to 1,200 requests  | Up to 6,000 requests  |
-| **Weekly Limit**    | Up to 9,000 requests  | Up to 45,000 requests |
-| **Monthly Limit**   | Up to 18,000 requests | Up to 90,000 requests |
-| **Supported Model** | qwen3-coder-plus      | qwen3-coder-plus      |
-
-#### Quick Setup for Coding Plan
-
-When you select the OpenAI-compatible option in the CLI, enter these values:
-
-- **API key**: `sk-sp-xxxxx`
-- **Base URL**: `https://coding.dashscope.aliyuncs.com/v1`
-- **Model**: `qwen3-coder-plus`
-
-> **Note**: Coding Plan API keys have the format `sk-sp-xxxxx`, which is different from standard Alibaba Cloud API keys.
-
-#### Configure via Environment Variables
-
-Set these environment variables to use Coding Plan:
-
-```bash
-export OPENAI_API_KEY="your-coding-plan-api-key"  # Format: sk-sp-xxxxx
-export OPENAI_BASE_URL="https://coding.dashscope.aliyuncs.com/v1"
-export OPENAI_MODEL="qwen3-coder-plus"
-```
-
-For more details about Coding Plan, including subscription options and troubleshooting, see the [full Coding Plan documentation](https://bailian.console.aliyun.com/cn-beijing/?tab=doc#/doc/?type=model&url=3005961).
-
-### Other OpenAI-compatible Providers
-
-If you are using other providers (OpenAI, Azure, local LLMs, etc.), use the following configuration methods.
+> **Note:** the CLI may display the key in plain text for verification. Make sure your terminal is not being recorded or shared.
 
 ### Configure via command-line arguments
 

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@qwen-code/qwen-code",
-  "version": "0.7.1",
+  "version": "0.7.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@qwen-code/qwen-code",
-      "version": "0.7.1",
+      "version": "0.7.0",
       "workspaces": [
         "packages/*"
       ],
@@ -17310,7 +17310,7 @@
     },
     "packages/cli": {
       "name": "@qwen-code/qwen-code",
-      "version": "0.7.1",
+      "version": "0.7.0",
       "dependencies": {
         "@google/genai": "1.30.0",
         "@iarna/toml": "^2.2.5",
@@ -17947,7 +17947,7 @@
     },
     "packages/core": {
       "name": "@qwen-code/qwen-code-core",
-      "version": "0.7.1",
+      "version": "0.7.0",
       "hasInstallScript": true,
       "dependencies": {
         "@anthropic-ai/sdk": "^0.36.1",
@@ -21408,7 +21408,7 @@
     },
     "packages/test-utils": {
       "name": "@qwen-code/qwen-code-test-utils",
-      "version": "0.7.1",
+      "version": "0.7.0",
       "dev": true,
       "license": "Apache-2.0",
       "devDependencies": {
@@ -21420,7 +21420,7 @@
     },
     "packages/vscode-ide-companion": {
       "name": "qwen-code-vscode-ide-companion",
-      "version": "0.7.1",
+      "version": "0.7.0",
       "license": "LICENSE",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.25.1",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code",
-  "version": "0.7.1",
+  "version": "0.7.0",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -13,7 +13,7 @@
     "url": "git+https://github.com/QwenLM/qwen-code.git"
   },
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.7.1"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.7.0"
   },
   "scripts": {
     "start": "cross-env node scripts/start.js",

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code",
-  "version": "0.7.1",
+  "version": "0.7.0",
   "description": "Qwen Code",
   "repository": {
     "type": "git",
@@ -33,7 +33,7 @@
     "dist"
   ],
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.7.1"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.7.0"
   },
   "dependencies": {
     "@google/genai": "1.30.0",

packages/cli/src/config/config.ts

@@ -874,10 +874,11 @@ export async function loadCliConfig(
     }
   };
 
-  // ACP mode check: must include both --acp (current) and --experimental-acp (deprecated).
-  // Without this check, edit, write_file, run_shell_command would be excluded in ACP mode.
-  const isAcpMode = argv.acp || argv.experimentalAcp;
-  if (!interactive && !isAcpMode && inputFormat !== InputFormat.STREAM_JSON) {
+  if (
+    !interactive &&
+    !argv.experimentalAcp &&
+    inputFormat !== InputFormat.STREAM_JSON
+  ) {
     switch (approvalMode) {
       case ApprovalMode.PLAN:
       case ApprovalMode.DEFAULT:

packages/cli/src/services/BuiltinCommandLoader.ts

@@ -18,6 +18,7 @@ import { copyCommand } from '../ui/commands/copyCommand.js';
 import { docsCommand } from '../ui/commands/docsCommand.js';
 import { directoryCommand } from '../ui/commands/directoryCommand.js';
 import { editorCommand } from '../ui/commands/editorCommand.js';
+import { exportCommand } from '../ui/commands/exportCommand.js';
 import { extensionsCommand } from '../ui/commands/extensionsCommand.js';
 import { helpCommand } from '../ui/commands/helpCommand.js';
 import { ideCommand } from '../ui/commands/ideCommand.js';
@@ -67,6 +68,7 @@ export class BuiltinCommandLoader implements ICommandLoader {
       docsCommand,
       directoryCommand,
       editorCommand,
+      exportCommand,
       extensionsCommand,
       helpCommand,
       await ideCommand(),

packages/cli/src/ui/commands/exportCommand.test.ts

@@ -0,0 +1,379 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import { exportCommand } from './exportCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import type { ChatRecord } from '@qwen-code/qwen-code-core';
+import type { Part, Content } from '@google/genai';
+import {
+  transformToMarkdown,
+  loadHtmlTemplate,
+  prepareExportData,
+  injectDataIntoHtmlTemplate,
+  generateExportFilename,
+} from '../utils/exportUtils.js';
+
+const mockSessionServiceMocks = vi.hoisted(() => ({
+  loadLastSession: vi.fn(),
+}));
+
+vi.mock('@qwen-code/qwen-code-core', () => {
+  class SessionService {
+    constructor(_cwd: string) {}
+    async loadLastSession() {
+      return mockSessionServiceMocks.loadLastSession();
+    }
+  }
+
+  return {
+    SessionService,
+  };
+});
+
+vi.mock('../utils/exportUtils.js', () => ({
+  transformToMarkdown: vi.fn(),
+  loadHtmlTemplate: vi.fn(),
+  prepareExportData: vi.fn(),
+  injectDataIntoHtmlTemplate: vi.fn(),
+  generateExportFilename: vi.fn(),
+}));
+
+vi.mock('node:fs/promises', () => ({
+  writeFile: vi.fn(),
+}));
+
+describe('exportCommand', () => {
+  const mockSessionData = {
+    conversation: {
+      sessionId: 'test-session-id',
+      startTime: '2025-01-01T00:00:00Z',
+      messages: [
+        {
+          type: 'user',
+          message: {
+            parts: [{ text: 'Hello' }] as Part[],
+          } as Content,
+        },
+      ] as ChatRecord[],
+    },
+  };
+
+  let mockContext: ReturnType<typeof createMockCommandContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockSessionServiceMocks.loadLastSession.mockResolvedValue(mockSessionData);
+
+    mockContext = createMockCommandContext({
+      services: {
+        config: {
+          getWorkingDir: vi.fn().mockReturnValue('/test/dir'),
+          getProjectRoot: vi.fn().mockReturnValue('/test/project'),
+        },
+      },
+    });
+
+    vi.mocked(transformToMarkdown).mockReturnValue('# Test Markdown');
+    vi.mocked(loadHtmlTemplate).mockResolvedValue(
+      '<html><script id="chat-data" type="application/json">// DATA_PLACEHOLDER</script></html>',
+    );
+    vi.mocked(prepareExportData).mockReturnValue({
+      sessionId: 'test-session-id',
+      startTime: '2025-01-01T00:00:00Z',
+      messages: mockSessionData.conversation.messages,
+    });
+    vi.mocked(injectDataIntoHtmlTemplate).mockReturnValue(
+      '<html><script id="chat-data" type="application/json">{"data": "test"}</script></html>',
+    );
+    vi.mocked(generateExportFilename).mockImplementation(
+      (ext: string) => `export-2025-01-01T00-00-00-000Z.${ext}`,
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('command structure', () => {
+    it('should have correct name and description', () => {
+      expect(exportCommand.name).toBe('export');
+      expect(exportCommand.description).toBe(
+        'Export current session message history to a file',
+      );
+    });
+
+    it('should have md and html subcommands', () => {
+      expect(exportCommand.subCommands).toHaveLength(2);
+      expect(exportCommand.subCommands?.map((c) => c.name)).toEqual([
+        'md',
+        'html',
+      ]);
+    });
+  });
+
+  describe('exportMarkdownAction', () => {
+    it('should export session to markdown file', async () => {
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+
+      const result = await mdCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('export-2025-01-01T00-00-00-000Z.md'),
+      });
+
+      expect(mockSessionServiceMocks.loadLastSession).toHaveBeenCalled();
+      expect(transformToMarkdown).toHaveBeenCalledWith(
+        mockSessionData.conversation.messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+      expect(generateExportFilename).toHaveBeenCalledWith('md');
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('export-2025-01-01T00-00-00-000Z.md'),
+        '# Test Markdown',
+        'utf-8',
+      );
+    });
+
+    it('should return error when config is not available', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          config: null,
+        },
+      });
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+      const result = await mdCommand.action(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Configuration not available.',
+      });
+    });
+
+    it('should return error when working directory cannot be determined', async () => {
+      const contextWithoutCwd = createMockCommandContext({
+        services: {
+          config: {
+            getWorkingDir: vi.fn().mockReturnValue(null),
+            getProjectRoot: vi.fn().mockReturnValue(null),
+          },
+        },
+      });
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand || !mdCommand.action) {
+        throw new Error('md command not found');
+      }
+      const result = await mdCommand.action(contextWithoutCwd, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not determine current working directory.',
+      });
+    });
+
+    it('should return error when no session is found', async () => {
+      mockSessionServiceMocks.loadLastSession.mockResolvedValue(undefined);
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+      const result = await mdCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'No active session found to export.',
+      });
+    });
+
+    it('should handle errors during export', async () => {
+      const error = new Error('File write failed');
+      vi.mocked(fs.writeFile).mockRejectedValue(error);
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+      const result = await mdCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Failed to export session: File write failed',
+      });
+    });
+
+    it('should use project root when working dir is not available', async () => {
+      const contextWithProjectRoot = createMockCommandContext({
+        services: {
+          config: {
+            getWorkingDir: vi.fn().mockReturnValue(null),
+            getProjectRoot: vi.fn().mockReturnValue('/test/project'),
+          },
+        },
+      });
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+      await mdCommand.action(contextWithProjectRoot, '');
+    });
+  });
+
+  describe('exportHtmlAction', () => {
+    it('should export session to HTML file', async () => {
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+
+      const result = await htmlCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining(
+          'export-2025-01-01T00-00-00-000Z.html',
+        ),
+      });
+
+      expect(mockSessionServiceMocks.loadLastSession).toHaveBeenCalled();
+      expect(loadHtmlTemplate).toHaveBeenCalled();
+      expect(prepareExportData).toHaveBeenCalledWith(
+        mockSessionData.conversation,
+      );
+      expect(injectDataIntoHtmlTemplate).toHaveBeenCalled();
+      expect(generateExportFilename).toHaveBeenCalledWith('html');
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('export-2025-01-01T00-00-00-000Z.html'),
+        expect.stringContaining('{"data": "test"}'),
+        'utf-8',
+      );
+    });
+
+    it('should return error when config is not available', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          config: null,
+        },
+      });
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Configuration not available.',
+      });
+    });
+
+    it('should return error when working directory cannot be determined', async () => {
+      const contextWithoutCwd = createMockCommandContext({
+        services: {
+          config: {
+            getWorkingDir: vi.fn().mockReturnValue(null),
+            getProjectRoot: vi.fn().mockReturnValue(null),
+          },
+        },
+      });
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand || !htmlCommand.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(contextWithoutCwd, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not determine current working directory.',
+      });
+    });
+
+    it('should return error when no session is found', async () => {
+      mockSessionServiceMocks.loadLastSession.mockResolvedValue(undefined);
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'No active session found to export.',
+      });
+    });
+
+    it('should handle errors during HTML template loading', async () => {
+      const error = new Error('Failed to fetch template');
+      vi.mocked(loadHtmlTemplate).mockRejectedValue(error);
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Failed to export session: Failed to fetch template',
+      });
+    });
+
+    it('should handle errors during file write', async () => {
+      const error = new Error('File write failed');
+      vi.mocked(fs.writeFile).mockRejectedValue(error);
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Failed to export session: File write failed',
+      });
+    });
+  });
+});

packages/cli/src/ui/commands/exportCommand.ts

@@ -0,0 +1,177 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  type CommandContext,
+  type SlashCommand,
+  type MessageActionReturn,
+  CommandKind,
+} from './types.js';
+import { SessionService } from '@qwen-code/qwen-code-core';
+import {
+  transformToMarkdown,
+  loadHtmlTemplate,
+  prepareExportData,
+  injectDataIntoHtmlTemplate,
+  generateExportFilename,
+} from '../utils/exportUtils.js';
+
+/**
+ * Action for the 'md' subcommand - exports session to markdown.
+ */
+async function exportMarkdownAction(
+  context: CommandContext,
+): Promise<MessageActionReturn> {
+  const { services } = context;
+  const { config } = services;
+
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Configuration not available.',
+    };
+  }
+
+  const cwd = config.getWorkingDir() || config.getProjectRoot();
+  if (!cwd) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Could not determine current working directory.',
+    };
+  }
+
+  try {
+    // Load the current session
+    const sessionService = new SessionService(cwd);
+    const sessionData = await sessionService.loadLastSession();
+
+    if (!sessionData) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'No active session found to export.',
+      };
+    }
+
+    const { conversation } = sessionData;
+
+    const markdown = transformToMarkdown(
+      conversation.messages,
+      conversation.sessionId,
+      conversation.startTime,
+    );
+
+    const filename = generateExportFilename('md');
+    const filepath = path.join(cwd, filename);
+
+    // Write to file
+    await fs.writeFile(filepath, markdown, 'utf-8');
+
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: `Session exported to markdown: ${filename}`,
+    };
+  } catch (error) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Failed to export session: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Action for the 'html' subcommand - exports session to HTML.
+ */
+async function exportHtmlAction(
+  context: CommandContext,
+): Promise<MessageActionReturn> {
+  const { services } = context;
+  const { config } = services;
+
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Configuration not available.',
+    };
+  }
+
+  const cwd = config.getWorkingDir() || config.getProjectRoot();
+  if (!cwd) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Could not determine current working directory.',
+    };
+  }
+
+  try {
+    // Load the current session
+    const sessionService = new SessionService(cwd);
+    const sessionData = await sessionService.loadLastSession();
+
+    if (!sessionData) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'No active session found to export.',
+      };
+    }
+
+    const { conversation } = sessionData;
+
+    const template = await loadHtmlTemplate();
+    const exportData = prepareExportData(conversation);
+    const html = injectDataIntoHtmlTemplate(template, exportData);
+
+    const filename = generateExportFilename('html');
+    const filepath = path.join(cwd, filename);
+
+    // Write to file
+    await fs.writeFile(filepath, html, 'utf-8');
+
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: `Session exported to HTML: ${filename}`,
+    };
+  } catch (error) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Failed to export session: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Main export command with subcommands.
+ */
+export const exportCommand: SlashCommand = {
+  name: 'export',
+  description: 'Export current session message history to a file',
+  kind: CommandKind.BUILT_IN,
+  subCommands: [
+    {
+      name: 'md',
+      description: 'Export session to markdown format',
+      kind: CommandKind.BUILT_IN,
+      action: exportMarkdownAction,
+    },
+    {
+      name: 'html',
+      description: 'Export session to HTML format',
+      kind: CommandKind.BUILT_IN,
+      action: exportHtmlAction,
+    },
+  ],
+};

packages/cli/src/ui/utils/exportUtils.test.ts

@@ -0,0 +1,404 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  extractTextFromContent,
+  transformToMarkdown,
+  loadHtmlTemplate,
+  prepareExportData,
+  injectDataIntoHtmlTemplate,
+  generateExportFilename,
+} from './exportUtils.js';
+import type { ChatRecord } from '@qwen-code/qwen-code-core';
+import type { Part, Content } from '@google/genai';
+
+describe('exportUtils', () => {
+  describe('extractTextFromContent', () => {
+    it('should return empty string for undefined content', () => {
+      expect(extractTextFromContent(undefined)).toBe('');
+    });
+
+    it('should return empty string for content without parts', () => {
+      expect(extractTextFromContent({} as Content)).toBe('');
+    });
+
+    it('should extract text from text parts', () => {
+      const content: Content = {
+        parts: [{ text: 'Hello' }, { text: 'World' }] as Part[],
+      };
+      expect(extractTextFromContent(content)).toBe('Hello\nWorld');
+    });
+
+    it('should format function call parts', () => {
+      const content: Content = {
+        parts: [
+          {
+            functionCall: {
+              name: 'testFunction',
+              args: { param1: 'value1' },
+            },
+          },
+        ] as Part[],
+      };
+      const result = extractTextFromContent(content);
+      expect(result).toContain('[Function Call: testFunction]');
+      expect(result).toContain('"param1": "value1"');
+    });
+
+    it('should format function response parts', () => {
+      const content: Content = {
+        parts: [
+          {
+            functionResponse: {
+              name: 'testFunction',
+              response: { result: 'success' },
+            },
+          },
+        ] as Part[],
+      };
+      const result = extractTextFromContent(content);
+      expect(result).toContain('[Function Response: testFunction]');
+      expect(result).toContain('"result": "success"');
+    });
+
+    it('should handle mixed part types', () => {
+      const content: Content = {
+        parts: [
+          { text: 'Start' },
+          {
+            functionCall: {
+              name: 'call',
+              args: {},
+            },
+          },
+          { text: 'End' },
+        ] as Part[],
+      };
+      const result = extractTextFromContent(content);
+      expect(result).toContain('Start');
+      expect(result).toContain('[Function Call: call]');
+      expect(result).toContain('End');
+    });
+  });
+
+  describe('transformToMarkdown', () => {
+    const mockMessages: ChatRecord[] = [
+      {
+        uuid: 'uuid-1',
+        parentUuid: null,
+        sessionId: 'test-session-id',
+        timestamp: '2025-01-01T00:00:00Z',
+        type: 'user',
+        cwd: '/test',
+        version: '1.0.0',
+        message: {
+          parts: [{ text: 'Hello, how are you?' }] as Part[],
+        } as Content,
+      },
+      {
+        uuid: 'uuid-2',
+        parentUuid: 'uuid-1',
+        sessionId: 'test-session-id',
+        timestamp: '2025-01-01T00:00:01Z',
+        type: 'assistant',
+        cwd: '/test',
+        version: '1.0.0',
+        message: {
+          parts: [{ text: 'I am doing well, thank you!' }] as Part[],
+        } as Content,
+      },
+    ];
+
+    it('should transform messages to markdown format', () => {
+      const result = transformToMarkdown(
+        mockMessages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).toContain('# Chat Session Export');
+      expect(result).toContain('**Session ID**: test-session-id');
+      expect(result).toContain('**Start Time**: 2025-01-01T00:00:00Z');
+      expect(result).toContain('## User');
+      expect(result).toContain('Hello, how are you?');
+      expect(result).toContain('## Assistant');
+      expect(result).toContain('I am doing well, thank you!');
+    });
+
+    it('should include exported timestamp', () => {
+      const before = new Date().toISOString();
+      const result = transformToMarkdown(
+        mockMessages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+      const after = new Date().toISOString();
+
+      expect(result).toContain('**Exported**:');
+      const exportedMatch = result.match(/\*\*Exported\*\*: (.+)/);
+      expect(exportedMatch).toBeTruthy();
+      if (exportedMatch) {
+        const exportedTime = exportedMatch[1].trim();
+        expect(exportedTime >= before).toBe(true);
+        expect(exportedTime <= after).toBe(true);
+      }
+    });
+
+    it('should format tool_result messages', () => {
+      const messages: ChatRecord[] = [
+        {
+          uuid: 'uuid-3',
+          parentUuid: 'uuid-2',
+          sessionId: 'test-session-id',
+          timestamp: '2025-01-01T00:00:02Z',
+          type: 'tool_result',
+          cwd: '/test',
+          version: '1.0.0',
+          toolCallResult: {
+            resultDisplay: 'Tool output',
+          },
+          message: {
+            parts: [{ text: 'Additional info' }] as Part[],
+          } as Content,
+        },
+      ];
+
+      const result = transformToMarkdown(
+        messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).toContain('## Tool Result');
+      expect(result).toContain('```');
+      expect(result).toContain('Tool output');
+      expect(result).toContain('Additional info');
+    });
+
+    it('should format tool_result with JSON resultDisplay', () => {
+      const messages: ChatRecord[] = [
+        {
+          uuid: 'uuid-4',
+          parentUuid: 'uuid-3',
+          sessionId: 'test-session-id',
+          timestamp: '2025-01-01T00:00:03Z',
+          type: 'tool_result',
+          cwd: '/test',
+          version: '1.0.0',
+          toolCallResult: {
+            resultDisplay: '{"key": "value"}',
+          },
+          message: {} as Content,
+        },
+      ];
+
+      const result = transformToMarkdown(
+        messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).toContain('## Tool Result');
+      expect(result).toContain('```');
+      expect(result).toContain('"key": "value"');
+    });
+
+    it('should handle chat compression system messages', () => {
+      const messages: ChatRecord[] = [
+        {
+          uuid: 'uuid-5',
+          parentUuid: null,
+          sessionId: 'test-session-id',
+          timestamp: '2025-01-01T00:00:04Z',
+          type: 'system',
+          subtype: 'chat_compression',
+          cwd: '/test',
+          version: '1.0.0',
+          message: {} as Content,
+        },
+      ];
+
+      const result = transformToMarkdown(
+        messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).toContain('_[Chat history compressed]_');
+    });
+
+    it('should skip system messages without subtype', () => {
+      const messages: ChatRecord[] = [
+        {
+          uuid: 'uuid-6',
+          parentUuid: null,
+          sessionId: 'test-session-id',
+          timestamp: '2025-01-01T00:00:05Z',
+          type: 'system',
+          cwd: '/test',
+          version: '1.0.0',
+          message: {} as Content,
+        },
+      ];
+
+      const result = transformToMarkdown(
+        messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).not.toContain('## System');
+    });
+  });
+
+  describe('loadHtmlTemplate', () => {
+    beforeEach(() => {
+      vi.stubGlobal('fetch', vi.fn());
+    });
+
+    afterEach(() => {
+      vi.unstubAllGlobals();
+    });
+
+    it('should load HTML template from URL', async () => {
+      const mockTemplate = '<html><body>Test Template</body></html>';
+      const mockResponse = {
+        ok: true,
+        text: vi.fn().mockResolvedValue(mockTemplate),
+      };
+      vi.mocked(fetch).mockResolvedValue(mockResponse as unknown as Response);
+
+      const result = await loadHtmlTemplate();
+
+      expect(result).toBe(mockTemplate);
+      expect(fetch).toHaveBeenCalledWith(
+        'https://raw.githubusercontent.com/QwenLM/qwen-code/main/template_portable.html',
+      );
+    });
+
+    it('should throw error when fetch fails', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+      };
+      vi.mocked(fetch).mockResolvedValue(mockResponse as unknown as Response);
+
+      await expect(loadHtmlTemplate()).rejects.toThrow(
+        'Failed to fetch HTML template: 404 Not Found',
+      );
+    });
+
+    it('should throw error when network request fails', async () => {
+      const networkError = new Error('Network error');
+      vi.mocked(fetch).mockRejectedValue(networkError);
+
+      await expect(loadHtmlTemplate()).rejects.toThrow(
+        'Failed to load HTML template',
+      );
+      await expect(loadHtmlTemplate()).rejects.toThrow('Network error');
+    });
+  });
+
+  describe('prepareExportData', () => {
+    it('should prepare export data from conversation', () => {
+      const conversation = {
+        sessionId: 'test-session-id',
+        startTime: '2025-01-01T00:00:00Z',
+        messages: [
+          {
+            type: 'user',
+            message: {
+              parts: [{ text: 'Hello' }] as Part[],
+            } as Content,
+          },
+        ] as ChatRecord[],
+      };
+
+      const result = prepareExportData(conversation);
+
+      expect(result).toEqual({
+        sessionId: 'test-session-id',
+        startTime: '2025-01-01T00:00:00Z',
+        messages: conversation.messages,
+      });
+    });
+  });
+
+  describe('injectDataIntoHtmlTemplate', () => {
+    it('should inject JSON data into HTML template', () => {
+      const template = `
+        <html>
+          <body>
+            <script id="chat-data" type="application/json">
+              // DATA_PLACEHOLDER: Your JSONL data will be injected here
+            </script>
+          </body>
+        </html>
+      `;
+
+      const data = {
+        sessionId: 'test-session-id',
+        startTime: '2025-01-01T00:00:00Z',
+        messages: [] as ChatRecord[],
+      };
+
+      const result = injectDataIntoHtmlTemplate(template, data);
+
+      expect(result).toContain(
+        '<script id="chat-data" type="application/json">',
+      );
+      expect(result).toContain('"sessionId": "test-session-id"');
+      expect(result).toContain('"startTime": "2025-01-01T00:00:00Z"');
+      expect(result).not.toContain('DATA_PLACEHOLDER');
+    });
+
+    it('should handle template with whitespace around placeholder', () => {
+      const template = `<script id="chat-data" type="application/json">\n// DATA_PLACEHOLDER: Your JSONL data will be injected here\n</script>`;
+
+      const data = {
+        sessionId: 'test',
+        startTime: '2025-01-01T00:00:00Z',
+        messages: [] as ChatRecord[],
+      };
+
+      const result = injectDataIntoHtmlTemplate(template, data);
+
+      expect(result).toContain('"sessionId": "test"');
+      expect(result).not.toContain('DATA_PLACEHOLDER');
+    });
+  });
+
+  describe('generateExportFilename', () => {
+    it('should generate filename with timestamp and extension', () => {
+      const filename = generateExportFilename('md');
+
+      expect(filename).toMatch(
+        /^export-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z\.md$/,
+      );
+    });
+
+    it('should use provided extension', () => {
+      const filename1 = generateExportFilename('html');
+      const filename2 = generateExportFilename('json');
+
+      expect(filename1).toMatch(/\.html$/);
+      expect(filename2).toMatch(/\.json$/);
+    });
+
+    it('should replace colons and dots in timestamp', () => {
+      const filename = generateExportFilename('md');
+
+      expect(filename).not.toContain(':');
+      // The filename should contain a dot only for the extension
+      expect(filename.split('.').length).toBe(2);
+      // Check that timestamp part (before extension) doesn't contain dots
+      const timestampPart = filename.split('.')[0];
+      expect(timestampPart).not.toContain('.');
+    });
+  });
+});

packages/cli/src/ui/utils/exportUtils.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Part, Content } from '@google/genai';
+import type { ChatRecord } from '@qwen-code/qwen-code-core';
+
+const HTML_TEMPLATE_URL =
+  'https://raw.githubusercontent.com/QwenLM/qwen-code/main/template_portable.html';
+
+/**
+ * Extracts text content from a Content object's parts.
+ */
+export function extractTextFromContent(content: Content | undefined): string {
+  if (!content?.parts) return '';
+
+  const textParts: string[] = [];
+  for (const part of content.parts as Part[]) {
+    if ('text' in part) {
+      const textPart = part as { text: string };
+      textParts.push(textPart.text);
+    } else if ('functionCall' in part) {
+      const fnPart = part as { functionCall: { name: string; args: unknown } };
+      textParts.push(
+        `[Function Call: ${fnPart.functionCall.name}]\n${JSON.stringify(fnPart.functionCall.args, null, 2)}`,
+      );
+    } else if ('functionResponse' in part) {
+      const fnResPart = part as {
+        functionResponse: { name: string; response: unknown };
+      };
+      textParts.push(
+        `[Function Response: ${fnResPart.functionResponse.name}]\n${JSON.stringify(fnResPart.functionResponse.response, null, 2)}`,
+      );
+    }
+  }
+
+  return textParts.join('\n');
+}
+
+/**
+ * Transforms ChatRecord messages to markdown format.
+ */
+export function transformToMarkdown(
+  messages: ChatRecord[],
+  sessionId: string,
+  startTime: string,
+): string {
+  const lines: string[] = [];
+
+  // Add header with metadata
+  lines.push('# Chat Session Export\n');
+  lines.push(`**Session ID**: ${sessionId}\n`);
+  lines.push(`**Start Time**: ${startTime}\n`);
+  lines.push(`**Exported**: ${new Date().toISOString()}\n`);
+  lines.push('---\n');
+
+  // Process each message
+  for (const record of messages) {
+    if (record.type === 'user') {
+      lines.push('## User\n');
+      const text = extractTextFromContent(record.message);
+      lines.push(`${text}\n`);
+    } else if (record.type === 'assistant') {
+      lines.push('## Assistant\n');
+      const text = extractTextFromContent(record.message);
+      lines.push(`${text}\n`);
+    } else if (record.type === 'tool_result') {
+      lines.push('## Tool Result\n');
+      if (record.toolCallResult) {
+        const resultDisplay = record.toolCallResult.resultDisplay;
+        if (resultDisplay) {
+          lines.push('```\n');
+          lines.push(
+            typeof resultDisplay === 'string'
+              ? resultDisplay
+              : JSON.stringify(resultDisplay, null, 2),
+          );
+          lines.push('\n```\n');
+        }
+      }
+      const text = extractTextFromContent(record.message);
+      if (text) {
+        lines.push(`${text}\n`);
+      }
+    } else if (record.type === 'system') {
+      // Skip system messages or format them minimally
+      if (record.subtype === 'chat_compression') {
+        lines.push('_[Chat history compressed]_\n');
+      }
+    }
+
+    lines.push('\n');
+  }
+
+  return lines.join('');
+}
+
+/**
+ * Loads the HTML template from a remote URL via fetch.
+ * Throws an error if the fetch fails.
+ */
+export async function loadHtmlTemplate(): Promise<string> {
+  try {
+    const response = await fetch(HTML_TEMPLATE_URL);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch HTML template: ${response.status} ${response.statusText}`,
+      );
+    }
+    const template = await response.text();
+    return template;
+  } catch (error) {
+    throw new Error(
+      `Failed to load HTML template from ${HTML_TEMPLATE_URL}: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+}
+
+/**
+ * Prepares export data from conversation.
+ */
+export function prepareExportData(conversation: {
+  sessionId: string;
+  startTime: string;
+  messages: ChatRecord[];
+}): {
+  sessionId: string;
+  startTime: string;
+  messages: ChatRecord[];
+} {
+  return {
+    sessionId: conversation.sessionId,
+    startTime: conversation.startTime,
+    messages: conversation.messages,
+  };
+}
+
+/**
+ * Injects JSON data into the HTML template.
+ */
+export function injectDataIntoHtmlTemplate(
+  template: string,
+  data: {
+    sessionId: string;
+    startTime: string;
+    messages: ChatRecord[];
+  },
+): string {
+  const jsonData = JSON.stringify(data, null, 2);
+  const html = template.replace(
+    /<script id="chat-data" type="application\/json">\s*\/\/ DATA_PLACEHOLDER:.*?\s*<\/script>/s,
+    `<script id="chat-data" type="application/json">\n${jsonData}\n    </script>`,
+  );
+  return html;
+}
+
+/**
+ * Generates a filename with timestamp for export files.
+ */
+export function generateExportFilename(extension: string): string {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return `export-${timestamp}.${extension}`;
+}

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code-core",
-  "version": "0.7.1",
+  "version": "0.7.0",
   "description": "Qwen Code Core",
   "repository": {
     "type": "git",

packages/core/src/config/config.ts

@@ -404,7 +404,7 @@ export class Config {
   private toolRegistry!: ToolRegistry;
   private promptRegistry!: PromptRegistry;
   private subagentManager!: SubagentManager;
-  private skillManager: SkillManager | null = null;
+  private skillManager!: SkillManager;
   private fileSystemService: FileSystemService;
   private contentGeneratorConfig!: ContentGeneratorConfig;
   private contentGeneratorConfigSources: ContentGeneratorConfigSources = {};
@@ -672,10 +672,8 @@ export class Config {
     }
     this.promptRegistry = new PromptRegistry();
     this.subagentManager = new SubagentManager(this);
-    if (this.getExperimentalSkills()) {
-      this.skillManager = new SkillManager(this);
-      await this.skillManager.startWatching();
-    }
+    this.skillManager = new SkillManager(this);
+    await this.skillManager.startWatching();
 
     // Load session subagents if they were provided before initialization
     if (this.sessionSubagents.length > 0) {
@@ -1441,7 +1439,7 @@ export class Config {
     return this.subagentManager;
   }
 
-  getSkillManager(): SkillManager | null {
+  getSkillManager(): SkillManager {
     return this.skillManager;
   }
 

packages/core/src/core/contentGenerator.ts

@@ -270,28 +270,28 @@ export function createContentGeneratorConfig(
 }
 
 export async function createContentGenerator(
-  generatorConfig: ContentGeneratorConfig,
-  config: Config,
+  config: ContentGeneratorConfig,
+  gcConfig: Config,
   isInitialAuth?: boolean,
 ): Promise<ContentGenerator> {
-  const validation = validateModelConfig(generatorConfig, false);
+  const validation = validateModelConfig(config, false);
   if (!validation.valid) {
     throw new Error(validation.errors.map((e) => e.message).join('\n'));
   }
 
-  const authType = generatorConfig.authType;
-  if (!authType) {
-    throw new Error('ContentGeneratorConfig must have an authType');
-  }
-
-  let baseGenerator: ContentGenerator;
-
-  if (authType === AuthType.USE_OPENAI) {
+  if (config.authType === AuthType.USE_OPENAI) {
+    // Import OpenAIContentGenerator dynamically to avoid circular dependencies
     const { createOpenAIContentGenerator } = await import(
       './openaiContentGenerator/index.js'
     );
-    baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
-  } else if (authType === AuthType.QWEN_OAUTH) {
+
+    // Always use OpenAIContentGenerator, logging is controlled by enableOpenAILogging flag
+    const generator = createOpenAIContentGenerator(config, gcConfig);
+    return new LoggingContentGenerator(generator, gcConfig);
+  }
+
+  if (config.authType === AuthType.QWEN_OAUTH) {
+    // Import required classes dynamically
     const { getQwenOAuthClient: getQwenOauthClient } = await import(
       '../qwen/qwenOAuth2.js'
     );
@@ -300,38 +300,44 @@ export async function createContentGenerator(
     );
 
     try {
+      // Get the Qwen OAuth client (now includes integrated token management)
+      // If this is initial auth, require cached credentials to detect missing credentials
       const qwenClient = await getQwenOauthClient(
-        config,
+        gcConfig,
         isInitialAuth ? { requireCachedCredentials: true } : undefined,
       );
-      baseGenerator = new QwenContentGenerator(
-        qwenClient,
-        generatorConfig,
-        config,
-      );
+
+      // Create the content generator with dynamic token management
+      const generator = new QwenContentGenerator(qwenClient, config, gcConfig);
+      return new LoggingContentGenerator(generator, gcConfig);
     } catch (error) {
       throw new Error(
         `${error instanceof Error ? error.message : String(error)}`,
       );
     }
-  } else if (authType === AuthType.USE_ANTHROPIC) {
+  }
+
+  if (config.authType === AuthType.USE_ANTHROPIC) {
     const { createAnthropicContentGenerator } = await import(
       './anthropicContentGenerator/index.js'
     );
-    baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
-  } else if (
-    authType === AuthType.USE_GEMINI ||
-    authType === AuthType.USE_VERTEX_AI
+
+    const generator = createAnthropicContentGenerator(config, gcConfig);
+    return new LoggingContentGenerator(generator, gcConfig);
+  }
+
+  if (
+    config.authType === AuthType.USE_GEMINI ||
+    config.authType === AuthType.USE_VERTEX_AI
   ) {
     const { createGeminiContentGenerator } = await import(
       './geminiContentGenerator/index.js'
     );
-    baseGenerator = createGeminiContentGenerator(generatorConfig, config);
-  } else {
-    throw new Error(
-      `Error creating contentGenerator: Unsupported authType: ${authType}`,
-    );
+    const generator = createGeminiContentGenerator(config, gcConfig);
+    return new LoggingContentGenerator(generator, gcConfig);
   }
 
-  return new LoggingContentGenerator(baseGenerator, config, generatorConfig);
+  throw new Error(
+    `Error creating contentGenerator: Unsupported authType: ${config.authType}`,
+  );
 }

packages/core/src/core/loggingContentGenerator/loggingContentGenerator.test.ts

@@ -12,7 +12,6 @@ import type {
 import { GenerateContentResponse } from '@google/genai';
 import type { Config } from '../../config/config.js';
 import type { ContentGenerator } from '../contentGenerator.js';
-import { AuthType } from '../contentGenerator.js';
 import { LoggingContentGenerator } from './index.js';
 import { OpenAIContentConverter } from '../openaiContentGenerator/converter.js';
 import {
@@ -51,17 +50,14 @@ const convertGeminiResponseToOpenAISpy = vi
     choices: [],
   } as OpenAI.Chat.ChatCompletion);
 
-const createConfig = (overrides: Record<string, unknown> = {}): Config => {
-  const configContent = {
-    authType: 'openai',
-    enableOpenAILogging: false,
-    ...overrides,
-  };
-  return {
-    getContentGeneratorConfig: () => configContent,
-    getAuthType: () => configContent.authType as AuthType | undefined,
-  } as Config;
-};
+const createConfig = (overrides: Record<string, unknown> = {}): Config =>
+  ({
+    getContentGeneratorConfig: () => ({
+      authType: 'openai',
+      enableOpenAILogging: false,
+      ...overrides,
+    }),
+  }) as Config;
 
 const createWrappedGenerator = (
   generateContent: ContentGenerator['generateContent'],
@@ -128,17 +124,13 @@ describe('LoggingContentGenerator', () => {
       ),
       vi.fn(),
     );
-    const generatorConfig = {
-      model: 'test-model',
-      authType: AuthType.USE_OPENAI,
-      enableOpenAILogging: true,
-      openAILoggingDir: 'logs',
-      schemaCompliance: 'openapi_30' as const,
-    };
     const generator = new LoggingContentGenerator(
       wrapped,
-      createConfig(),
-      generatorConfig,
+      createConfig({
+        enableOpenAILogging: true,
+        openAILoggingDir: 'logs',
+        schemaCompliance: 'openapi_30',
+      }),
     );
 
     const request = {
@@ -233,15 +225,9 @@ describe('LoggingContentGenerator', () => {
       vi.fn().mockRejectedValue(error),
       vi.fn(),
     );
-    const generatorConfig = {
-      model: 'test-model',
-      authType: AuthType.USE_OPENAI,
-      enableOpenAILogging: true,
-    };
     const generator = new LoggingContentGenerator(
       wrapped,
-      createConfig(),
-      generatorConfig,
+      createConfig({ enableOpenAILogging: true }),
     );
 
     const request = {
@@ -307,15 +293,9 @@ describe('LoggingContentGenerator', () => {
         })(),
       ),
     );
-    const generatorConfig = {
-      model: 'test-model',
-      authType: AuthType.USE_OPENAI,
-      enableOpenAILogging: true,
-    };
     const generator = new LoggingContentGenerator(
       wrapped,
-      createConfig(),
-      generatorConfig,
+      createConfig({ enableOpenAILogging: true }),
     );
 
     const request = {
@@ -365,15 +345,9 @@ describe('LoggingContentGenerator', () => {
         })(),
       ),
     );
-    const generatorConfig = {
-      model: 'test-model',
-      authType: AuthType.USE_OPENAI,
-      enableOpenAILogging: true,
-    };
     const generator = new LoggingContentGenerator(
       wrapped,
-      createConfig(),
-      generatorConfig,
+      createConfig({ enableOpenAILogging: true }),
     );
 
     const request = {

packages/core/src/core/loggingContentGenerator/loggingContentGenerator.ts

@@ -31,10 +31,7 @@ import {
   logApiRequest,
   logApiResponse,
 } from '../../telemetry/loggers.js';
-import type {
-  ContentGenerator,
-  ContentGeneratorConfig,
-} from '../contentGenerator.js';
+import type { ContentGenerator } from '../contentGenerator.js';
 import { isStructuredError } from '../../utils/quotaErrorDetection.js';
 import { OpenAIContentConverter } from '../openaiContentGenerator/converter.js';
 import { OpenAILogger } from '../../utils/openaiLogger.js';
@@ -53,11 +50,9 @@ export class LoggingContentGenerator implements ContentGenerator {
   constructor(
     private readonly wrapped: ContentGenerator,
     private readonly config: Config,
-    generatorConfig: ContentGeneratorConfig,
   ) {
-    // Extract fields needed for initialization from passed config
-    // (config.getContentGeneratorConfig() may not be available yet during refreshAuth)
-    if (generatorConfig.enableOpenAILogging) {
+    const generatorConfig = this.config.getContentGeneratorConfig();
+    if (generatorConfig?.enableOpenAILogging) {
       this.openaiLogger = new OpenAILogger(generatorConfig.openAILoggingDir);
       this.schemaCompliance = generatorConfig.schemaCompliance;
     }
@@ -94,7 +89,7 @@ export class LoggingContentGenerator implements ContentGenerator {
         model,
         durationMs,
         prompt_id,
-        this.config.getAuthType(),
+        this.config.getContentGeneratorConfig()?.authType,
         usageMetadata,
         responseText,
       ),
@@ -131,7 +126,7 @@ export class LoggingContentGenerator implements ContentGenerator {
         errorMessage,
         durationMs,
         prompt_id,
-        this.config.getAuthType(),
+        this.config.getContentGeneratorConfig()?.authType,
         errorType,
         errorStatus,
       ),

packages/core/src/skills/skill-manager.ts

@@ -235,7 +235,6 @@ export class SkillManager {
     }
 
     this.watchStarted = true;
-    await this.ensureUserSkillsDir();
     await this.refreshCache();
     this.updateWatchersFromCache();
   }
@@ -487,14 +486,29 @@ export class SkillManager {
   }
 
   private updateWatchersFromCache(): void {
-    const watchTargets = new Set<string>(
-      (['project', 'user'] as const)
-        .map((level) => this.getSkillsBaseDir(level))
-        .filter((baseDir) => fsSync.existsSync(baseDir)),
-    );
+    const desiredPaths = new Set<string>();
+
+    for (const level of ['project', 'user'] as const) {
+      const baseDir = this.getSkillsBaseDir(level);
+      const parentDir = path.dirname(baseDir);
+      if (fsSync.existsSync(parentDir)) {
+        desiredPaths.add(parentDir);
+      }
+      if (fsSync.existsSync(baseDir)) {
+        desiredPaths.add(baseDir);
+      }
+
+      const levelSkills = this.skillsCache?.get(level) || [];
+      for (const skill of levelSkills) {
+        const skillDir = path.dirname(skill.filePath);
+        if (fsSync.existsSync(skillDir)) {
+          desiredPaths.add(skillDir);
+        }
+      }
+    }
 
     for (const existingPath of this.watchers.keys()) {
-      if (!watchTargets.has(existingPath)) {
+      if (!desiredPaths.has(existingPath)) {
         void this.watchers
           .get(existingPath)
           ?.close()
@@ -508,7 +522,7 @@ export class SkillManager {
       }
     }
 
-    for (const watchPath of watchTargets) {
+    for (const watchPath of desiredPaths) {
       if (this.watchers.has(watchPath)) {
         continue;
       }
@@ -543,16 +557,4 @@ export class SkillManager {
       void this.refreshCache().then(() => this.updateWatchersFromCache());
     }, 150);
   }
-
-  private async ensureUserSkillsDir(): Promise<void> {
-    const baseDir = this.getSkillsBaseDir('user');
-    try {
-      await fs.mkdir(baseDir, { recursive: true });
-    } catch (error) {
-      console.warn(
-        `Failed to create user skills directory at ${baseDir}:`,
-        error,
-      );
-    }
-  }
 }

packages/core/src/tools/skill.ts

@@ -53,7 +53,7 @@ export class SkillTool extends BaseDeclarativeTool<SkillParams, ToolResult> {
       false, // canUpdateOutput
     );
 
-    this.skillManager = config.getSkillManager()!;
+    this.skillManager = config.getSkillManager();
     this.skillManager.addChangeListener(() => {
       void this.refreshSkills();
     });

packages/test-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code-test-utils",
-  "version": "0.7.1",
+  "version": "0.7.0",
   "private": true,
   "main": "src/index.ts",
   "license": "Apache-2.0",

packages/vscode-ide-companion/README.md

@@ -1,11 +1,6 @@
 # Qwen Code Companion
 
-[![Version](https://img.shields.io/visual-studio-marketplace/v/qwenlm.qwen-code-vscode-ide-companion)](https://marketplace.visualstudio.com/items?itemName=qwenlm.qwen-code-vscode-ide-companion)
-[![VS Code Installs](https://img.shields.io/visual-studio-marketplace/i/qwenlm.qwen-code-vscode-ide-companion)](https://marketplace.visualstudio.com/items?itemName=qwenlm.qwen-code-vscode-ide-companion)
-[![Open VSX Downloads](https://img.shields.io/open-vsx/dt/qwenlm/qwen-code-vscode-ide-companion)](https://open-vsx.org/extension/qwenlm/qwen-code-vscode-ide-companion)
-[![Rating](https://img.shields.io/visual-studio-marketplace/r/qwenlm.qwen-code-vscode-ide-companion)](https://marketplace.visualstudio.com/items?itemName=qwenlm.qwen-code-vscode-ide-companion)
-
-Seamlessly integrate [Qwen Code](https://github.com/QwenLM/qwen-code) into Visual Studio Code with native IDE features and an intuitive chat interface. This extension bundles everything you need — no additional installation required.
+Seamlessly integrate [Qwen Code](https://github.com/QwenLM/qwen-code) into Visual Studio Code with native IDE features and an intuitive interface. This extension bundles everything you need to get started immediately.
 
 ## Demo
 
@@ -16,7 +11,7 @@ Seamlessly integrate [Qwen Code](https://github.com/QwenLM/qwen-code) into Visua
 
 ## Features
 
-- **Native IDE experience**: Dedicated Qwen Code Chat panel accessed via the Qwen icon in the editor title bar
+- **Native IDE experience**: Dedicated Qwen Code sidebar panel accessed via the Qwen icon
 - **Native diffing**: Review, edit, and accept changes in VS Code's diff view
 - **Auto-accept edits mode**: Automatically apply Qwen's changes as they're made
 - **File management**: @-mention files or attach files and images using the system file picker
@@ -25,46 +20,73 @@ Seamlessly integrate [Qwen Code](https://github.com/QwenLM/qwen-code) into Visua
 
 ## Requirements
 
-- Visual Studio Code 1.85.0 or newer (also works with Cursor, Windsurf, and other VS Code-based editors)
+- Visual Studio Code 1.85.0 or newer
 
-## Quick Start
+## Installation
 
-1. **Install** from the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=qwenlm.qwen-code-vscode-ide-companion) or [Open VSX Registry](https://open-vsx.org/extension/qwenlm/qwen-code-vscode-ide-companion)
+1. Install from the VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=qwenlm.qwen-code-vscode-ide-companion
 
-2. **Open the Chat panel** using one of these methods:
-   - Click the **Qwen icon** in the top-right corner of the editor
-   - Run `Qwen Code: Open` from the Command Palette (`Cmd+Shift+P` / `Ctrl+Shift+P`)
+2. Two ways to use
+   - Chat panel: Click the Qwen icon in the Activity Bar, or run `Qwen Code: Open` from the Command Palette (`Cmd+Shift+P` / `Ctrl+Shift+P`).
+   - Terminal session (classic): Run `Qwen Code: Run` to launch a session in the integrated terminal (bundled CLI).
 
-3. **Start chatting** — Ask Qwen to help with coding tasks, explain code, fix bugs, or write new features
+## Development and Debugging
 
-## Commands
+To debug and develop this extension locally:
 
-| Command                          | Description                                            |
-| -------------------------------- | ------------------------------------------------------ |
-| `Qwen Code: Open`                | Open the Qwen Code Chat panel                          |
-| `Qwen Code: Run`                 | Launch a classic terminal session with the bundled CLI |
-| `Qwen Code: Accept Current Diff` | Accept the currently displayed diff                    |
-| `Qwen Code: Close Diff Editor`   | Close/reject the current diff                          |
+1. **Clone the repository**
 
-## Feedback & Issues
+   ```bash
+   git clone https://github.com/QwenLM/qwen-code.git
+   cd qwen-code
+   ```
 
-- 🐛 [Report bugs](https://github.com/QwenLM/qwen-code/issues/new?template=bug_report.yml&labels=bug,vscode-ide-companion)
-- 💡 [Request features](https://github.com/QwenLM/qwen-code/issues/new?template=feature_request.yml&labels=enhancement,vscode-ide-companion)
-- 📖 [Documentation](https://qwenlm.github.io/qwen-code-docs/)
-- 📋 [Changelog](https://github.com/QwenLM/qwen-code/releases)
+2. **Install dependencies**
 
-## Contributing
+   ```bash
+   npm install
+   # or if using pnpm
+   pnpm install
+   ```
 
-We welcome contributions! See our [Contributing Guide](https://github.com/QwenLM/qwen-code/blob/main/CONTRIBUTING.md) for details on:
+3. **Start debugging**
 
-- Setting up the development environment
-- Building and debugging the extension locally
-- Submitting pull requests
+   ```bash
+   code .  # Open the project root in VS Code
+   ```
+   - Open the `packages/vscode-ide-companion/src/extension.ts` file
+   - Open Debug panel (`Ctrl+Shift+D` or `Cmd+Shift+D`)
+   - Select **"Launch Companion VS Code Extension"** from the debug dropdown
+   - Press `F5` to launch Extension Development Host
+
+4. **Make changes and reload**
+   - Edit the source code in the original VS Code window
+   - To see your changes, reload the Extension Development Host window by:
+     - Pressing `Ctrl+R` (Windows/Linux) or `Cmd+R` (macOS)
+     - Or clicking the "Reload" button in the debug toolbar
+
+5. **View logs and debug output**
+   - Open the Debug Console in the original VS Code window to see extension logs
+   - In the Extension Development Host window, open Developer Tools with `Help > Toggle Developer Tools` to see webview logs
+
+## Build for Production
+
+To build the extension for distribution:
+
+```bash
+npm run compile
+# or
+pnpm run compile
+```
+
+To package the extension as a VSIX file:
+
+```bash
+npx vsce package
+# or
+pnpm vsce package
+```
 
 ## Terms of Service and Privacy Notice
 
 By installing this extension, you agree to the [Terms of Service](https://github.com/QwenLM/qwen-code/blob/main/docs/tos-privacy.md).
-
-## License
-
-[Apache-2.0](https://github.com/QwenLM/qwen-code/blob/main/LICENSE)

packages/vscode-ide-companion/package.json

@@ -2,7 +2,7 @@
   "name": "qwen-code-vscode-ide-companion",
   "displayName": "Qwen Code Companion",
   "description": "Enable Qwen Code with direct access to your VS Code workspace.",
-  "version": "0.7.1",
+  "version": "0.7.0",
   "publisher": "qwenlm",
   "icon": "assets/icon.png",
   "repository": {

packages/vscode-ide-companion/src/extension.ts

@@ -314,32 +314,34 @@ export async function activate(context: vscode.ExtensionContext) {
             'cli.js',
           ).fsPath;
           const execPath = process.execPath;
+          const lowerExecPath = execPath.toLowerCase();
+          const needsElectronRunAsNode =
+            lowerExecPath.includes('code') ||
+            lowerExecPath.includes('electron');
 
+          let qwenCmd: string;
           const terminalOptions: vscode.TerminalOptions = {
             name: `Qwen Code (${selectedFolder.name})`,
             cwd: selectedFolder.uri.fsPath,
             location,
           };
 
-          let qwenCmd: string;
-
           if (isWindows) {
-            // On Windows, try multiple strategies to find a Node.js runtime:
-            // 1. Check if VSCode ships a standalone node.exe alongside Code.exe
-            // 2. Check VSCode's internal Node.js in resources directory
-            // 3. Fall back to using Code.exe with ELECTRON_RUN_AS_NODE=1
+            // Use system Node via cmd.exe; avoid PowerShell parsing issues
             const quoteCmd = (s: string) => `"${s.replace(/"/g, '""')}"`;
             const cliQuoted = quoteCmd(cliEntry);
             // TODO: @yiliang114, temporarily run through node, and later hope to decouple from the local node
             qwenCmd = `node ${cliQuoted}`;
             terminalOptions.shellPath = process.env.ComSpec;
           } else {
-            // macOS/Linux: All VSCode-like IDEs (VSCode, Cursor, Windsurf, etc.)
-            // are Electron-based, so we always need ELECTRON_RUN_AS_NODE=1
-            // to run Node.js scripts using the IDE's bundled runtime.
             const quotePosix = (s: string) => `"${s.replace(/"/g, '\\"')}"`;
             const baseCmd = `${quotePosix(execPath)} ${quotePosix(cliEntry)}`;
-            qwenCmd = `ELECTRON_RUN_AS_NODE=1 ${baseCmd}`;
+            if (needsElectronRunAsNode) {
+              // macOS Electron helper needs ELECTRON_RUN_AS_NODE=1;
+              qwenCmd = `ELECTRON_RUN_AS_NODE=1 ${baseCmd}`;
+            } else {
+              qwenCmd = baseCmd;
+            }
           }
 
           const terminal = vscode.window.createTerminal(terminalOptions);