@axhub/genie 0.2.7 → 0.2.9

package/server/acp-runtime/client.js

@@ -2,7 +2,6 @@ import fs from 'fs/promises';
 import { randomUUID } from 'crypto';
 import os from 'os';
 import path from 'path';
-import { spawn } from 'child_process';
 import { Readable, Writable } from 'stream';
 
 import {
@@ -13,9 +12,12 @@ import {
 
 import {
   CONVERSATION_EVENT_KINDS,
-  createConversationEvent
+  createConversationEvent,
+  stripAssistantProtocolTags
 } from '../../shared/conversationEvents.js';
 import { parseDataUrl } from '../utils/agentImages.js';
+import { spawnCommand } from '../utils/spawnCommand.js';
+import { resolveCommandPath } from '../utils/resolveCommandPath.js';
 import { resolveAgentCommand } from './registry.js';
 
 const DEFAULT_TERMINAL_OUTPUT_LIMIT = 256 * 1024;
@@ -672,7 +674,7 @@ async function resolveGeminiCommand(commandLine) {
   try {
     const versionOutput = await new Promise((resolve, reject) => {
       let stdout = '';
-      const childProcess = spawn(parsed.command, ['--version'], {
+      const childProcess = spawnCommand(parsed.command, ['--version'], {
         stdio: ['ignore', 'pipe', 'ignore']
       });
 
@@ -703,17 +705,41 @@ async function resolveGeminiCommand(commandLine) {
   }
 }
 
-async function resolveLaunchCommand(agentKey, overrides = {}) {
+async function resolveNpxFallbackCommand(commandLine, agentKey) {
+  const parsed = splitCommandLine(commandLine);
+  if (parsed.command !== 'npx') {
+    return commandLine;
+  }
+
+  const npxCheck = await resolveCommandPath('npx');
+  if (npxCheck.found) {
+    return commandLine;
+  }
+
+  const npmCheck = await resolveCommandPath('npm');
+  if (npmCheck.found) {
+    return ['npm', 'exec', '--yes', '--', ...parsed.args].join(' ');
+  }
+
+  throw new Error(
+    `Unable to launch ${agentKey} ACP adapter because neither npx nor npm is available in PATH.`
+  );
+}
+
+export async function resolveLaunchCommand(agentKey, overrides = {}) {
   const commandLine = resolveAgentCommand(agentKey, overrides);
   if (!commandLine) {
     throw new Error(`Unsupported ACP agent: ${agentKey}`);
   }
 
-  if (String(agentKey || '').trim().toLowerCase() === 'gemini') {
-    return resolveGeminiCommand(commandLine);
+  const normalizedAgentKey = String(agentKey || '').trim().toLowerCase();
+  const resolvedCommandLine = await resolveNpxFallbackCommand(commandLine, normalizedAgentKey || 'unknown');
+
+  if (normalizedAgentKey === 'gemini') {
+    return resolveGeminiCommand(resolvedCommandLine);
   }
 
-  return commandLine;
+  return resolvedCommandLine;
 }
 
 function buildPromptBlocks(promptText, attachments = {}) {
@@ -786,7 +812,7 @@ class LocalTerminalProcess {
         }, {})
       : {};
 
-    this.child = spawn(this.command, this.args, {
+    this.child = spawnCommand(this.command, this.args, {
       cwd: this.cwd,
       env: sanitizeProcessEnv(process.env, envEntries),
       stdio: ['ignore', 'pipe', 'pipe']
@@ -881,6 +907,7 @@ export class AcpClient {
     this.isPromptInFlight = false;
     this.pendingPromptDiagnostic = null;
     this.hasReportedPromptFatalError = false;
+    this.agentDiagnosticBuffer = '';
     this.streamState = {
       turnId: null,
       assistantSegmentIndex: 0,
@@ -899,6 +926,7 @@ export class AcpClient {
     this.writer.send({
       provider: this.agentKey,
       sessionId: this.sessionId,
+      projectPath: this.projectPath,
       runtime: 'acp',
       timestamp: nowIso(),
       ...payload
@@ -1001,7 +1029,19 @@ export class AcpClient {
   }
 
   handleAgentDiagnostic(text) {
-    const fatalError = detectFatalAgentDiagnostic(this.agentKey, text);
+    const diagnosticText = String(text || '').trim();
+    if (!diagnosticText) {
+      return;
+    }
+
+    const nextBuffer = this.agentDiagnosticBuffer
+      ? `${this.agentDiagnosticBuffer}\n${diagnosticText}`
+      : diagnosticText;
+    this.agentDiagnosticBuffer = nextBuffer.length > 8192
+      ? nextBuffer.slice(-8192)
+      : nextBuffer;
+
+    const fatalError = detectFatalAgentDiagnostic(this.agentKey, this.agentDiagnosticBuffer);
     if (!fatalError || !this.isPromptInFlight) {
       return;
     }
@@ -1210,6 +1250,11 @@ export class AcpClient {
 
     if (update.sessionUpdate === 'agent_message_chunk') {
       if (update.content?.type === 'text' && typeof update.content.text === 'string') {
+        const cleanText = stripAssistantProtocolTags(update.content.text);
+        if (!cleanText) {
+          return;
+        }
+
         const messageId = this.streamState.assistantMessageId
           || this.createAssistantMessageId('assistant_text');
 
@@ -1230,7 +1275,7 @@ export class AcpClient {
           CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_DELTA,
           {
             messageId,
-            text: update.content.text
+            text: cleanText
           },
           {
             timestamp,
@@ -1442,7 +1487,7 @@ export class AcpClient {
     const spawnEnvironment = await prepareSpawnEnvironment(this.agentKey);
     this.spawnCleanup = spawnEnvironment.cleanup;
 
-    this.childProcess = spawn(command, args, {
+    this.childProcess = spawnCommand(command, args, {
       cwd: this.projectPath,
       stdio: ['pipe', 'pipe', 'pipe'],
       windowsHide: true,
@@ -1603,16 +1648,44 @@ export class AcpClient {
   }
 
   async setModel(modelId) {
-    if (!modelId) {
+    if (!modelId || !this.sessionId || !this.connection) {
       return;
     }
 
+    let lastError = null;
+
     try {
-      await this.connection.setSessionModel({
-        sessionId: this.sessionId,
-        modelId
-      });
-    } catch {}
+      if (typeof this.connection.setSessionConfigOption === 'function') {
+        try {
+          await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: 'model',
+            value: modelId
+          });
+          return;
+        } catch (error) {
+          lastError = error;
+        }
+      }
+
+      if (typeof this.connection.unstable_setSessionModel === 'function') {
+        try {
+          await this.connection.unstable_setSessionModel({
+            sessionId: this.sessionId,
+            modelId
+          });
+          return;
+        } catch (error) {
+          lastError = error;
+        }
+      }
+    } catch (error) {
+      lastError = error;
+    }
+
+    if (lastError) {
+      console.warn(`[ACP:${this.agentKey}] Failed to set model "${modelId}": ${lastError.message}`);
+    }
   }
 
   async setMode(modeId) {
@@ -1631,6 +1704,7 @@ export class AcpClient {
   async sendPrompt(promptText, attachments = {}) {
     this.resetTurnState();
     this.hasReportedPromptFatalError = false;
+    this.agentDiagnosticBuffer = '';
     const promptPayload = buildPromptBlocks(promptText, attachments);
     const clientRequestId = typeof attachments?.clientRequestId === 'string' && attachments.clientRequestId.trim()
       ? attachments.clientRequestId.trim()

package/server/acp-runtime/index.js

@@ -1,10 +1,4 @@
 import { resolveWorkingDirectory } from '../utils/defaultWorkingDirectory.js';
-import {
-  CLAUDE_MODELS,
-  CODEX_MODELS,
-  GEMINI_MODELS,
-  OPENCODE_MODELS
-} from '../../shared/modelConstants.js';
 import { AcpClient } from './client.js';
 import {
   findAcpSessionRecord,
@@ -54,16 +48,11 @@ function registerActiveClient(provider, sessionId, client) {
   return entry;
 }
 
-function resolveDefaultModel(agentKey, requestedModel) {
-  if (requestedModel) {
-    return requestedModel;
-  }
-
-  if (agentKey === 'claude') return CLAUDE_MODELS.DEFAULT;
-  if (agentKey === 'codex') return CODEX_MODELS.DEFAULT;
-  if (agentKey === 'gemini') return GEMINI_MODELS.DEFAULT;
-  if (agentKey === 'opencode') return OPENCODE_MODELS.DEFAULT;
-  return null;
+export function resolveDefaultModel(agentKey, requestedModel) {
+  const normalizedRequestedModel = typeof requestedModel === 'string'
+    ? requestedModel.trim()
+    : '';
+  return normalizedRequestedModel || null;
 }
 
 function unregisterActiveClient(provider, sessionId, client = null) {

package/server/acp-runtime/session-store.js

@@ -7,9 +7,6 @@ function parsePositiveInteger(value, fallback) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
-const ACP_SESSION_ROOT = process.env.AXHUB_GENIE_ACP_SESSION_ROOT
-  ? path.resolve(process.env.AXHUB_GENIE_ACP_SESSION_ROOT)
-  : path.join(os.homedir(), '.axhub-genie', 'acp-sessions');
 const DEFAULT_SESSION_GC_MAX_AGE_DAYS = parsePositiveInteger(process.env.ACP_SESSION_GC_MAX_AGE_DAYS, 30);
 
 function normalizeProvider(value) {
@@ -22,7 +19,10 @@ function normalizeSessionId(value) {
 }
 
 function getProviderDir(provider) {
-  return path.join(ACP_SESSION_ROOT, normalizeProvider(provider));
+  const sessionRoot = process.env.AXHUB_GENIE_ACP_SESSION_ROOT
+    ? path.resolve(process.env.AXHUB_GENIE_ACP_SESSION_ROOT)
+    : path.join(os.homedir(), '.axhub-genie', 'acp-sessions');
+  return path.join(sessionRoot, normalizeProvider(provider));
 }
 
 function getSessionFilePath(provider, sessionId) {

package/server/channels/runtime/AgentRuntimeAdapter.js

@@ -1,4 +1,3 @@
-import { CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../../shared/modelConstants.js';
 import { executeAgentPrompt } from '../../acp-runtime/index.js';
 
 function normalizeBackend(backend) {
@@ -9,13 +8,6 @@ function normalizeBackend(backend) {
   return 'codex';
 }
 
-function getDefaultModel(backend) {
-  if (backend === 'codex') return CODEX_MODELS.DEFAULT;
-  if (backend === 'gemini') return GEMINI_MODELS.DEFAULT;
-  if (backend === 'opencode') return OPENCODE_MODELS.DEFAULT;
-  return undefined;
-}
-
 function createWriter(callbacks) {
   const state = {
     sessionId: null,
@@ -96,7 +88,6 @@ export async function runBackendSession({
   onError,
 }) {
   const resolvedBackend = normalizeBackend(backend);
-  const resolvedModel = model || getDefaultModel(resolvedBackend);
 
   const writer = createWriter({
     onSessionId,
@@ -108,7 +99,7 @@ export async function runBackendSession({
     projectPath,
     cwd: projectPath,
     sessionId: sessionId || undefined,
-    model: resolvedModel,
+    model: model || undefined,
     permissionMode: 'bypassPermissions',
     resume: !!sessionId,
     skipPermissions: true,

package/server/claude-sdk.js

@@ -5,15 +5,13 @@ import {
   isAgentSessionActive,
   resolveAgentPermission
 } from './acp-runtime/index.js';
-import { CLAUDE_MODELS } from '../shared/modelConstants.js';
 
 export async function queryClaudeSDK(command, options = {}, writer) {
   return executeAgentPrompt({
     agentKey: 'claude',
     command,
     options: {
-      ...options,
-      model: options.model || CLAUDE_MODELS.DEFAULT
+      ...options
     },
     writer
   });

package/server/cli.js

@@ -24,6 +24,10 @@ import {
     DEFAULT_WORKING_DIRECTORY_ENV,
     getConfiguredDefaultProjectPath,
 } from './utils/defaultWorkingDirectory.js';
+import {
+    getCcConnectConnectionSummary,
+    updateCcConnectPlatformBinding,
+} from './utils/ccConnectManager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -374,6 +378,27 @@ function buildEditorErrorResponse({ requestId, channel = null, targetClientId =
     };
 }
 
+function buildCcConnectSuccessResponse({ command, platform = null, data = {} }) {
+    return {
+        ok: true,
+        command,
+        platform,
+        data,
+    };
+}
+
+function buildCcConnectErrorResponse({ command, platform = null, code, message }) {
+    return {
+        ok: false,
+        command,
+        platform,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+
 function printJson(payload) {
     console.log(JSON.stringify(payload, null, 2));
 }
@@ -453,6 +478,27 @@ async function sendEditorWebSocketRequest({ apiBaseUrl, apiKey, message, timeout
     });
 }
 
+const RETRYABLE_ERROR_CODES = new Set(['CONNECTION_ERROR', 'CONNECTION_CLOSED', 'REQUEST_TIMEOUT']);
+const CLI_RETRY_DELAY_MS = 1000;
+const CLI_MAX_RETRIES = 1;
+
+async function sendEditorWebSocketRequestWithRetry(options) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= CLI_MAX_RETRIES; attempt++) {
+        try {
+            return await sendEditorWebSocketRequest(options);
+        } catch (error) {
+            lastError = error;
+            if (attempt < CLI_MAX_RETRIES && RETRYABLE_ERROR_CODES.has(error?.code)) {
+                await new Promise((resolve) => setTimeout(resolve, CLI_RETRY_DELAY_MS));
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw lastError;
+}
+
 function resolveOutputDirPath(outputDir) {
     return path.resolve(outputDir || process.cwd());
 }
@@ -603,7 +649,7 @@ async function runEditorCommand(positionals, options) {
     const timeoutMs = parsePositiveInteger(options.timeoutMs || DEFAULT_EDITOR_TIMEOUT_MS, '--timeout-ms') || DEFAULT_EDITOR_TIMEOUT_MS;
 
     try {
-        const response = await sendEditorWebSocketRequest({
+        const response = await sendEditorWebSocketRequestWithRetry({
             apiBaseUrl,
             apiKey: options.apiKey,
             message: editorRequest.message,
@@ -627,6 +673,96 @@ async function runEditorCommand(positionals, options) {
     }
 }
 
+function buildCcConnectCommand(positionals, options) {
+    const commandPath = positionals.join(' ');
+    const requestedPlatform = typeof options.platform === 'string' ? options.platform.trim() : '';
+
+    if (commandPath === 'cc-connect' || commandPath === 'cc-connect status') {
+        return {
+            command: 'cc-connect status',
+            action: 'status',
+            platform: requestedPlatform || null,
+        };
+    }
+
+    if (commandPath === 'cc-connect set') {
+        const platform = requireOption(options, 'platform', '--platform is required');
+        const provider = typeof options.provider === 'string' && options.provider.trim()
+            ? options.provider.trim()
+            : null;
+        const projectPath = typeof options.projectPath === 'string' && options.projectPath.trim()
+            ? path.resolve(options.projectPath)
+            : null;
+
+        if (!provider && !projectPath) {
+            throw new Error('At least one of --provider or --project-path is required.');
+        }
+
+        return {
+            command: 'cc-connect set',
+            action: 'set',
+            platform,
+            provider,
+            projectPath,
+        };
+    }
+
+    throw new Error(`Unknown cc-connect command: ${commandPath}`);
+}
+
+async function runCcConnectCommand(positionals, options) {
+    const command = buildCcConnectCommand(positionals, options);
+
+    try {
+        if (command.action === 'status') {
+            const summary = await getCcConnectConnectionSummary(command.platform);
+            const data = command.platform
+                ? {
+                    ccConnect: summary.ccConnect,
+                    providers: summary.providers,
+                    platform: summary.platform,
+                }
+                : {
+                    ccConnect: summary.ccConnect,
+                    providers: summary.providers,
+                    platforms: summary.platforms,
+                };
+
+            printJson(buildCcConnectSuccessResponse({
+                command: command.command,
+                platform: command.platform,
+                data,
+            }));
+            return;
+        }
+
+        if (command.action === 'set') {
+            const result = await updateCcConnectPlatformBinding({
+                platformId: command.platform,
+                provider: command.provider === null ? undefined : command.provider,
+                projectPath: command.projectPath === null ? undefined : command.projectPath,
+            });
+
+            printJson(buildCcConnectSuccessResponse({
+                command: command.command,
+                platform: result.platform,
+                data: result,
+            }));
+            return;
+        }
+
+        throw new Error(`Unsupported cc-connect action: ${command.action}`);
+    } catch (error) {
+        printJson(buildCcConnectErrorResponse({
+            command: command.command,
+            platform: command.platform || null,
+            code: error.code || 'CC_CONNECT_COMMAND_FAILED',
+            message: error.message,
+        }));
+        process.exit(1);
+    }
+}
+
 // Show status command
 function showStatus(options = {}) {
     const runtimeStatus = getRuntimeStatus();
@@ -754,6 +890,7 @@ Commands:
   start          Start the Axhub Genie server (default)
   stop           Stop the running Axhub Genie server
   status         Show configuration and data locations
+  cc-connect     Inspect or update platform connection bindings
   editor         Query or control a connected web editor frontend
   update         Update to the latest version
   help           Show this help information
@@ -769,12 +906,15 @@ Options:
   --json                      Output JSON (status or editor commands)
   --api-base <url>            Override API base URL for editor commands
   --api-key <key>             API key for /api/agent/ws editor commands
+  --platform <id>             Target platform for cc-connect commands
+  --provider <id>             Provider for cc-connect updates or editor task references
   --channel <name>            Integration channel for editor commands
   --target-client-id <id>     Target frontend client ID for editor commands
   --client-id <id>            Optional client filter for editor clients list
+  --project-path <path>       Project path for cc-connect platform binding updates
   --element-key <key>         Target element key for editor node commands
   --status <values>           Comma-separated status filters for editor nodes list
-  --state <editing|idle>      Target editing state for editor editing set
+  --state <editing|idle|completed|error> Target editing state for editor editing set
   --limit <n>                 Maximum number of nodes returned by editor nodes list
   --output-dir <path>         Download directory for screenshot/image export commands
   --timeout-ms <ms>           Timeout for editor WebSocket requests (default: ${DEFAULT_EDITOR_TIMEOUT_MS})
@@ -790,6 +930,9 @@ Examples:
   $ axhub-genie stop                   # Stop running server
   $ axhub-genie status                 # Show configuration
   $ axhub-genie status --json          # Get machine-readable status
+  $ axhub-genie cc-connect status
+  $ axhub-genie cc-connect set --platform weixin --provider codex
+  $ axhub-genie cc-connect set --platform feishu --project-path /path/to/repo
   $ axhub-genie editor clients list --channel project-a
   $ axhub-genie editor snapshot --channel project-a --target-client-id figma-123
   $ axhub-genie editor nodes list --channel project-a --target-client-id figma-123 --status pending-dispatch,dirty
@@ -940,10 +1083,18 @@ function parseArgs(args) {
             parsed.options.apiKey = args[++i];
         } else if (arg.startsWith('--api-key=')) {
             parsed.options.apiKey = arg.split('=')[1];
+        } else if (arg === '--platform') {
+            parsed.options.platform = args[++i];
+        } else if (arg.startsWith('--platform=')) {
+            parsed.options.platform = arg.split('=')[1];
         } else if (arg === '--channel') {
             parsed.options.channel = args[++i];
         } else if (arg.startsWith('--channel=')) {
             parsed.options.channel = arg.split('=')[1];
+        } else if (arg === '--project-path') {
+            parsed.options.projectPath = args[++i];
+        } else if (arg.startsWith('--project-path=')) {
+            parsed.options.projectPath = arg.split('=')[1];
         } else if (arg === '--target-client-id') {
             parsed.options.targetClientId = args[++i];
         } else if (arg.startsWith('--target-client-id=')) {
@@ -1041,6 +1192,9 @@ async function main() {
         case 'editor':
             await runEditorCommand(positionals, options);
             break;
+        case 'cc-connect':
+            await runCcConnectCommand(positionals, options);
+            break;
         case 'status':
         case 'info':
             showStatus(options);
@@ -1078,6 +1232,9 @@ if (isDirectExecution) {
 }
 
 export {
+    buildCcConnectCommand,
+    buildCcConnectErrorResponse,
+    buildCcConnectSuccessResponse,
     buildEditorRequest,
     buildEditorSuccessResponse,
     buildEditorErrorResponse,

package/server/external-agent/service.js

@@ -62,15 +62,21 @@ async function ensureProviderInstalled(provider) {
   throw createRequestError(messageParts.join(' '), 400);
 }
 
-export function buildSessionNavigation(sessionId) {
+export function buildSessionNavigation({
+  provider,
+  sessionId
+} = {}) {
+  const normalizedProvider = typeof provider === 'string' && provider.trim() ? provider.trim().toLowerCase() : null;
   const normalizedSessionId = typeof sessionId === 'string' && sessionId.trim() ? sessionId.trim() : null;
-  const sessionPath = normalizedSessionId ? `/session/${normalizedSessionId}` : null;
+  const sessionPath = normalizedProvider && normalizedSessionId
+    ? `/session/${normalizedProvider}/${encodeURIComponent(normalizedSessionId)}`
+    : null;
   const frontendPort = process.env.VITE_PORT || '5173';
   const configuredFrontendUrl = typeof process.env.FRONTEND_URL === 'string'
     ? process.env.FRONTEND_URL.trim().replace(/\/+$/, '')
     : '';
   const frontendBaseUrl = configuredFrontendUrl || `http://localhost:${frontendPort}`;
-  const sessionUrl = normalizedSessionId ? `${frontendBaseUrl}${sessionPath}` : null;
+  const sessionUrl = sessionPath ? `${frontendBaseUrl}${sessionPath}` : null;
 
   return {
     sessionPath,
@@ -471,7 +477,11 @@ export async function runExternalAgentRequest({
       openOnly: true,
       runtime: 'acp',
       sessionId: normalized.normalizedSessionId,
-      ...buildSessionNavigation(normalized.normalizedSessionId),
+      ...buildSessionNavigation({
+        provider: normalized.provider,
+        sessionId: normalized.normalizedSessionId,
+        projectPath: normalized.projectPath
+      }),
       isResumed: true,
       message: 'Session link generated. No model call triggered.'
     };
@@ -534,7 +544,11 @@ export async function runExternalAgentRequest({
       throw new AgentSessionAbortedError();
     }
 
-    const navigation = buildSessionNavigation(callbackSessionId);
+    const navigation = buildSessionNavigation({
+      provider: normalized.provider,
+      sessionId: callbackSessionId,
+      projectPath: finalProjectPath
+    });
     const response = {
       success: true,
       sessionId: callbackSessionId,
@@ -580,7 +594,11 @@ export async function runExternalAgentRequest({
   } catch (error) {
     callbackSessionId = writer.getSessionId() || callbackCaptureWriter.getSessionId() || normalized.normalizedSessionId;
     callbackResult = {
-      ...buildSessionNavigation(callbackSessionId),
+      ...buildSessionNavigation({
+        provider: normalized.provider,
+        sessionId: callbackSessionId,
+        projectPath: finalProjectPath
+      }),
       messages: callbackCaptureWriter.getAssistantMessages(),
       tokens: callbackCaptureWriter.getTotalTokens()
     };