@axhub/genie 0.2.7 → 0.2.8

package/server/routes/cc-connect.js

@@ -0,0 +1,1131 @@
+import express from 'express';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import crossSpawn from 'cross-spawn';
+import TOML from '@iarna/toml';
+import { detectProviderInstallationStatus } from './cli-auth.js';
+import { resolveCommandPath } from '../utils/resolveCommandPath.js';
+import { spawnCommand } from '../utils/spawnCommand.js';
+import {
+  CC_CONNECT_CONFIG_PATH,
+  CC_CONNECT_PLATFORMS,
+  CC_CONNECT_PROVIDERS,
+  createSetupConfigContent,
+  extractPlatformOptionsFromConfigContent,
+  getCcConnectManagedProjectName,
+  getPlatformConnection,
+  listCcConnectPlatformSummaries,
+  readCcConnectState,
+  removePlatformConnection,
+  upsertPlatformConnection,
+  writeCcConnectConfig,
+  writeCcConnectState
+} from '../utils/ccConnectState.js';
+
+const router = express.Router();
+
+const CC_CONNECT_COMMAND = 'cc-connect';
+const COMMAND_TIMEOUT_MS = 5000;
+const INSTALL_TIMEOUT_MS = 120000;
+const DAEMON_COMMAND_TIMEOUT_MS = 20000;
+const LOG_PREFIX = '[cc-connect]';
+const SESSION_TERMINAL_GRACE_MS = 60000;
+const setupSessions = new Map();
+
+const PROVIDER_ORDER = CC_CONNECT_PROVIDERS.map((provider) => provider.id);
+const PLATFORM_MAP = Object.fromEntries(CC_CONNECT_PLATFORMS.map((platform) => [platform.id, platform]));
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function mergeAvailableProviders(configuredProviders = [], installedProviderIds = [], activeProvider = null) {
+  const available = new Set();
+
+  for (const providerId of configuredProviders) {
+    if (PROVIDER_ORDER.includes(providerId)) {
+      available.add(providerId);
+    }
+  }
+
+  for (const providerId of installedProviderIds) {
+    if (PROVIDER_ORDER.includes(providerId)) {
+      available.add(providerId);
+    }
+  }
+
+  if (activeProvider && PROVIDER_ORDER.includes(activeProvider)) {
+    available.add(activeProvider);
+  }
+
+  return PROVIDER_ORDER.filter((providerId) => available.has(providerId));
+}
+
+function withAvailableProviders(connection, installedProviderIds) {
+  if (!connection) {
+    return null;
+  }
+
+  const configuredProviders = mergeAvailableProviders(
+    connection.configuredProviders,
+    installedProviderIds,
+    connection.activeProvider
+  );
+
+  return {
+    ...connection,
+    configuredProviders
+  };
+}
+
+function buildPlatformSummaries(state, installedProviderIds) {
+  return listCcConnectPlatformSummaries(state).map((platform) => {
+    if (!platform.connected) {
+      return platform;
+    }
+
+    const connection = getPlatformConnection(state, platform.id);
+    const mergedProviders = mergeAvailableProviders(
+      connection?.configuredProviders || [],
+      installedProviderIds,
+      connection?.activeProvider || null
+    );
+
+    return {
+      ...platform,
+      configuredProviders: mergedProviders
+    };
+  });
+}
+
+function runCommandSync({ command, args = [], timeoutMs = COMMAND_TIMEOUT_MS, cwd = process.cwd(), env = process.env }) {
+  const runner = process.platform === 'win32' ? crossSpawn.sync : spawnSync;
+  const result = runner(command, args, {
+    cwd,
+    env,
+    encoding: 'utf8',
+    timeout: timeoutMs
+  });
+
+  return {
+    status: result.status,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    error: result.error || null
+  };
+}
+
+function normalizePlatformId(value) {
+  const platformId = String(value || '').trim().toLowerCase();
+  return PLATFORM_MAP[platformId] ? platformId : null;
+}
+
+function normalizeProviderId(value) {
+  const providerId = String(value || '').trim().toLowerCase();
+  return PROVIDER_ORDER.includes(providerId) ? providerId : null;
+}
+
+function buildCommandEnv() {
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+  return env;
+}
+
+function getNpmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+async function getCcConnectStatus() {
+  const resolved = await resolveCommandPath(CC_CONNECT_COMMAND);
+  if (!resolved.found) {
+    return {
+      installed: false,
+      version: null,
+      isBeta: false,
+      resolvedPath: null
+    };
+  }
+
+  const result = runCommandSync({
+    command: resolved.resolvedPath || CC_CONNECT_COMMAND,
+    args: ['--version'],
+    timeoutMs: COMMAND_TIMEOUT_MS,
+    env: buildCommandEnv()
+  });
+  const version = String(result.stdout || '').trim() || null;
+
+  return {
+    installed: true,
+    version,
+    isBeta: Boolean(version && /beta|alpha|rc|pre/i.test(version)),
+    resolvedPath: resolved.resolvedPath || null
+  };
+}
+
+async function getProviderStatuses() {
+  const statuses = await Promise.all(
+    PROVIDER_ORDER.map(async (providerId) => {
+      try {
+        const status = await detectProviderInstallationStatus(providerId);
+        return {
+          id: providerId,
+          label: CC_CONNECT_PROVIDERS.find((provider) => provider.id === providerId)?.label || providerId,
+          ...status
+        };
+      } catch (error) {
+        return {
+          id: providerId,
+          label: CC_CONNECT_PROVIDERS.find((provider) => provider.id === providerId)?.label || providerId,
+          success: false,
+          installed: false,
+          error: error.message
+        };
+      }
+    })
+  );
+
+  return statuses;
+}
+
+async function getInstalledProviderIds() {
+  const statuses = await getProviderStatuses();
+  return statuses.filter((status) => status.installed).map((status) => status.id);
+}
+
+function cleanupSessionArtifacts(session) {
+  if (!session) {
+    return;
+  }
+
+  for (const filePath of [session.tempConfigPath, session.qrImagePath]) {
+    if (!filePath) {
+      continue;
+    }
+
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    } catch {
+      // Best-effort cleanup.
+    }
+  }
+}
+
+function cleanupSession(sessionId) {
+  const session = setupSessions.get(sessionId);
+  if (!session) {
+    return;
+  }
+
+  if (session.process && !session.process.killed) {
+    try {
+      session.process.kill('SIGTERM');
+    } catch {
+      // Ignore child cleanup failures.
+    }
+  }
+
+  cleanupSessionArtifacts(session);
+  setupSessions.delete(sessionId);
+}
+
+function scheduleFinishedSessionCleanup(sessionId) {
+  setTimeout(() => {
+    cleanupSession(sessionId);
+  }, SESSION_TERMINAL_GRACE_MS);
+}
+
+function parseQrStatusOutput(session, output) {
+  const combinedOutput = String(output || '');
+
+  const urlMatch = combinedOutput.match(/https?:\/\/[^\s"'<>]+/);
+  if (urlMatch && !session.qrUrl) {
+    session.qrUrl = urlMatch[0];
+    session.status = 'pending';
+    session.message = 'Scan the QR code to continue.';
+  }
+
+  if (session.qrImagePath && !session.qrImageBase64 && fs.existsSync(session.qrImagePath)) {
+    try {
+      session.qrImageBase64 = fs.readFileSync(session.qrImagePath).toString('base64');
+      session.status = 'pending';
+      session.message = 'Scan the QR code to continue.';
+    } catch {
+      // Ignore partially-written image files and retry on next chunk.
+    }
+  }
+
+  if (/已扫码|scann?ed|confirm on (?:your )?phone|confirm/i.test(combinedOutput) && session.status === 'pending') {
+    session.status = 'scanned';
+    session.message = 'QR code scanned. Confirm on your device to finish setup.';
+  }
+
+  if (/token.*written|setup.*complete|登录成功|绑定成功|success/i.test(combinedOutput)) {
+    session.message = 'Connection completed. Applying runtime configuration...';
+  }
+}
+
+function buildShortErrorMessage(result) {
+  const stderr = String(result?.stderr || '').trim();
+  if (stderr) {
+    return stderr.replace(/\s+/g, ' ').slice(0, 260);
+  }
+
+  const stdout = String(result?.stdout || '').trim();
+  if (stdout) {
+    return stdout.replace(/\s+/g, ' ').slice(0, 260);
+  }
+
+  if (result?.error?.message) {
+    return result.error.message;
+  }
+
+  return 'Unknown error';
+}
+
+function runCcConnectDaemonCommand(args, timeoutMs = DAEMON_COMMAND_TIMEOUT_MS) {
+  return runCommandSync({
+    command: CC_CONNECT_COMMAND,
+    args,
+    timeoutMs,
+    env: buildCommandEnv()
+  });
+}
+
+function startCcConnectViaDaemon(configPath) {
+  const statusResult = runCcConnectDaemonCommand(['daemon', 'status']);
+  const isRunning = statusResult.status === 0 && /status:\s+running/i.test(statusResult.stdout || '');
+
+  if (isRunning) {
+    const restartResult = runCcConnectDaemonCommand(['daemon', 'restart']);
+    if (restartResult.status === 0) {
+      return { ok: true, detail: 'cc-connect daemon restarted with the latest configuration.' };
+    }
+
+    return {
+      ok: false,
+      detail: `Configuration written, but daemon restart failed: ${buildShortErrorMessage(restartResult)}`
+    };
+  }
+
+  const startResult = runCcConnectDaemonCommand(['daemon', 'start']);
+  if (startResult.status === 0) {
+    return { ok: true, detail: 'cc-connect daemon started with the latest configuration.' };
+  }
+
+  const installResult = runCcConnectDaemonCommand(['daemon', 'install', '--config', configPath], 60000);
+  if (installResult.status === 0) {
+    return { ok: true, detail: 'cc-connect daemon installed and started.' };
+  }
+
+  return {
+    ok: false,
+    detail: `Configuration written, but daemon start failed: ${buildShortErrorMessage(installResult)}`
+  };
+}
+
+function startCcConnectDetached(configPath) {
+  try {
+    const child = spawnCommand(CC_CONNECT_COMMAND, ['--config', configPath], {
+      detached: true,
+      stdio: 'ignore',
+      env: buildCommandEnv(),
+      windowsHide: true
+    });
+    child.unref();
+    return { ok: true, detail: 'cc-connect started in the background.' };
+  } catch (error) {
+    return {
+      ok: false,
+      detail: `Configuration written, but background start failed: ${error.message}`
+    };
+  }
+}
+
+function ensureCcConnectDaemonRunning(configPath) {
+  if (process.platform === 'win32') {
+    return startCcConnectDetached(configPath);
+  }
+
+  return startCcConnectViaDaemon(configPath);
+}
+
+function stopCcConnectDaemon() {
+  try {
+    runCcConnectDaemonCommand(['daemon', 'stop']);
+  } catch {
+    // Ignore stop failures.
+  }
+
+  try {
+    runCcConnectDaemonCommand(['daemon', 'uninstall']);
+  } catch {
+    // Ignore uninstall failures.
+  }
+}
+
+function countConfiguredProjects(configContent) {
+  try {
+    const parsed = TOML.parse(configContent);
+    return Array.isArray(parsed?.projects) ? parsed.projects.length : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function buildSetupOptions(platformId, mode, credentials = {}) {
+  if (platformId === 'weixin') {
+    if (mode === 'token') {
+      return {
+        token: String(credentials.token || '').trim()
+      };
+    }
+
+    return {
+      token: ''
+    };
+  }
+
+  if (platformId === 'feishu') {
+    if (mode === 'credentials') {
+      return {
+        app_id: String(credentials.app_id || credentials.appId || '').trim(),
+        app_secret: String(credentials.app_secret || credentials.appSecret || '').trim()
+      };
+    }
+
+    return {
+      app_id: '',
+      app_secret: ''
+    };
+  }
+
+  return {};
+}
+
+function buildSetupArgs({ platformId, mode, tempConfigPath, projectName, qrImagePath, credentials = {} }) {
+  if (platformId === 'weixin') {
+    if (mode === 'token') {
+      const token = String(credentials.token || '').trim();
+      const args = ['weixin', 'setup', '--project', projectName, '--config', tempConfigPath, '--token', token];
+      if (credentials.api_url || credentials.apiUrl) {
+        args.push('--api-url', String(credentials.api_url || credentials.apiUrl).trim());
+      }
+      return args;
+    }
+
+    return [
+      'weixin',
+      'setup',
+      '--project',
+      projectName,
+      '--config',
+      tempConfigPath,
+      '--qr-image',
+      qrImagePath,
+      '--timeout',
+      String(PLATFORM_MAP[platformId].timeoutSeconds)
+    ];
+  }
+
+  if (platformId === 'feishu') {
+    const baseArgs = ['feishu', 'setup', '--project', projectName, '--config', tempConfigPath, '--platform-type', 'feishu'];
+    if (mode === 'credentials') {
+      return [
+        ...baseArgs,
+        '--app-id',
+        String(credentials.app_id || credentials.appId || '').trim(),
+        '--app-secret',
+        String(credentials.app_secret || credentials.appSecret || '').trim()
+      ];
+    }
+
+    return [
+      ...baseArgs,
+      '--qr-image',
+      qrImagePath,
+      '--timeout',
+      String(PLATFORM_MAP[platformId].timeoutSeconds)
+    ];
+  }
+
+  throw new Error(`Unsupported platform: ${platformId}`);
+}
+
+function validateSetupPayload(platformId, body) {
+  const projectPath = typeof body?.projectPath === 'string' ? body.projectPath.trim() : '';
+  if (!projectPath) {
+    return { ok: false, error: 'projectPath is required.' };
+  }
+
+  if (!fs.existsSync(projectPath)) {
+    return { ok: false, error: 'Selected project path does not exist.' };
+  }
+
+  const provider = typeof body?.provider === 'undefined'
+    ? null
+    : normalizeProviderId(body.provider);
+
+  if (typeof body?.provider !== 'undefined' && !provider) {
+    return { ok: false, error: 'Unsupported provider.' };
+  }
+
+  if (platformId === 'weixin') {
+    const mode = body?.mode === 'token' ? 'token' : 'qr';
+    if (mode === 'token' && !String(body?.credentials?.token || '').trim()) {
+      return { ok: false, error: 'A Weixin token is required for token mode.' };
+    }
+
+    return {
+      ok: true,
+      payload: {
+        mode,
+        projectPath,
+        provider,
+        credentials: body?.credentials || {}
+      }
+    };
+  }
+
+  if (platformId === 'feishu') {
+    const mode = body?.mode === 'credentials' ? 'credentials' : 'qr';
+    const credentials = body?.credentials || {};
+    if (mode === 'credentials') {
+      const appId = String(credentials.app_id || credentials.appId || '').trim();
+      const appSecret = String(credentials.app_secret || credentials.appSecret || '').trim();
+      if (!appId || !appSecret) {
+        return { ok: false, error: 'app_id and app_secret are required for Feishu credentials mode.' };
+      }
+    }
+
+    return {
+      ok: true,
+      payload: {
+        mode,
+        projectPath,
+        provider,
+        credentials
+      }
+    };
+  }
+
+  return { ok: false, error: 'Unsupported platform.' };
+}
+
+async function finalizeSetupSession(session) {
+  const configContent = fs.readFileSync(session.tempConfigPath, 'utf8');
+  const connectionOptions = extractPlatformOptionsFromConfigContent(
+    configContent,
+    session.primaryProjectName,
+    session.platformId
+  );
+
+  if (!connectionOptions || !Object.keys(connectionOptions).length) {
+    throw new Error('Setup completed, but no connection options were written to the temporary config.');
+  }
+
+  const currentState = readCcConnectState();
+  const previousConnection = getPlatformConnection(currentState, session.platformId);
+  const preferredProvider = session.primaryProvider && session.configuredProviders.includes(session.primaryProvider)
+    ? session.primaryProvider
+    : previousConnection?.activeProvider && session.configuredProviders.includes(previousConnection.activeProvider)
+      ? previousConnection.activeProvider
+      : session.configuredProviders[0] || null;
+
+  const nextState = upsertPlatformConnection(currentState, session.platformId, {
+    configuredProviders: session.configuredProviders,
+    activeProvider: preferredProvider,
+    projectPath: session.projectPath,
+    connectionOptions,
+    platformType: session.platformId,
+    connectedAt: previousConnection?.connectedAt || nowIso(),
+    updatedAt: nowIso()
+  });
+
+  writeCcConnectState(nextState);
+  const { configPath } = writeCcConnectConfig(nextState);
+  const daemonResult = ensureCcConnectDaemonRunning(configPath);
+
+  if (!daemonResult.ok) {
+    throw new Error(daemonResult.detail);
+  }
+
+  session.status = 'confirmed';
+  session.message = daemonResult.detail;
+}
+
+async function createSetupSession({ platformId, mode, projectPath, credentials, provider }) {
+  const ccStatus = await getCcConnectStatus();
+  if (!ccStatus.installed) {
+    throw new Error('cc-connect is not installed.');
+  }
+
+  const configuredProviders = await getInstalledProviderIds();
+  if (!configuredProviders.length) {
+    throw new Error('No supported AI providers are installed. Install Claude, Codex, Gemini, or OpenCode first.');
+  }
+
+  const existingConnection = getPlatformConnection(readCcConnectState(), platformId);
+  const requestedProvider = normalizeProviderId(provider);
+  if (requestedProvider && !configuredProviders.includes(requestedProvider)) {
+    throw new Error(`Selected provider is not installed: ${requestedProvider}`);
+  }
+
+  const primaryProvider = requestedProvider && configuredProviders.includes(requestedProvider)
+    ? requestedProvider
+    : existingConnection?.activeProvider && configuredProviders.includes(existingConnection.activeProvider)
+      ? existingConnection.activeProvider
+      : configuredProviders[0];
+  const sessionId = `${platformId}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  const primaryProjectName = getCcConnectManagedProjectName(platformId, primaryProvider);
+  const tempConfigPath = path.join(os.tmpdir(), `cc-connect-${platformId}-${sessionId}.toml`);
+  const qrImagePath = mode === 'qr' ? path.join(os.tmpdir(), `cc-connect-${platformId}-${sessionId}.png`) : null;
+  const setupOptions = buildSetupOptions(platformId, mode, credentials);
+  const session = {
+    id: sessionId,
+    platformId,
+    mode,
+    status: 'starting',
+    qrUrl: null,
+    qrImageBase64: null,
+    startedAt: Date.now(),
+    expiresAt: Date.now() + (PLATFORM_MAP[platformId].timeoutSeconds * 1000),
+    message: 'Starting connection setup...',
+    process: null,
+    projectPath,
+    configuredProviders,
+    primaryProvider,
+    primaryProjectName,
+    tempConfigPath,
+    qrImagePath,
+    credentials
+  };
+
+  fs.writeFileSync(
+    tempConfigPath,
+    createSetupConfigContent({
+      platformId,
+      providerId: primaryProvider,
+      projectName: primaryProjectName,
+      projectPath,
+      setupOptions
+    }),
+    'utf8'
+  );
+
+  setupSessions.set(sessionId, session);
+
+  const args = buildSetupArgs({
+    platformId,
+    mode,
+    tempConfigPath,
+    projectName: primaryProjectName,
+    qrImagePath,
+    credentials
+  });
+
+  let child = null;
+  try {
+    child = spawnCommand(CC_CONNECT_COMMAND, args, {
+      cwd: projectPath,
+      env: buildCommandEnv(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: process.platform === 'win32'
+    });
+    session.process = child;
+  } catch (error) {
+    cleanupSessionArtifacts(session);
+    setupSessions.delete(session.id);
+    throw error;
+  }
+
+  let stdoutBuffer = '';
+  let stderrBuffer = '';
+
+  child.stdout?.on('data', (chunk) => {
+    const text = chunk.toString('utf8');
+    stdoutBuffer += text;
+    parseQrStatusOutput(session, stdoutBuffer);
+  });
+
+  child.stderr?.on('data', (chunk) => {
+    const text = chunk.toString('utf8');
+    stderrBuffer += text;
+    parseQrStatusOutput(session, stderrBuffer);
+  });
+
+  child.once('error', (error) => {
+    session.status = 'error';
+    session.message = `Failed to start setup: ${error.message}`;
+    scheduleFinishedSessionCleanup(session.id);
+  });
+
+  child.once('close', async (code) => {
+    try {
+      if (code === 0) {
+        await finalizeSetupSession(session);
+      } else if (session.status !== 'error') {
+        session.status = 'error';
+        session.message = `Setup failed: ${String(stderrBuffer || stdoutBuffer || `exit code ${code}`).trim().slice(0, 260)}`;
+      }
+    } catch (error) {
+      session.status = 'error';
+      session.message = error.message;
+    } finally {
+      cleanupSessionArtifacts(session);
+      scheduleFinishedSessionCleanup(session.id);
+    }
+  });
+
+  return session;
+}
+
+setInterval(() => {
+  const now = Date.now();
+  for (const [sessionId, session] of setupSessions.entries()) {
+    if (session.status === 'confirmed' || session.status === 'error' || session.status === 'expired') {
+      continue;
+    }
+
+    if (now > session.expiresAt) {
+      session.status = 'expired';
+      session.message = 'The setup session expired. Start again to generate a new QR code.';
+      if (session.process && !session.process.killed) {
+        try {
+          session.process.kill('SIGTERM');
+        } catch {
+          // Ignore timeout cleanup failures.
+        }
+      }
+      cleanupSessionArtifacts(session);
+      scheduleFinishedSessionCleanup(sessionId);
+    }
+  }
+}, 10000);
+
+async function buildSummaryResponse() {
+  const ccConnect = await getCcConnectStatus();
+  const providers = await getProviderStatuses();
+  const state = readCcConnectState();
+  const installedProviderIds = providers.filter((provider) => provider.installed).map((provider) => provider.id);
+
+  return {
+    success: true,
+    ccConnect,
+    providers,
+    platforms: buildPlatformSummaries(state, installedProviderIds)
+  };
+}
+
+function buildPlatformSessionPayload(session) {
+  return {
+    sessionId: session.id,
+    platform: session.platformId,
+    mode: session.mode,
+    provider: session.primaryProvider,
+    providers: session.configuredProviders,
+    status: session.status,
+    qrUrl: session.qrUrl,
+    qrImageBase64: session.qrImageBase64,
+    expiresAt: session.expiresAt,
+    message: session.message
+  };
+}
+
+router.get('/status', async (req, res) => {
+  try {
+    res.json(await getCcConnectStatus());
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/providers', async (req, res) => {
+  try {
+    const providers = await getProviderStatuses();
+    res.json({ success: true, providers });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/agents', async (req, res) => {
+  try {
+    const providers = await getProviderStatuses();
+    res.json({ success: true, agents: providers, providers });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/platforms', async (req, res) => {
+  try {
+    res.json(await buildSummaryResponse());
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/install', async (req, res) => {
+  try {
+    const existing = await getCcConnectStatus();
+    if (existing.installed && existing.isBeta) {
+      return res.json({
+        success: true,
+        version: existing.version,
+        message: 'cc-connect@beta is already installed.'
+      });
+    }
+
+    const result = runCommandSync({
+      command: getNpmCommand(),
+      args: ['install', '-g', 'cc-connect@beta'],
+      timeoutMs: INSTALL_TIMEOUT_MS,
+      env: buildCommandEnv()
+    });
+
+    if (result.status !== 0) {
+      return res.status(500).json({
+        success: false,
+        error: `Installation failed: ${buildShortErrorMessage(result)}`
+      });
+    }
+
+    const installed = await getCcConnectStatus();
+    return res.json({
+      success: true,
+      version: installed.version,
+      message: 'cc-connect@beta installed successfully.'
+    });
+  } catch (error) {
+    return res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/active-agent', (req, res) => {
+  void (async () => {
+    const state = readCcConnectState();
+    const installedProviderIds = await getInstalledProviderIds();
+    const connection = withAvailableProviders(getPlatformConnection(state, 'weixin'), installedProviderIds);
+    res.json({
+      agent: connection?.activeProvider || null,
+      availableAgents: connection?.configuredProviders || []
+    });
+  })().catch((error) => {
+    res.status(500).json({ success: false, error: error.message });
+  });
+});
+
+router.post('/switch-agent', (req, res) => {
+  void (async () => {
+    const provider = String(req.body?.agent || '').trim().toLowerCase();
+    if (!provider) {
+      return res.status(400).json({ success: false, error: 'agent is required.' });
+    }
+
+    const currentState = readCcConnectState();
+    const installedProviderIds = await getInstalledProviderIds();
+    const connection = getPlatformConnection(currentState, 'weixin');
+    if (!connection) {
+      return res.status(404).json({ success: false, error: 'Weixin is not connected.' });
+    }
+
+    const availableProviders = mergeAvailableProviders(
+      connection.configuredProviders,
+      installedProviderIds,
+      connection.activeProvider
+    );
+
+    if (!availableProviders.includes(provider)) {
+      return res.status(400).json({ success: false, error: `Unsupported provider: ${provider}` });
+    }
+
+    const nextState = upsertPlatformConnection(currentState, 'weixin', {
+      ...connection,
+      configuredProviders: availableProviders,
+      activeProvider: provider,
+      updatedAt: nowIso()
+    });
+    writeCcConnectState(nextState);
+    const { configPath } = writeCcConnectConfig(nextState);
+    const daemonResult = ensureCcConnectDaemonRunning(configPath);
+    if (!daemonResult.ok) {
+      return res.status(500).json({ success: false, error: daemonResult.detail });
+    }
+
+    return res.json({ success: true, agent: provider, message: daemonResult.detail });
+  })().catch((error) => {
+    return res.status(500).json({ success: false, error: error.message });
+  });
+});
+
+router.post('/unbind', (req, res) => {
+  const currentState = readCcConnectState();
+  const nextState = removePlatformConnection(currentState, 'weixin');
+  writeCcConnectState(nextState);
+  const { content } = writeCcConnectConfig(nextState);
+  if (countConfiguredProjects(content) > 0) {
+    const daemonResult = ensureCcConnectDaemonRunning(CC_CONNECT_CONFIG_PATH);
+    if (!daemonResult.ok) {
+      return res.status(500).json({ success: false, error: daemonResult.detail });
+    }
+    return res.json({ success: true, message: 'Weixin connection removed.' });
+  }
+
+  stopCcConnectDaemon();
+  return res.json({ success: true, message: 'Weixin connection removed.' });
+});
+
+router.post('/:platform/setup', async (req, res) => {
+  try {
+    const platformId = normalizePlatformId(req.params.platform);
+    if (!platformId) {
+      return res.status(404).json({ success: false, error: 'Unsupported platform.' });
+    }
+
+    const validation = validateSetupPayload(platformId, req.body);
+    if (!validation.ok) {
+      return res.status(400).json({ success: false, error: validation.error });
+    }
+
+    const session = await createSetupSession({
+      platformId,
+      ...validation.payload
+    });
+
+    return res.json({
+      success: true,
+      ...buildPlatformSessionPayload(session),
+      providers: session.configuredProviders
+    });
+  } catch (error) {
+    return res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/:platform/status', (req, res) => {
+  const platformId = normalizePlatformId(req.params.platform);
+  if (!platformId) {
+    return res.status(404).json({ success: false, error: 'Unsupported platform.' });
+  }
+
+  const sessionId = String(req.query.sessionId || '').trim();
+  if (!sessionId) {
+    return res.status(400).json({ success: false, error: 'sessionId is required.' });
+  }
+
+  const session = setupSessions.get(sessionId);
+  if (!session || session.platformId !== platformId) {
+    return res.status(404).json({ success: false, error: 'Setup session not found.' });
+  }
+
+  return res.json(buildPlatformSessionPayload(session));
+});
+
+router.post('/:platform/refresh', async (req, res) => {
+  try {
+    const platformId = normalizePlatformId(req.params.platform);
+    if (!platformId) {
+      return res.status(404).json({ success: false, error: 'Unsupported platform.' });
+    }
+
+    const sessionId = String(req.body?.sessionId || req.query.sessionId || '').trim();
+    if (!sessionId) {
+      return res.status(400).json({ success: false, error: 'sessionId is required.' });
+    }
+
+    const previousSession = setupSessions.get(sessionId);
+    if (!previousSession || previousSession.platformId !== platformId) {
+      return res.status(404).json({ success: false, error: 'Setup session not found.' });
+    }
+
+    if (previousSession.mode !== 'qr') {
+      return res.status(400).json({ success: false, error: 'Only QR setup sessions can be refreshed.' });
+    }
+
+    cleanupSession(sessionId);
+    const session = await createSetupSession({
+      platformId,
+      mode: 'qr',
+      projectPath: previousSession.projectPath,
+      credentials: previousSession.credentials,
+      provider: previousSession.primaryProvider
+    });
+
+    return res.json({
+      success: true,
+      ...buildPlatformSessionPayload(session),
+      providers: session.configuredProviders
+    });
+  } catch (error) {
+    return res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.delete('/:platform/session', (req, res) => {
+  const platformId = normalizePlatformId(req.params.platform);
+  if (!platformId) {
+    return res.status(404).json({ success: false, error: 'Unsupported platform.' });
+  }
+
+  const sessionId = String(req.query.sessionId || '').trim();
+  if (sessionId) {
+    const session = setupSessions.get(sessionId);
+    if (session?.platformId === platformId) {
+      cleanupSession(sessionId);
+    }
+  }
+
+  res.json({ success: true });
+});
+
+router.get('/:platform/active-provider', (req, res) => {
+  void (async () => {
+    const platformId = normalizePlatformId(req.params.platform);
+    if (!platformId) {
+      return res.status(404).json({ success: false, error: 'Unsupported platform.' });
+    }
+
+    const state = readCcConnectState();
+    const installedProviderIds = await getInstalledProviderIds();
+    const connection = withAvailableProviders(getPlatformConnection(state, platformId), installedProviderIds);
+    return res.json({
+      success: true,
+      provider: connection?.activeProvider || null,
+      availableProviders: connection?.configuredProviders || [],
+      projectPath: connection?.projectPath || null
+    });
+  })().catch((error) => {
+    return res.status(500).json({ success: false, error: error.message });
+  });
+});
+
+router.post('/:platform/switch-provider', (req, res) => {
+  void (async () => {
+    const platformId = normalizePlatformId(req.params.platform);
+    if (!platformId) {
+      return res.status(404).json({ success: false, error: 'Unsupported platform.' });
+    }
+
+    const provider = String(req.body?.provider || '').trim().toLowerCase();
+    const currentState = readCcConnectState();
+    const installedProviderIds = await getInstalledProviderIds();
+    const connection = getPlatformConnection(currentState, platformId);
+
+    if (!provider) {
+      return res.status(400).json({ success: false, error: 'provider is required.' });
+    }
+
+    if (!connection) {
+      return res.status(404).json({ success: false, error: `${PLATFORM_MAP[platformId].label} is not connected.` });
+    }
+
+    const availableProviders = mergeAvailableProviders(
+      connection.configuredProviders,
+      installedProviderIds,
+      connection.activeProvider
+    );
+
+    if (!availableProviders.includes(provider)) {
+      return res.status(400).json({ success: false, error: `Unsupported provider: ${provider}` });
+    }
+
+    const nextState = upsertPlatformConnection(currentState, platformId, {
+      ...connection,
+      configuredProviders: availableProviders,
+      activeProvider: provider,
+      updatedAt: nowIso()
+    });
+    writeCcConnectState(nextState);
+    const { configPath } = writeCcConnectConfig(nextState);
+    const daemonResult = ensureCcConnectDaemonRunning(configPath);
+    if (!daemonResult.ok) {
+      return res.status(500).json({ success: false, error: daemonResult.detail });
+    }
+
+    return res.json({ success: true, provider, message: daemonResult.detail });
+  })().catch((error) => {
+    return res.status(500).json({ success: false, error: error.message });
+  });
+});
+
+router.post('/:platform/project', (req, res) => {
+  void (async () => {
+    const platformId = normalizePlatformId(req.params.platform);
+    if (!platformId) {
+      return res.status(404).json({ success: false, error: 'Unsupported platform.' });
+    }
+
+    const projectPath = typeof req.body?.projectPath === 'string' ? req.body.projectPath.trim() : '';
+    if (!projectPath) {
+      return res.status(400).json({ success: false, error: 'projectPath is required.' });
+    }
+
+    if (!fs.existsSync(projectPath)) {
+      return res.status(400).json({ success: false, error: 'Selected project path does not exist.' });
+    }
+
+    const currentState = readCcConnectState();
+    const installedProviderIds = await getInstalledProviderIds();
+    const connection = getPlatformConnection(currentState, platformId);
+
+    if (!connection) {
+      return res.status(404).json({ success: false, error: `${PLATFORM_MAP[platformId].label} is not connected.` });
+    }
+
+    const availableProviders = mergeAvailableProviders(
+      connection.configuredProviders,
+      installedProviderIds,
+      connection.activeProvider
+    );
+
+    const nextState = upsertPlatformConnection(currentState, platformId, {
+      ...connection,
+      configuredProviders: availableProviders,
+      projectPath,
+      updatedAt: nowIso()
+    });
+    writeCcConnectState(nextState);
+    const { configPath } = writeCcConnectConfig(nextState);
+    const daemonResult = ensureCcConnectDaemonRunning(configPath);
+
+    if (!daemonResult.ok) {
+      return res.status(500).json({ success: false, error: daemonResult.detail });
+    }
+
+    return res.json({
+      success: true,
+      projectPath,
+      message: daemonResult.detail
+    });
+  })().catch((error) => {
+    return res.status(500).json({ success: false, error: error.message });
+  });
+});
+
+router.post('/:platform/unbind', (req, res) => {
+  const platformId = normalizePlatformId(req.params.platform);
+  if (!platformId) {
+    return res.status(404).json({ success: false, error: 'Unsupported platform.' });
+  }
+
+  const currentState = readCcConnectState();
+  const nextState = removePlatformConnection(currentState, platformId);
+  writeCcConnectState(nextState);
+  const { content } = writeCcConnectConfig(nextState);
+  if (countConfiguredProjects(content) > 0) {
+    const daemonResult = ensureCcConnectDaemonRunning(CC_CONNECT_CONFIG_PATH);
+    if (!daemonResult.ok) {
+      return res.status(500).json({ success: false, error: daemonResult.detail });
+    }
+    return res.json({ success: true, message: `${PLATFORM_MAP[platformId].label} connection removed.` });
+  }
+
+  stopCcConnectDaemon();
+  return res.json({ success: true, message: `${PLATFORM_MAP[platformId].label} connection removed.` });
+});
+
+export default router;