@axhub/genie 0.2.11 → 0.2.12

package/server/external-agent/ws.js

@@ -118,6 +118,151 @@ function normalizePositiveInteger(value) {
   return next;
 }
 
+function readContextCurrentFilePath(context) {
+  if (!isPlainObject(context)) {
+    return null;
+  }
+
+  if (typeof context.currentFile === 'string') {
+    return normalizeNonEmptyString(context.currentFile);
+  }
+
+  if (isPlainObject(context.currentFile)) {
+    return normalizeNonEmptyString(context.currentFile.path);
+  }
+
+  if (isPlainObject(context.extensions)) {
+    return normalizeNonEmptyString(context.extensions.targetPath);
+  }
+
+  return null;
+}
+
+function normalizePathValue(value) {
+  const normalized = normalizeNonEmptyString(value);
+  if (!normalized) {
+    return null;
+  }
+  return normalized
+    .replace(/\\/g, '/')
+    .replace(/^\.\//, '');
+}
+
+function pathsReferToSameFile(left, right) {
+  const normalizedLeft = normalizePathValue(left);
+  const normalizedRight = normalizePathValue(right);
+  if (!normalizedLeft || !normalizedRight) {
+    return false;
+  }
+  if (normalizedLeft === normalizedRight) {
+    return true;
+  }
+  return (
+    normalizedLeft.endsWith(`/${normalizedRight}`)
+    || normalizedRight.endsWith(`/${normalizedLeft}`)
+  );
+}
+
+function readContextCurrentFilePathFromPageUrl(pageUrl) {
+  const normalizedPageUrl = normalizeNonEmptyString(pageUrl);
+  if (!normalizedPageUrl) {
+    return null;
+  }
+
+  try {
+    const url = new URL(normalizedPageUrl, 'http://localhost');
+    const targetPath = normalizePathValue(url.searchParams.get('targetPath'));
+    if (targetPath) {
+      return targetPath;
+    }
+
+    const rawContext = normalizeNonEmptyString(url.searchParams.get('context'));
+    if (!rawContext) {
+      return null;
+    }
+
+    return readContextCurrentFilePath(JSON.parse(rawContext));
+  } catch {
+    return null;
+  }
+}
+
+function getIntegrationConnectionRecency(meta) {
+  return Math.max(Date.parse(meta?.lastSeenAt || '') || 0, Date.parse(meta?.connectedAt || '') || 0);
+}
+
+function getIntegrationConnectionIdentityKey(meta) {
+  if (!meta?.role || !meta?.channel || !meta?.clientId) {
+    return null;
+  }
+  return `${meta.role}::${meta.channel}::${meta.clientId}`;
+}
+
+function getIntegrationPageIdentityKey(meta) {
+  const pageUrl = normalizeNonEmptyString(meta?.pageUrl);
+  if (!meta?.role || !meta?.channel || !pageUrl) {
+    return null;
+  }
+  return `${meta.role}::${meta.channel}::${pageUrl}`;
+}
+
+function pickMostRecentIntegrationTarget(targets) {
+  return targets.slice().sort((left, right) => {
+    return getIntegrationConnectionRecency(right) - getIntegrationConnectionRecency(left);
+  })[0] || null;
+}
+
+function dedupeIntegrationConnectionsByIdentity(connections) {
+  const deduped = new Map();
+
+  for (const meta of connections) {
+    const key = getIntegrationConnectionIdentityKey(meta);
+    if (!key) {
+      continue;
+    }
+
+    const previous = deduped.get(key);
+    if (!previous || getIntegrationConnectionRecency(meta) >= getIntegrationConnectionRecency(previous)) {
+      deduped.set(key, meta);
+    }
+  }
+
+  return Array.from(deduped.values());
+}
+
+function collapseDuplicateFrontendPagesByPageUrl(connections) {
+  const deduped = new Map();
+  const withoutPageUrl = [];
+
+  for (const meta of connections) {
+    const key = getIntegrationPageIdentityKey(meta);
+    if (!key) {
+      withoutPageUrl.push(meta);
+      continue;
+    }
+
+    const previous = deduped.get(key);
+    if (!previous || getIntegrationConnectionRecency(meta) >= getIntegrationConnectionRecency(previous)) {
+      deduped.set(key, meta);
+    }
+  }
+
+  return [...deduped.values(), ...withoutPageUrl];
+}
+
+function pickContextMatchedTarget(targets, context) {
+  const currentFilePath = readContextCurrentFilePath(context);
+  if (!currentFilePath) {
+    return null;
+  }
+
+  const matches = targets.filter((target) => (
+    pathsReferToSameFile(readContextCurrentFilePathFromPageUrl(target.pageUrl), currentFilePath)
+  ));
+
+  return matches.length > 0 ? pickMostRecentIntegrationTarget(matches) : null;
+}
+
 function buildSessionActivitySubscriptionKey({ requestId = null, provider = null, sessionId = null } = {}) {
   if (requestId) {
     return `request:${requestId}`;
@@ -359,7 +504,7 @@ function buildSessionActivityFromConversationEvent({
       id: event.eventId,
       timestamp: event.timestamp,
       kind: 'tool',
-      text: `调用工具：${toolName}`,
+      text: toolName,
       requestId,
       sessionId: resolvedSessionId,
       provider: resolvedProvider,
@@ -726,8 +871,33 @@ function touchIntegrationConnection(ws) {
   return updated;
 }
 
+function removeDuplicateIntegrationIdentityConnections(nextMeta, currentWs) {
+  if (nextMeta?.role !== INTEGRATION_ROLE_FRONTEND_PAGE) {
+    return;
+  }
+
+  const nextKey = getIntegrationConnectionIdentityKey(nextMeta);
+  if (!nextKey) {
+    return;
+  }
+
+  for (const [candidateWs, candidateMeta] of integrationConnections.entries()) {
+    if (candidateWs === currentWs) {
+      continue;
+    }
+
+    if (getIntegrationConnectionIdentityKey(candidateMeta) !== nextKey) {
+      continue;
+    }
+
+    integrationConnections.delete(candidateWs);
+    removePendingIntegrationRequestsForWs(candidateWs);
+    removePendingIntegrationPingsForWs(candidateWs);
+  }
+}
+
 function listIntegrationConnections({ role = null, channel = null, clientId = null } = {}) {
-  return Array.from(integrationConnections.values()).filter((meta) => {
+  const matchingConnections = Array.from(integrationConnections.values()).filter((meta) => {
     if (role && meta.role !== role) {
       return false;
     }
@@ -742,6 +912,12 @@ function listIntegrationConnections({ role = null, channel = null, clientId = nu
 
     return true;
   });
+
+  if (role !== INTEGRATION_ROLE_FRONTEND_PAGE) {
+    return matchingConnections;
+  }
+
+  return dedupeIntegrationConnectionsByIdentity(matchingConnections);
 }
 
 function buildEditorClientSummary(meta) {
@@ -977,6 +1153,7 @@ function handleIntegrationConnect(ws, data) {
   };
 
   const previous = integrationConnections.get(ws) || null;
+  removeDuplicateIntegrationIdentityConnections(nextMeta, ws);
   integrationConnections.set(ws, nextMeta);
 
   sendJson(ws, {
@@ -1197,7 +1374,7 @@ function getTargetFrontendConnections(channel, targetClientId) {
   });
 }
 
-function resolveForwardTargets(originWs, { channel, targetClientId }) {
+function resolveForwardTargets(originWs, { channel, targetClientId, context, requiredCapability = null }) {
   const explicitTargetId = normalizeNonEmptyString(targetClientId);
   if (explicitTargetId) {
     return {
@@ -1207,7 +1384,15 @@ function resolveForwardTargets(originWs, { channel, targetClientId }) {
     };
   }
 
-  const channelTargets = getTargetFrontendConnections(channel, null);
+  const allChannelTargets = getTargetFrontendConnections(channel, null);
+  const channelTargets = requiredCapability
+    ? allChannelTargets.filter((target) => target.capabilities?.includes(requiredCapability))
+    : allChannelTargets.filter((target) => (
+      !Array.isArray(target.capabilities)
+      || target.capabilities.length === 0
+      || target.capabilities.includes('context.update')
+      || target.capabilities.includes('prompt.update')
+    ));
   if (channelTargets.length === 0) {
     return {
       targets: [],
@@ -1219,17 +1404,18 @@ function resolveForwardTargets(originWs, { channel, targetClientId }) {
     };
   }
 
-  if (channelTargets.length === 1) {
+  const pageTargets = collapseDuplicateFrontendPagesByPageUrl(channelTargets);
+  if (pageTargets.length === 1) {
     return {
-      targets: channelTargets,
-      resolvedTargetClientId: channelTargets[0].clientId,
+      targets: pageTargets,
+      resolvedTargetClientId: pageTargets[0].clientId,
       error: null
     };
   }
 
   const originMeta = integrationConnections.get(originWs) || null;
   const sessionMatchedTargets = originMeta?.sessionId
-    ? channelTargets.filter((target) => target.sessionId && target.sessionId === originMeta.sessionId)
+    ? pageTargets.filter((target) => target.sessionId && target.sessionId === originMeta.sessionId)
     : [];
   if (sessionMatchedTargets.length === 1) {
     return {
@@ -1240,7 +1426,7 @@ function resolveForwardTargets(originWs, { channel, targetClientId }) {
   }
 
   const pageMatchedTargets = originMeta?.pageUrl
-    ? channelTargets.filter((target) => target.pageUrl && target.pageUrl === originMeta.pageUrl)
+    ? pageTargets.filter((target) => target.pageUrl && target.pageUrl === originMeta.pageUrl)
     : [];
   if (pageMatchedTargets.length === 1) {
     return {
@@ -1250,6 +1436,15 @@ function resolveForwardTargets(originWs, { channel, targetClientId }) {
     };
   }
 
+  const contextMatchedTarget = pickContextMatchedTarget(pageTargets, context);
+  if (contextMatchedTarget) {
+    return {
+      targets: [contextMatchedTarget],
+      resolvedTargetClientId: contextMatchedTarget.clientId,
+      error: null
+    };
+  }
+
   return {
     targets: [],
     resolvedTargetClientId: null,
@@ -1499,7 +1694,13 @@ function forwardIntegrationMessage(ws, data, { validator, type, awaitResult = fa
   }
 
   const { channel, targetClientId } = validation.payload;
-  const resolution = resolveForwardTargets(ws, { channel, targetClientId });
+  const requiredCapability = INTEGRATION_EDITOR_CAPABILITIES[type] || null;
+  const resolution = resolveForwardTargets(ws, {
+    channel,
+    targetClientId,
+    context: validation.payload.context,
+    requiredCapability
+  });
   if (resolution.error) {
     sendIntegrationError(ws, {
       requestId,
@@ -1519,7 +1720,6 @@ function forwardIntegrationMessage(ws, data, { validator, type, awaitResult = fa
     return;
   }
 
-  const requiredCapability = INTEGRATION_EDITOR_CAPABILITIES[type] || null;
   if (requiredCapability) {
     const unsupportedTarget = targets.find((target) => !target.capabilities?.includes(requiredCapability));
     if (unsupportedTarget) {
@@ -2014,6 +2214,7 @@ export function handleExternalAgentWebSocketConnection(ws, request) {
   });
 
   ws.on('close', () => {
+    removeSessionStateSubscriptionsForWs(ws);
     removeSessionActivitySubscriptionsForWs(ws);
     unregisterIntegrationConnection(ws);
   });

package/server/index.js

@@ -101,9 +101,11 @@ import {
   executeAgentPrompt,
   getActiveAgentSessions,
   isAgentSessionActive,
+  resolveAgentElicitation,
   resolveAgentPermission,
   setAgentSessionMode
 } from './acp-runtime/index.js';
+import { mergeAgentCommandOverrides } from './acp-runtime/command-overrides.js';
 import authRoutes from './routes/auth.js';
 import commandsRoutes from './routes/commands.js';
 import settingsRoutes from './routes/settings.js';
@@ -128,8 +130,11 @@ import userRoutes from './routes/user.js';
 import codexRoutes from './routes/codex.js';
 import opencodeRoutes from './routes/opencode.js';
 import sessionCoreRoutes from './routes/session-core.js';
+import runsRoutes from './routes/runs.js';
 import { parseCodexTokenCountInfo } from './utils/codexTokenUsage.js';
 import { getConfiguredDefaultProjectPath, resolveWorkingDirectory } from './utils/defaultWorkingDirectory.js';
+import { buildShellCommand } from './utils/shellCommand.js';
+import { openLocalTerminal } from './utils/localTerminal.js';
 import { initializeDatabase, userDb } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
 import { IS_PLATFORM } from './constants/config.js';
@@ -138,6 +143,8 @@ import { SessionEventMirrorWriter } from './session-core/runtimeWriter.js';
 import { abortAgentSessionWithWriter } from './session-core/abortSession.js';
 import { authenticateExternalWebSocketRequest } from './external-agent/auth.js';
 import { handleExternalAgentWebSocketConnection } from './external-agent/ws.js';
+import { runRegistry } from './session-core/runRegistry.js';
+import { shouldStartProjectsWatcher } from './projects-watcher-config.js';
 
 // File system watcher for projects folder
 let projectsWatcher = null;
@@ -520,6 +527,40 @@ app.use('/api/user', authenticateToken, userRoutes);
 app.use('/api/codex', authenticateToken, codexRoutes);
 app.use('/api/opencode', authenticateToken, opencodeRoutes);
 app.use('/api/session-core', authenticateToken, sessionCoreRoutes);
+app.use('/api', authenticateToken, runsRoutes);
+
+app.post('/api/local-terminal/session', authenticateToken, async (req, res) => {
+    try {
+        const provider = req.body?.provider || 'claude';
+        const sessionId = typeof req.body?.sessionId === 'string' ? req.body.sessionId.trim() : '';
+        const projectPath = resolveWorkingDirectory({ projectPath: req.body?.projectPath });
+
+        if (!sessionId) {
+            return res.status(400).json({ error: 'sessionId is required' });
+        }
+
+        const command = buildShellCommand({
+            projectPath,
+            provider,
+            sessionId,
+            hasSession: true,
+            platform: os.platform()
+        });
+        const terminal = openLocalTerminal({ command });
+
+        res.json({
+            success: true,
+            provider,
+            sessionId,
+            projectPath,
+            command,
+            terminal
+        });
+    } catch (error) {
+        console.error('[ERROR] Failed to open local terminal:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
 
 // Agent API Routes (uses API key authentication)
 app.use('/api/agent', agentRoutes);
@@ -651,6 +692,10 @@ app.get('/api/projects', authenticateToken, async (req, res) => {
 
 app.get('/api/projects/list', authenticateToken, async (req, res) => {
     try {
+        if (String(req.query.force || '').toLowerCase() === 'true') {
+            clearProjectDirectoryCache();
+            clearProviderSessionLookupCaches();
+        }
         const projects = await getProjectsList(broadcastProgress);
         res.json(projects);
     } catch (error) {
@@ -1161,21 +1206,89 @@ function handleChatConnection(ws) {
 
             if (agentCommandTypes.includes(data.type)) {
                 const agentKey = data.type.replace(/-command$/, '');
+                const clientRequestId = data.clientRequestId || data.options?.clientRequestId || null;
                 console.log(`[DEBUG] ${agentKey} message:`, data.command || '[Continue/Resume]');
                 console.log('📁 Project:', data.options?.projectPath || data.options?.cwd || 'Unknown');
                 console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
                 console.log('🤖 Model:', data.options?.model || 'default');
 
-                await executeAgentPrompt({
-                    agentKey,
-                    command: data.command,
-                    options: {
-                        ...(data.options || {}),
-                        clientRequestId: data.clientRequestId || data.options?.clientRequestId || null
-                    },
-                    writer: new SessionEventMirrorWriter(baseWriter, agentKey)
+                const run = runRegistry.createRun({
+                    provider: agentKey,
+                    sessionId: data.sessionId || data.options?.sessionId || null,
+                    clientRequestId
+                });
+                let sessionWriter = null;
+                const emitRunState = (status, event = {}) => {
+                    const resolvedSessionId = event.sessionId ||
+                        sessionWriter?.getSessionId?.() ||
+                        data.sessionId ||
+                        data.options?.sessionId ||
+                        null;
+                    const updatedRun = runRegistry.updateRun(run.runId, {
+                        status,
+                        sessionId: resolvedSessionId,
+                        clientRequestId
+                    }) || runRegistry.getRun(run.runId);
+                    const runEvent = runRegistry.appendRunEvent(run.runId, {
+                        type: 'run-state',
+                        provider: agentKey,
+                        sessionId: updatedRun?.sessionId || resolvedSessionId,
+                        clientRequestId,
+                        event: {
+                            status,
+                            ...event
+                        }
+                    });
+                    baseWriter.send({
+                        type: 'run-state',
+                        provider: agentKey,
+                        sessionId: updatedRun?.sessionId || resolvedSessionId,
+                        clientRequestId,
+                        runId: run.runId,
+                        runEventSeq: runEvent?.seq || updatedRun?.lastEventSeq || null,
+                        run: updatedRun,
+                        event: {
+                            status,
+                            ...event
+                        }
+                    });
+                };
+
+                sessionWriter = new SessionEventMirrorWriter(baseWriter, agentKey, {
+                    runRegistry,
+                    runId: run.runId,
+                    clientRequestId
                 });
-            } else if (data.type === 'abort-session') {
+                emitRunState('queued', { reason: 'accepted' });
+
+                try {
+                    emitRunState('running', { reason: 'execution_started' });
+                    const agentCommandOverrides = mergeAgentCommandOverrides(
+                        process.env.AXHUB_ACP_COMMAND_OVERRIDES,
+                        data.options?.agentCommandOverrides
+                    );
+                    const result = await executeAgentPrompt({
+                        agentKey,
+                        command: data.command,
+                        options: {
+                            ...(data.options || {}),
+                            ...(Object.keys(agentCommandOverrides).length > 0 ? { agentCommandOverrides } : {}),
+                            clientRequestId
+                        },
+                        writer: sessionWriter
+                    });
+                    emitRunState('succeeded', {
+                        sessionId: result?.sessionId || sessionWriter.getSessionId?.() || null,
+                        stopReason: result?.stopReason || null
+                    });
+                } catch (error) {
+                    emitRunState('failed', {
+                        sessionId: sessionWriter.getSessionId?.() || data.options?.sessionId || null,
+                        error: error.message
+                    });
+                    throw error;
+                }
+           } else if (data.type === 'abort-session') {
                 console.log('[DEBUG] Abort session request:', data.sessionId);
                 const provider = typeof data.provider === 'string' && data.provider.trim()
                     ? data.provider.trim().toLowerCase()
@@ -1213,6 +1326,15 @@ function handleChatConnection(ws) {
                         rememberEntry: data.rememberEntry
                     });
                 }
+            } else if (data.type === 'elicitation-response') {
+                if (data.requestId) {
+                    resolveAgentElicitation(data.requestId, {
+                        action: data.action,
+                        content: data.content && typeof data.content === 'object' && !Array.isArray(data.content)
+                            ? data.content
+                            : {}
+                    });
+                }
             } else if (data.type === 'check-session-status') {
                 // Check if a specific session is currently processing
                 const provider = data.provider || 'claude';
@@ -1350,47 +1472,14 @@ function handleShellConnection(ws) {
                 }));
 
                 try {
-                    // Prepare the shell command adapted to the platform and provider
-                    let shellCommand;
-                    if (isPlainShell) {
-                        // Plain shell mode - just run the initial command in the project directory
-                        if (os.platform() === 'win32') {
-                            shellCommand = `Set-Location -Path "${projectPath}"; ${initialCommand}`;
-                        } else {
-                            shellCommand = `cd "${projectPath}" && ${initialCommand}`;
-                        }
-                    } else if (provider === 'gemini') {
-                        if (os.platform() === 'win32') {
-                            if (hasSession && sessionId) {
-                                shellCommand = `Set-Location -Path "${projectPath}"; npx -y @google/gemini-cli --resume ${sessionId}`;
-                            } else {
-                                shellCommand = `Set-Location -Path "${projectPath}"; npx -y @google/gemini-cli`;
-                            }
-                        } else {
-                            if (hasSession && sessionId) {
-                                shellCommand = `cd "${projectPath}" && npx -y @google/gemini-cli --resume ${sessionId}`;
-                            } else {
-                                shellCommand = `cd "${projectPath}" && npx -y @google/gemini-cli`;
-                            }
-                        }
-                    } else {
-                        // Use claude command (default) or initialCommand if provided
-                        const command = initialCommand || 'claude';
-                        if (os.platform() === 'win32') {
-                            if (hasSession && sessionId) {
-                                // Try to resume session, but with fallback to new session if it fails
-                                shellCommand = `Set-Location -Path "${projectPath}"; claude --resume ${sessionId}; if ($LASTEXITCODE -ne 0) { claude }`;
-                            } else {
-                                shellCommand = `Set-Location -Path "${projectPath}"; ${command}`;
-                            }
-                        } else {
-                            if (hasSession && sessionId) {
-                                shellCommand = `cd "${projectPath}" && claude --resume ${sessionId} || claude`;
-                            } else {
-                                shellCommand = `cd "${projectPath}" && ${command}`;
-                            }
-                        }
-                    }
+                    const shellCommand = buildShellCommand({
+                        projectPath,
+                        provider,
+                        sessionId,
+                        hasSession,
+                        initialCommand,
+                        isPlainShell
+                    });
 
                     console.log('🔧 Executing shell command:', shellCommand);
 
@@ -2195,8 +2284,12 @@ async function startServer() {
 
             writeRuntimeStatusFile(PORT, isProduction);
 
-            // Start watching the projects folder for changes
-            await setupProjectsWatcher();
+            if (shouldStartProjectsWatcher()) {
+                // Opt-in only: provider session files are high-churn and expensive to poll.
+                await setupProjectsWatcher();
+            } else {
+                console.log(`${c.info('[INFO]')} Project/session file watcher: disabled; use manual refresh`);
+            }
         });
     } catch (error) {
         console.error('[ERROR] Failed to start server:', error);

package/server/projects-watcher-config.js

@@ -0,0 +1,4 @@
+export function shouldStartProjectsWatcher(env = process.env) {
+  const rawValue = String(env.AXHUB_GENIE_ENABLE_PROJECTS_WATCHER || '').trim().toLowerCase();
+  return rawValue === 'true' || rawValue === '1';
+}