@axhub/genie 0.2.11 → 0.2.12

package/server/routes/session-core.js

@@ -1,53 +1,64 @@
 import express from 'express';
-import crypto from 'node:crypto';
 import path from 'path';
 import {
-  getClaudeSessionMetadata,
-  getCodexSessionMetadata,
-  getGeminiSessionMetadata,
-  getOpencodeSessionMetadata,
-  getProjects,
+  getLocalProviderSessionMessages,
+  getLocalProviderSessions,
   getProjectsList
 } from '../projects.js';
 import { discoverAllProviders, discoverProvider } from '../session-core/providerDiscovery.js';
-import { getProviderAdapter } from '../session-core/providerAdapters.js';
-import { findAcpSessionRecord, listAcpSessions } from '../acp-runtime/session-store.js';
-import { mergeSessionLists } from '../session-core/sessionListMerge.js';
+import { probeAgentCapabilities } from '../acp-runtime/index.js';
+import { mergeAgentCommandOverrides } from '../acp-runtime/command-overrides.js';
+import { findAcpSessionRecord } from '../acp-runtime/session-store.js';
+import { runRegistry as defaultRunRegistry } from '../session-core/runRegistry.js';
+import { normalizeLegacyHistoryEntries } from '../../shared/conversationEvents.js';
 
 const router = express.Router();
+const ASSISTANT_TEXT_EVENT_KINDS = new Set([
+  'assistant_text_start',
+  'assistant_text_delta',
+  'assistant_text_end'
+]);
 
 router.use((req, res, next) => {
   res.setHeader('X-Runtime-Engine', 'acp');
   next();
 });
 
-async function flattenProjectSessions(project) {
+function getRequestAgentCommandOverrides(req) {
+  return mergeAgentCommandOverrides(
+    process.env.AXHUB_ACP_COMMAND_OVERRIDES,
+    req?.get?.('X-Axhub-Acp-Command-Overrides')
+  );
+}
+
+async function flattenProjectSessions(project, options = {}) {
   const projectPath = project.fullPath || project.path || null;
-  const groups = [
-    { provider: 'claude', items: project.sessions || [] },
-    { provider: 'codex', items: project.codexSessions || [] },
-    { provider: 'gemini', items: project.geminiSessions || [] },
-    { provider: 'opencode', items: project.opencodeSessions || [] }
-  ];
-
-  const acpSessions = await listAcpSessions({ projectPath });
-  const legacySessions = groups.flatMap(({ provider, items }) => (
-    items.map((item) => ({ ...item, provider, __provider: provider, source: item?.source || 'legacy' }))
-  ));
-  const normalizedAcpSessions = acpSessions.map((item) => ({
-    ...item,
-    provider: item.provider,
-    __provider: item.provider,
-    source: 'acp'
-  }));
-
-  return mergeSessionLists(legacySessions, normalizedAcpSessions);
+  const sessionGroups = await Promise.all(
+    ['claude', 'codex', 'gemini', 'opencode'].map(async (provider) => {
+      return getLocalProviderSessions({
+        provider,
+        projectName: project.name,
+        projectPath,
+        limit: 0
+      });
+    })
+  );
+
+  return sessionGroups
+    .flat()
+    .sort((left, right) => {
+      const leftTime = new Date(left?.lastActivity || left?.updatedAt || left?.createdAt || 0).getTime();
+      const rightTime = new Date(right?.lastActivity || right?.updatedAt || right?.createdAt || 0).getTime();
+      return rightTime - leftTime;
+    });
 }
 
 async function resolveProviderSessionRoute({
   provider,
   sessionId,
-  projectList = null
+  projectPath = null,
+  projectList = null,
+  agentCommandOverrides = {}
 }) {
   const normalizedProvider = String(provider || '').trim().toLowerCase();
   const normalizedSessionId = String(sessionId || '').trim();
@@ -69,8 +80,8 @@ async function resolveProviderSessionRoute({
     return path.normalize(withoutWindowsLongPathPrefix);
   };
 
-  const findProjectByPath = (projectPath) => {
-    const normalizedProjectPath = normalizeComparableProjectPath(projectPath);
+  const findProjectByPath = (candidateProjectPath) => {
+    const normalizedProjectPath = normalizeComparableProjectPath(candidateProjectPath);
     if (!normalizedProjectPath) {
       return null;
     }
@@ -81,81 +92,60 @@ async function resolveProviderSessionRoute({
     }) || null;
   };
 
-  const acpRecord = await findAcpSessionRecord(normalizedSessionId, normalizedProvider);
-  const acpProject = findProjectByPath(acpRecord?.projectPath || null);
-
-  let matchedProject = acpProject;
-  let resolvedSource = acpRecord ? 'acp' : 'legacy';
-
-  if (!matchedProject) {
-    switch (normalizedProvider) {
-      case 'claude': {
-        const metadata = await getClaudeSessionMetadata(normalizedSessionId);
-        matchedProject = findProjectByPath(metadata?.cwd || null);
-        break;
-      }
-      case 'codex': {
-        const metadata = await getCodexSessionMetadata(normalizedSessionId);
-        matchedProject = findProjectByPath(metadata?.cwd || null);
-        break;
-      }
-      case 'gemini': {
-        const metadata = await getGeminiSessionMetadata(normalizedSessionId);
-        const projectHash = String(metadata?.projectHash || '').trim();
-
-        if (projectHash) {
-          matchedProject = projects.find((project) => {
-            const projectPath = normalizeComparableProjectPath(project.fullPath || project.path || '');
-            if (!projectPath) {
-              return false;
-            }
-
-            const candidateHash = crypto.createHash('sha256').update(projectPath).digest('hex');
-            return candidateHash === projectHash;
-          }) || null;
-        }
-        break;
-      }
-      case 'opencode': {
-        const metadata = await getOpencodeSessionMetadata(normalizedSessionId);
-        matchedProject = findProjectByPath(metadata?.cwd || null);
-        break;
-      }
-      default:
-        break;
+  const findProjectByRouteContext = (routeProjectContext) => {
+    const matchedByPath = findProjectByPath(routeProjectContext);
+    if (matchedByPath) {
+      return matchedByPath;
     }
-  }
 
-  if (!matchedProject) {
-    return null;
-  }
+    const normalizedContext = normalizeComparableProjectPath(routeProjectContext);
+    if (!normalizedContext) {
+      return null;
+    }
 
-  const adapter = getProviderAdapter(normalizedProvider);
-  let sessions = [];
+    return projects.find((project) => [
+      project.name,
+      project.displayName
+    ].some((candidate) => normalizeComparableProjectPath(candidate) === normalizedContext)) || null;
+  };
 
-  if (normalizedProvider === 'claude') {
-    sessions = await adapter.listSessions({
-      projectName: matchedProject.name,
-      projectPath: matchedProject.fullPath || matchedProject.path,
-      limit: 1000,
-      offset: 0
-    });
-  } else {
-    sessions = await adapter.listSessions({
-      projectPath: matchedProject.fullPath || matchedProject.path,
-      limit: 0
-    });
-  }
+  const acpRecord = await findAcpSessionRecord(normalizedSessionId, normalizedProvider);
+  const matchedProject = findProjectByPath(acpRecord?.projectPath || null)
+    || (!acpRecord ? findProjectByRouteContext(projectPath) : null);
 
-  const matchedSession = (Array.isArray(sessions) ? sessions : []).find((session) => session.id === normalizedSessionId);
-  if (!matchedSession) {
+  if (!matchedProject) {
     return null;
   }
 
+  const resolvedProjectPath = acpRecord?.projectPath
+    || matchedProject.fullPath
+    || matchedProject.path
+    || projectPath
+    || null;
+  const resolvedSession = {
+    id: normalizedSessionId,
+    sessionId: normalizedSessionId,
+    provider: normalizedProvider,
+    __provider: normalizedProvider,
+    source: 'acp',
+    runtime: 'acp',
+    projectPath: resolvedProjectPath,
+    cwd: resolvedProjectPath,
+    title: acpRecord?.title || acpRecord?.summary || normalizedSessionId,
+    summary: acpRecord?.summary || null,
+    model: acpRecord?.model || null,
+    createdAt: acpRecord?.createdAt || null,
+    updatedAt: acpRecord?.updatedAt || null,
+    lastActivity: acpRecord?.lastActivity || acpRecord?.updatedAt || acpRecord?.createdAt || null,
+    lastPromptAt: acpRecord?.lastPromptAt || null,
+    closedAt: acpRecord?.closedAt || null,
+    isClosed: Boolean(acpRecord?.isClosed)
+  };
+
   return {
     provider: normalizedProvider,
-    source: matchedSession.source || resolvedSource,
-    session: matchedSession,
+    source: resolvedSession.source || 'acp',
+    session: resolvedSession,
     project: {
       name: matchedProject.name,
       fullPath: matchedProject.fullPath || matchedProject.path,
@@ -165,6 +155,236 @@ async function resolveProviderSessionRoute({
   };
 }
 
+function normalizeComparableText(value) {
+  return String(value || '').replace(/\r\n/g, '\n').trim();
+}
+
+function normalizeNullableString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function getAssistantTextGroupKey(event, index) {
+  return normalizeNullableString(event?.payload?.messageId || event?.extensions?.messageId)
+    || `event:${event?.eventId || index}`;
+}
+
+function collectAssistantTextGroups(events = []) {
+  const groups = new Map();
+  (Array.isArray(events) ? events : []).forEach((event, index) => {
+    if (!ASSISTANT_TEXT_EVENT_KINDS.has(event?.kind)) {
+      return;
+    }
+
+    const key = getAssistantTextGroupKey(event, index);
+    const group = groups.get(key) || {
+      events: [],
+      text: ''
+    };
+    group.events.push(event);
+    if (event.kind === 'assistant_text_delta') {
+      group.text += String(event.payload?.text || '');
+    }
+    groups.set(key, group);
+  });
+  return groups;
+}
+
+function isAssistantTextCoveredByRunTexts(text, runAssistantTexts) {
+  const normalizedText = normalizeComparableText(text);
+  if (!normalizedText || !(runAssistantTexts instanceof Set) || runAssistantTexts.size === 0) {
+    return false;
+  }
+
+  if (runAssistantTexts.has(normalizedText)) {
+    return true;
+  }
+
+  const parts = Array.from(runAssistantTexts)
+    .map((part) => normalizeComparableText(part))
+    .filter((part) => part && normalizedText.includes(part))
+    .sort((left, right) => right.length - left.length);
+
+  if (parts.length === 0) {
+    return false;
+  }
+
+  const reachable = new Array(normalizedText.length + 1).fill(false);
+  reachable[0] = true;
+  for (let index = 0; index < normalizedText.length; index += 1) {
+    if (!reachable[index]) {
+      continue;
+    }
+    for (const part of parts) {
+      if (normalizedText.startsWith(part, index)) {
+        reachable[index + part.length] = true;
+      }
+    }
+  }
+
+  return reachable[normalizedText.length] === true;
+}
+
+function collectRunRegistryConversationEvents({ provider, sessionId, runRegistry = defaultRunRegistry } = {}) {
+  if (!runRegistry || typeof runRegistry.listSessionRuns !== 'function' || typeof runRegistry.listRunEvents !== 'function') {
+    return [];
+  }
+
+  return runRegistry
+    .listSessionRuns({ provider, sessionId })
+    .flatMap((run) => runRegistry.listRunEvents(run.runId, { after: 0 }))
+    .filter((runEvent) => runEvent?.type === 'conversation-event' && runEvent.event)
+    .map((runEvent) => ({
+      ...runEvent.event,
+      provider: runEvent.event.provider || runEvent.provider || provider,
+      sessionId: runEvent.event.sessionId || runEvent.sessionId || sessionId
+    }));
+}
+
+function collectUserMessageTimesByText(events = []) {
+  const timesByText = new Map();
+  (Array.isArray(events) ? events : []).forEach((event) => {
+    if (event?.kind !== 'user_message') {
+      return;
+    }
+
+    const text = normalizeComparableText(event.payload?.text);
+    if (!text) {
+      return;
+    }
+
+    const timestamp = Date.parse(event.timestamp || '');
+    const times = timesByText.get(text) || [];
+    times.push(Number.isFinite(timestamp) ? timestamp : 0);
+    timesByText.set(text, times);
+  });
+  return timesByText;
+}
+
+function isDuplicateAcpUserReplay(event, runUserTimesByText) {
+  if (event?.kind !== 'user_message') {
+    return false;
+  }
+
+  const text = normalizeComparableText(event.payload?.text);
+  if (!text) {
+    return false;
+  }
+
+  const runTimes = runUserTimesByText.get(text);
+  if (!Array.isArray(runTimes) || runTimes.length === 0) {
+    return false;
+  }
+
+  const acpTime = Date.parse(event.timestamp || '');
+  if (!Number.isFinite(acpTime)) {
+    return true;
+  }
+
+  return runTimes.some((runTime) => runTime <= acpTime);
+}
+
+function getConversationEventDedupeKey(event) {
+  if (event?.eventId) {
+    return `id:${event.eventId}`;
+  }
+  return [
+    'shape',
+    event?.kind || '',
+    event?.provider || '',
+    event?.sessionId || '',
+    event?.timestamp || '',
+    JSON.stringify(event?.payload || {})
+  ].join('\u0000');
+}
+
+function loadLocalSessionEventsResult(result, provider, sessionId) {
+  const rawMessages = Array.isArray(result)
+    ? result
+    : Array.isArray(result?.messages)
+    ? result.messages
+    : Array.isArray(result?.events)
+      ? result.events
+      : [];
+
+  const events = normalizeLegacyHistoryEntries(rawMessages, provider, sessionId);
+
+  return {
+    source: 'native-history',
+    events,
+    total: typeof result?.total === 'number' ? result.total : rawMessages.length,
+    hasMore: typeof result?.hasMore === 'boolean' ? result.hasMore : false,
+    offset: typeof result?.offset === 'number' ? result.offset : 0,
+    limit: Object.prototype.hasOwnProperty.call(result || {}, 'limit') ? result.limit : null,
+    ...(result?.tokenUsage ? { tokenUsage: result.tokenUsage } : {})
+  };
+}
+
+export function mergeSessionEventsWithRunRegistryEvents(events = [], {
+  provider,
+  sessionId,
+  runRegistry = defaultRunRegistry
+} = {}) {
+  const acpEvents = Array.isArray(events) ? events : [];
+  const runEvents = collectRunRegistryConversationEvents({ provider, sessionId, runRegistry });
+
+  if (runEvents.length === 0) {
+    return acpEvents;
+  }
+
+  const runAssistantTexts = new Set(
+    Array.from(collectAssistantTextGroups(runEvents).values())
+      .map((group) => normalizeComparableText(group.text))
+      .filter(Boolean)
+  );
+  const runUserTimesByText = collectUserMessageTimesByText(runEvents);
+  const duplicateAcpAssistantEventIds = new Set();
+  const duplicateAcpAssistantEventRefs = new Set();
+
+  for (const group of collectAssistantTextGroups(acpEvents).values()) {
+    const text = normalizeComparableText(group.text);
+    if (!text || !isAssistantTextCoveredByRunTexts(text, runAssistantTexts)) {
+      continue;
+    }
+    group.events.forEach((event) => {
+      if (event?.eventId) {
+        duplicateAcpAssistantEventIds.add(event.eventId);
+      } else {
+        duplicateAcpAssistantEventRefs.add(event);
+      }
+    });
+  }
+
+  const filteredAcpEvents = acpEvents.filter((event) => !(
+    isDuplicateAcpUserReplay(event, runUserTimesByText) ||
+    (event?.eventId && duplicateAcpAssistantEventIds.has(event.eventId)) ||
+    duplicateAcpAssistantEventRefs.has(event)
+  ));
+  const ordered = [...filteredAcpEvents, ...runEvents].map((event, index) => ({ event, index }));
+  ordered.sort((left, right) => {
+    const leftTime = Date.parse(left.event?.timestamp || '');
+    const rightTime = Date.parse(right.event?.timestamp || '');
+    const normalizedLeftTime = Number.isFinite(leftTime) ? leftTime : 0;
+    const normalizedRightTime = Number.isFinite(rightTime) ? rightTime : 0;
+    if (normalizedLeftTime !== normalizedRightTime) {
+      return normalizedLeftTime - normalizedRightTime;
+    }
+    return left.index - right.index;
+  });
+
+  const seen = new Set();
+  const merged = [];
+  for (const { event } of ordered) {
+    const key = getConversationEventDedupeKey(event);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    merged.push(event);
+  }
+
+  return merged;
+}
+
 router.get('/providers', async (req, res) => {
   try {
     const providers = await discoverAllProviders({ projectPath: req.query.projectPath });
@@ -176,16 +396,33 @@ router.get('/providers', async (req, res) => {
 
 router.get('/providers/:provider', async (req, res) => {
   try {
-    const result = await discoverProvider(req.params.provider, { projectPath: req.query.projectPath });
+    const result = await discoverProvider(req.params.provider, {
+      projectPath: req.query.projectPath,
+      force: req.query.force
+    });
     res.json({ success: true, ...result });
   } catch (error) {
     res.status(500).json({ success: false, error: error.message });
   }
 });
 
+router.get('/providers/:provider/acp-capabilities', async (req, res) => {
+  try {
+    const agentCommandOverrides = getRequestAgentCommandOverrides(req);
+    const result = await probeAgentCapabilities(req.params.provider, {
+      projectPath: req.query.projectPath,
+      force: req.query.force,
+      ...(Object.keys(agentCommandOverrides).length > 0 ? { agentCommandOverrides } : {}),
+    });
+    res.json({ success: true, provider: req.params.provider, capabilitySnapshot: result });
+  } catch (error) {
+    res.status(500).json({ success: false, provider: req.params.provider, error: error.message });
+  }
+});
+
 router.get('/projects/:projectName/history-index', async (req, res) => {
   try {
-    const projects = await getProjects();
+    const projects = await getProjectsList();
     const project = projects.find((entry) => entry.name === req.params.projectName);
     if (!project) {
       return res.status(404).json({ success: false, error: 'Project not found' });
@@ -197,7 +434,9 @@ router.get('/projects/:projectName/history-index', async (req, res) => {
         fullPath: project.fullPath || project.path,
         displayName: project.displayName || project.name
       },
-      sessions: await flattenProjectSessions(project)
+      sessions: await flattenProjectSessions(project, {
+        agentCommandOverrides: getRequestAgentCommandOverrides(req)
+      })
     });
   } catch (error) {
     res.status(500).json({ success: false, error: error.message });
@@ -215,11 +454,13 @@ router.get('/sessions/:provider/:sessionId/resolve', async (req, res) => {
 
     const result = await resolveProviderSessionRoute({
       provider: requestedProvider,
-      sessionId: requestedSessionId
+      sessionId: requestedSessionId,
+      projectPath: req.query.projectPath || req.query.cwd || req.query.workdir || req.query.project || req.query.projectName || null,
+      agentCommandOverrides: getRequestAgentCommandOverrides(req)
     });
 
     if (!result) {
-      return res.status(404).json({ success: true, found: false });
+      return res.json({ success: true, found: false });
     }
 
     res.json({
@@ -234,19 +475,26 @@ router.get('/sessions/:provider/:sessionId/resolve', async (req, res) => {
 
 router.get('/sessions/:provider/:sessionId/events', async (req, res) => {
   try {
-    const adapter = getProviderAdapter(req.params.provider);
     const parsedLimit = req.query.limit ? parseInt(req.query.limit, 10) : null;
     const parsedOffset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
-    const result = await adapter.loadEvents({
+    const result = loadLocalSessionEventsResult(await getLocalProviderSessionMessages({
+      provider: req.params.provider,
       projectName: req.query.projectName,
-      projectPath: req.query.projectPath,
       sessionId: req.params.sessionId,
       limit: parsedLimit,
       offset: parsedOffset
-    });
+    }), req.params.provider, req.params.sessionId);
 
-    const events = Array.isArray(result) ? result : (result?.events || result?.messages || []);
-    const total = typeof result?.total === 'number' ? result.total : events.length;
+    const rawEvents = Array.isArray(result) ? result : (result?.events || result?.messages || []);
+    const events = mergeSessionEventsWithRunRegistryEvents(rawEvents, {
+      provider: req.params.provider,
+      sessionId: req.params.sessionId,
+      runRegistry: defaultRunRegistry
+    });
+    const total = Math.max(
+      typeof result?.total === 'number' ? result.total : rawEvents.length,
+      events.length
+    );
     const hasMore = typeof result?.hasMore === 'boolean' ? result.hasMore : false;
     const offset = typeof result?.offset === 'number' ? result.offset : parsedOffset;
     const limit = Object.prototype.hasOwnProperty.call(result || {}, 'limit')
@@ -257,7 +505,7 @@ router.get('/sessions/:provider/:sessionId/events', async (req, res) => {
       success: true,
       provider: req.params.provider,
       sessionId: req.params.sessionId,
-      source: result?.source || 'legacy',
+      source: result?.source || 'acp',
       events,
       total,
       hasMore,