feat(config): add Claude IDE extension setup flow

tests/unit/commands/help-command-parity.test.ts

@@ -40,4 +40,22 @@ describe('help command parity', () => {
     expect(rendered.includes('ccs llamacpp')).toBe(true);
     expect(rendered.includes('http://127.0.0.1:8080')).toBe(true);
   });
+
+  test('root help documents Claude IDE extension setup surfaces', async () => {
+    const lines: string[] = [];
+    console.log = (...args: unknown[]) => {
+      lines.push(args.map((arg) => String(arg)).join(' '));
+    };
+
+    await handleHelpCommand();
+
+    const rendered = stripAnsi(lines.join('\n'));
+    expect(rendered.includes('Claude IDE Extension setup page')).toBe(true);
+    expect(rendered.includes('ccs env <profile> --format claude-extension --ide vscode')).toBe(
+      true
+    );
+    expect(rendered.includes('ccs env <profile> --format claude-extension --ide windsurf')).toBe(
+      true
+    );
+  });
 });

tests/unit/commands/persist-command-handler.test.ts

@@ -4,6 +4,8 @@ import * as os from 'os';
 import * as path from 'path';
 import * as lockfile from 'proper-lockfile';
 import { handlePersistCommand } from '../../../src/commands/persist-command';
+import { createEmptyUnifiedConfig } from '../../../src/config/unified-config-types';
+import { saveUnifiedConfig } from '../../../src/config/unified-config-loader';
 
 interface RestoreFixture {
   claudeDir: string;
@@ -16,6 +18,7 @@ interface RestoreFixture {
 
 let tempRoot: string;
 let originalClaudeConfigDir: string | undefined;
+let originalCcsHome: string | undefined;
 let originalProcessExit: typeof process.exit;
 let originalFsOpen: typeof fs.promises.open;
 let originalFsRename: typeof fs.promises.rename;
@@ -66,9 +69,11 @@ function stubProcessExit(): void {
 beforeEach(async () => {
   tempRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'ccs-persist-handler-test-'));
   originalClaudeConfigDir = process.env.CLAUDE_CONFIG_DIR;
+  originalCcsHome = process.env.CCS_HOME;
   originalProcessExit = process.exit;
   originalFsOpen = fs.promises.open;
   originalFsRename = fs.promises.rename;
+  process.env.CCS_HOME = tempRoot;
 });
 
 afterEach(async () => {
@@ -82,6 +87,12 @@ afterEach(async () => {
     process.env.CLAUDE_CONFIG_DIR = originalClaudeConfigDir;
   }
 
+  if (originalCcsHome === undefined) {
+    delete process.env.CCS_HOME;
+  } else {
+    process.env.CCS_HOME = originalCcsHome;
+  }
+
   if (tempRoot) {
     await fs.promises.rm(tempRoot, { recursive: true, force: true });
   }
@@ -271,3 +282,105 @@ describe('persist command restore failure handling', () => {
     }
   });
 });
+
+describe('persist command Claude extension parity', () => {
+  async function writeUnifiedConfig(): Promise<void> {
+    const config = createEmptyUnifiedConfig();
+    config.accounts.work = {
+      created: '2026-03-15T00:00:00.000Z',
+      last_used: null,
+      context_mode: 'isolated',
+    };
+    config.default = 'work';
+    config.profiles.glm = {
+      type: 'api',
+      settings: path.join(tempRoot, '.ccs', 'glm.settings.json'),
+    };
+
+    await fs.promises.mkdir(path.join(tempRoot, '.ccs'), { recursive: true });
+    await fs.promises.writeFile(
+      path.join(tempRoot, '.ccs', 'glm.settings.json'),
+      JSON.stringify(
+        {
+          env: {
+            ANTHROPIC_BASE_URL: 'https://api.example.test',
+            ANTHROPIC_API_KEY: 'sk-ant-test-123456',
+            ANTHROPIC_MODEL: 'claude-sonnet-4-5',
+          },
+        },
+        null,
+        2
+      ) + '\n',
+      'utf8'
+    );
+    saveUnifiedConfig(config);
+  }
+
+  it('persists account profiles via CLAUDE_CONFIG_DIR and clears stale managed env keys', async () => {
+    await writeUnifiedConfig();
+
+    const settingsPath = path.join(tempRoot, '.claude', 'settings.json');
+    await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
+    await fs.promises.writeFile(
+      settingsPath,
+      JSON.stringify(
+        {
+          env: {
+            ANTHROPIC_API_KEY: 'stale-key',
+            ANTHROPIC_BASE_URL: 'http://127.0.0.1:8317',
+            KEEP_ME: 'still-here',
+          },
+        },
+        null,
+        2
+      ) + '\n',
+      'utf8'
+    );
+
+    await handlePersistCommand(['work', '--yes']);
+
+    const persisted = JSON.parse(await fs.promises.readFile(settingsPath, 'utf8')) as {
+      env: Record<string, string>;
+    };
+
+    expect(persisted.env.KEEP_ME).toBe('still-here');
+    expect(persisted.env.ANTHROPIC_API_KEY).toBeUndefined();
+    expect(persisted.env.ANTHROPIC_BASE_URL).toBeUndefined();
+    expect(persisted.env.CLAUDE_CONFIG_DIR).toBe(path.join(tempRoot, '.ccs', 'instances', 'work'));
+    expect(fs.existsSync(persisted.env.CLAUDE_CONFIG_DIR)).toBe(true);
+  });
+
+  it('persists default profile using mapped account continuity and preserves unrelated env', async () => {
+    await writeUnifiedConfig();
+
+    const settingsPath = path.join(tempRoot, '.claude', 'settings.json');
+    await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
+    await fs.promises.writeFile(
+      settingsPath,
+      JSON.stringify(
+        {
+          env: {
+            ANTHROPIC_AUTH_TOKEN: 'stale-token',
+            ANTHROPIC_MODEL: 'stale-model',
+            KEEP_ME: 'still-here',
+          },
+        },
+        null,
+        2
+      ) + '\n',
+      'utf8'
+    );
+
+    await handlePersistCommand(['default', '--yes']);
+
+    const persisted = JSON.parse(await fs.promises.readFile(settingsPath, 'utf8')) as {
+      env: Record<string, string>;
+    };
+
+    expect(persisted.env.KEEP_ME).toBe('still-here');
+    expect(persisted.env.ANTHROPIC_AUTH_TOKEN).toBeUndefined();
+    expect(persisted.env.ANTHROPIC_MODEL).toBeUndefined();
+    expect(persisted.env.CLAUDE_CONFIG_DIR).toBe(path.join(tempRoot, '.ccs', 'instances', 'work'));
+    expect(fs.existsSync(persisted.env.CLAUDE_CONFIG_DIR)).toBe(true);
+  });
+});

tests/unit/web-server/claude-extension-routes.test.ts

@@ -0,0 +1,142 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
+import express from 'express';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import type { Server } from 'http';
+import claudeExtensionRoutes from '../../../src/web-server/routes/claude-extension-routes';
+import { createEmptyUnifiedConfig } from '../../../src/config/unified-config-types';
+import { saveUnifiedConfig } from '../../../src/config/unified-config-loader';
+
+describe('web-server claude-extension-routes', () => {
+  let server: Server;
+  let baseUrl = '';
+  let tempHome = '';
+  let originalCcsHome: string | undefined;
+
+  beforeAll(async () => {
+    const app = express();
+    app.use(express.json());
+    app.use('/api/claude-extension', claudeExtensionRoutes);
+
+    await new Promise<void>((resolve, reject) => {
+      server = app.listen(0, '127.0.0.1');
+      const handleError = (error: Error) => reject(error);
+      server.once('error', handleError);
+      server.once('listening', () => {
+        server.off('error', handleError);
+        resolve();
+      });
+    });
+
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+      throw new Error('Unable to resolve test server port');
+    }
+    baseUrl = `http://127.0.0.1:${address.port}`;
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  });
+
+  beforeEach(() => {
+    tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-claude-extension-routes-'));
+    originalCcsHome = process.env.CCS_HOME;
+    process.env.CCS_HOME = tempHome;
+
+    const ccsDir = path.join(tempHome, '.ccs');
+    fs.mkdirSync(ccsDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(ccsDir, 'glm.settings.json'),
+      JSON.stringify(
+        {
+          env: {
+            ANTHROPIC_BASE_URL: 'https://api.example.test',
+            ANTHROPIC_API_KEY: 'sk-ant-test-123456',
+            ANTHROPIC_MODEL: 'claude-sonnet-4-5',
+          },
+        },
+        null,
+        2
+      ) + '\n'
+    );
+
+    const config = createEmptyUnifiedConfig();
+    config.profiles.glm = {
+      type: 'api',
+      settings: path.join(ccsDir, 'glm.settings.json'),
+    };
+    config.accounts.work = {
+      created: '2026-03-15T00:00:00.000Z',
+      last_used: null,
+      context_mode: 'isolated',
+    };
+    config.default = 'work';
+    saveUnifiedConfig(config);
+  });
+
+  afterEach(() => {
+    if (originalCcsHome !== undefined) process.env.CCS_HOME = originalCcsHome;
+    else delete process.env.CCS_HOME;
+
+    if (tempHome && fs.existsSync(tempHome)) {
+      fs.rmSync(tempHome, { recursive: true, force: true });
+    }
+  });
+
+  it('lists profile options and IDE host targets', async () => {
+    const response = await fetch(`${baseUrl}/api/claude-extension/profiles`);
+    expect(response.status).toBe(200);
+
+    const payload = (await response.json()) as {
+      profiles: Array<{ name: string }>;
+      hosts: Array<{ id: string }>;
+    };
+
+    expect(payload.profiles.some((profile) => profile.name === 'default')).toBe(true);
+    expect(payload.profiles.some((profile) => profile.name === 'glm')).toBe(true);
+    expect(payload.profiles.some((profile) => profile.name === 'work')).toBe(true);
+    expect(payload.profiles.some((profile) => profile.name === 'gemini')).toBe(true);
+    expect(payload.hosts.map((host) => host.id)).toEqual(['vscode', 'cursor', 'windsurf']);
+  });
+
+  it('renders VS Code setup for API profiles with disableLoginPrompt', async () => {
+    const response = await fetch(`${baseUrl}/api/claude-extension/setup?profile=glm&host=vscode`);
+    expect(response.status).toBe(200);
+
+    const payload = (await response.json()) as {
+      host: { settingsKey: string; disableLoginPromptKey?: string };
+      ideSettings: { json: string };
+      sharedSettings: { command: string; json: string };
+    };
+
+    expect(payload.host.settingsKey).toBe('claudeCode.environmentVariables');
+    expect(payload.host.disableLoginPromptKey).toBe('claudeCode.disableLoginPrompt');
+    expect(payload.ideSettings.json).toContain('"claudeCode.disableLoginPrompt": true');
+    expect(payload.ideSettings.json).toContain('"ANTHROPIC_API_KEY"');
+    expect(payload.sharedSettings.command).toBe('ccs persist glm');
+    expect(payload.sharedSettings.json).toContain('"env"');
+  });
+
+  it('renders Windsurf setup for default account resolution via CLAUDE_CONFIG_DIR', async () => {
+    const response = await fetch(
+      `${baseUrl}/api/claude-extension/setup?profile=default&host=windsurf`
+    );
+    expect(response.status).toBe(200);
+
+    const payload = (await response.json()) as {
+      profile: { profileType: string; resolvedProfileName: string };
+      host: { settingsKey: string };
+      ideSettings: { json: string };
+      sharedSettings: { command: string };
+    };
+
+    expect(payload.profile.profileType).toBe('account');
+    expect(payload.profile.resolvedProfileName).toBe('work');
+    expect(payload.host.settingsKey).toBe('claude-code.environmentVariables');
+    expect(payload.ideSettings.json).toContain('"claude-code.environmentVariables"');
+    expect(payload.ideSettings.json).toContain('"CLAUDE_CONFIG_DIR"');
+    expect(payload.sharedSettings.command).toBe('ccs persist default');
+  });
+});