@axhub/genie 0.2.11 → 0.2.12

package/server/acp-runtime/registry.js

@@ -1,13 +1,15 @@
 const ACP_ADAPTER_PACKAGE_RANGES = {
-  claude: '^0.26.0',
-  codex: '^0.11.1'
+  claude: '^0.37.0',
+  codex: '^0.15.0',
+  gemini: '^0.43.0',
+  opencode: '^1.15.10'
 };
 
 export const AGENT_REGISTRY = {
   claude: `npx -y @agentclientprotocol/claude-agent-acp@${ACP_ADAPTER_PACKAGE_RANGES.claude}`,
   codex: `npx @zed-industries/codex-acp@${ACP_ADAPTER_PACKAGE_RANGES.codex}`,
-  gemini: 'gemini --acp',
-  opencode: 'npx -y opencode-ai acp'
+  gemini: `npx -y @google/gemini-cli@${ACP_ADAPTER_PACKAGE_RANGES.gemini} --acp --skip-trust`,
+  opencode: `npx -y opencode-ai@${ACP_ADAPTER_PACKAGE_RANGES.opencode} acp`
 };
 
 const AGENT_ALIASES = {

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

@@ -1,7 +1,6 @@
 import fs from 'fs/promises';
 import os from 'os';
 import path from 'path';
-import { readMirroredConversationEvents } from '../session-core/eventStore.js';
 
 function parsePositiveInteger(value, fallback) {
   const parsed = parseInt(value, 10);
@@ -9,6 +8,10 @@ function parsePositiveInteger(value, fallback) {
 }
 
 const DEFAULT_SESSION_GC_MAX_AGE_DAYS = parsePositiveInteger(process.env.ACP_SESSION_GC_MAX_AGE_DAYS, 30);
+const sessionRecordWriteQueues = new Map();
+let sessionIndexMutationQueue = Promise.resolve();
+const SUPPORTED_SESSION_PROVIDERS = ['claude', 'codex', 'gemini', 'opencode'];
+const SESSION_INDEX_VERSION = 1;
 
 function normalizeProvider(value) {
   return String(value || '').trim().toLowerCase();
@@ -19,13 +22,21 @@ function normalizeSessionId(value) {
   return normalized || null;
 }
 
-function getProviderDir(provider) {
-  const sessionRoot = process.env.AXHUB_GENIE_ACP_SESSION_ROOT
+function getSessionRoot() {
+  return process.env.AXHUB_GENIE_ACP_SESSION_ROOT
     ? path.resolve(process.env.AXHUB_GENIE_ACP_SESSION_ROOT)
     : path.join(os.homedir(), '.axhub-genie', 'acp-sessions');
+}
+
+function getProviderDir(provider) {
+  const sessionRoot = getSessionRoot();
   return path.join(sessionRoot, normalizeProvider(provider));
 }
 
+function getSessionIndexFilePath() {
+  return path.join(getSessionRoot(), 'index.json');
+}
+
 function getSessionFilePath(provider, sessionId) {
   return path.join(getProviderDir(provider), `${encodeURIComponent(sessionId)}.json`);
 }
@@ -42,6 +53,10 @@ async function ensureProviderDir(provider) {
   await fs.mkdir(getProviderDir(provider), { recursive: true });
 }
 
+async function ensureSessionRootDir() {
+  await fs.mkdir(getSessionRoot(), { recursive: true });
+}
+
 async function listProviderSessionFiles(provider) {
   try {
     const entries = await fs.readdir(getProviderDir(provider), { withFileTypes: true });
@@ -64,6 +79,26 @@ async function readJsonFile(filePath) {
     if (error?.code === 'ENOENT') {
       return null;
     }
+    if (error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function writeJsonFileAtomically(filePath, content) {
+  const tempPath = [
+    filePath,
+    process.pid,
+    Date.now(),
+    Math.random().toString(36).slice(2)
+  ].join('.') + '.tmp';
+
+  try {
+    await fs.writeFile(tempPath, content, 'utf8');
+    await fs.rename(tempPath, filePath);
+  } catch (error) {
+    await fs.rm(tempPath, { force: true }).catch(() => {});
     throw error;
   }
 }
@@ -73,15 +108,26 @@ function createSessionSummary(record) {
     return null;
   }
 
+  const provider = normalizeProvider(record.provider);
+  const sessionId = normalizeSessionId(record.sessionId || record.id);
+  if (!provider || !sessionId) {
+    return null;
+  }
+
+  const projectPath = typeof record.projectPath === 'string' && record.projectPath.trim()
+    ? record.projectPath
+    : (typeof record.cwd === 'string' && record.cwd.trim() ? record.cwd : null);
+
   return {
-    id: record.sessionId,
-    sessionId: record.sessionId,
-    provider: record.provider,
+    id: sessionId,
+    sessionId,
+    provider,
+    __provider: provider,
     source: 'acp',
     runtime: 'acp',
-    projectPath: record.projectPath || null,
-    cwd: record.projectPath || null,
-    title: record.title || record.sessionId,
+    projectPath,
+    cwd: projectPath,
+    title: record.title || sessionId,
     summary: record.summary || null,
     model: record.model || null,
     createdAt: record.createdAt || null,
@@ -93,71 +139,132 @@ function createSessionSummary(record) {
   };
 }
 
-function extractVisibleUserPrompt(value) {
-  const text = String(value || '').trim();
-  if (!text) {
-    return '';
-  }
+function normalizeIndexSession(value) {
+  return createSessionSummary(value);
+}
 
-  if (
-    text.startsWith('# AGENTS.md instructions for ') ||
-    text.includes('<environment_context>') ||
-    text.startsWith('<subagent_notification>') ||
-    text.startsWith('</subagent_notification>')
-  ) {
-    return '';
-  }
+function getIndexSessionKey(session) {
+  const provider = normalizeProvider(session?.provider || session?.__provider);
+  const sessionId = normalizeSessionId(session?.sessionId || session?.id);
+  return provider && sessionId ? `${provider}\u0000${sessionId}` : null;
+}
 
-  if (text.startsWith('[DYNAMIC CONTEXT V1]')) {
-    const marker = '\n\n[USER MESSAGE]\n';
-    const markerIndex = text.indexOf(marker);
-    if (markerIndex >= 0) {
-      return text.slice(markerIndex + marker.length).trim();
+function uniqueSessionSummaries(sessions = []) {
+  const byKey = new Map();
+  for (const session of sessions) {
+    const summary = normalizeIndexSession(session);
+    const key = getIndexSessionKey(summary);
+    if (!key) {
+      continue;
     }
-    return '';
+    byKey.set(key, summary);
   }
+  return sortSessionsByActivity(Array.from(byKey.values()));
+}
 
-  const dynamicContextMatch = text.match(
-    /^<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>\s*<user_message>\s*([\s\S]*?)\s*<\/user_message>$/i
-  );
-  if (dynamicContextMatch) {
-    return String(dynamicContextMatch[1] || '').trim();
+function normalizeSessionIndex(index) {
+  if (!index || typeof index !== 'object' || !Array.isArray(index.sessions)) {
+    return null;
   }
 
-  return text;
+  return {
+    version: SESSION_INDEX_VERSION,
+    updatedAt: typeof index.updatedAt === 'string' ? index.updatedAt : null,
+    sessions: uniqueSessionSummaries(index.sessions)
+  };
 }
 
-function truncateSessionSummary(text, maxLength = 50) {
-  const normalizedText = typeof text === 'string' ? text.trim() : '';
-  if (!normalizedText) {
-    return null;
-  }
+async function writeSessionIndex(sessions = []) {
+  const index = {
+    version: SESSION_INDEX_VERSION,
+    updatedAt: new Date().toISOString(),
+    sessions: uniqueSessionSummaries(sessions)
+  };
 
-  return normalizedText.length > maxLength
-    ? `${normalizedText.slice(0, maxLength)}...`
-    : normalizedText;
+  await ensureSessionRootDir();
+  await writeJsonFileAtomically(getSessionIndexFilePath(), `${JSON.stringify(index, null, 2)}\n`);
+  return index;
 }
 
-async function deriveSummaryFromMirroredEvents(record) {
-  if (!record?.provider || !record?.sessionId) {
-    return null;
-  }
+async function readSessionIndex() {
+  const index = await readJsonFile(getSessionIndexFilePath());
+  return normalizeSessionIndex(index);
+}
 
-  const events = await readMirroredConversationEvents(record.provider, record.sessionId);
-  for (const event of events) {
-    if (event?.kind !== 'user_message') {
+async function scanSessionRecordSummaries({ provider = null } = {}) {
+  const providers = provider ? [normalizeProvider(provider)] : SUPPORTED_SESSION_PROVIDERS;
+  const sessions = [];
+
+  for (const currentProvider of providers) {
+    if (!currentProvider) {
       continue;
     }
 
-    const rawText = event?.payload?.text || event?.payload?.message || '';
-    const visiblePrompt = extractVisibleUserPrompt(rawText);
-    const summary = truncateSessionSummary(visiblePrompt);
-    if (summary) {
-      return summary;
+    const filePaths = await listProviderSessionFiles(currentProvider);
+    for (const filePath of filePaths) {
+      const record = await readJsonFile(filePath);
+      const summary = createSessionSummary(record);
+      if (summary) {
+        sessions.push(summary);
+      }
     }
   }
 
-  return null;
+  return uniqueSessionSummaries(sessions);
+}
+
+async function rebuildSessionIndex() {
+  const sessions = await scanSessionRecordSummaries();
+  return writeSessionIndex(sessions);
+}
+
+async function readOrRebuildSessionIndex() {
+  const index = await readSessionIndex();
+  return index || rebuildSessionIndex();
+}
+
+async function queueSessionIndexMutation(operation) {
+  const currentMutation = sessionIndexMutationQueue
+    .catch(() => {})
+    .then(operation);
+
+  sessionIndexMutationQueue = currentMutation.catch(() => {});
+  return currentMutation;
+}
+
+async function upsertSessionIndexEntry(record) {
+  return queueSessionIndexMutation(async () => {
+    const summary = createSessionSummary(record);
+    if (!summary) {
+      return null;
+    }
+
+    const index = await readOrRebuildSessionIndex();
+    const key = getIndexSessionKey(summary);
+    const nextSessions = (index.sessions || []).filter((session) => getIndexSessionKey(session) !== key);
+    nextSessions.push(summary);
+    await writeSessionIndex(nextSessions);
+    return summary;
+  });
+}
+
+export async function removeAcpSessionIndexEntry(provider, sessionId) {
+  return queueSessionIndexMutation(async () => {
+    const normalizedProvider = normalizeProvider(provider);
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedProvider || !normalizedSessionId) {
+      return false;
+    }
+
+    const index = await readOrRebuildSessionIndex();
+    const removeKey = `${normalizedProvider}\u0000${normalizedSessionId}`;
+    const nextSessions = (index.sessions || []).filter((session) => getIndexSessionKey(session) !== removeKey);
+    const removed = nextSessions.length !== index.sessions.length;
+    if (removed) {
+      await writeSessionIndex(nextSessions);
+    }
+    return removed;
+  });
 }
 
 function getSessionActivityTime(record) {
@@ -181,14 +288,7 @@ export async function readAcpSessionRecord(provider, sessionId) {
   return record && typeof record === 'object' ? record : null;
 }
 
-export async function writeAcpSessionRecord(record) {
-  const normalizedProvider = normalizeProvider(record?.provider);
-  const normalizedSessionId = normalizeSessionId(record?.sessionId);
-
-  if (!normalizedProvider || !normalizedSessionId) {
-    throw new Error('provider and sessionId are required to persist an ACP session');
-  }
-
+async function writeAcpSessionRecordUnlocked(record, normalizedProvider, normalizedSessionId) {
   const now = new Date().toISOString();
   const existing = await readAcpSessionRecord(normalizedProvider, normalizedSessionId);
   const nextRecord = {
@@ -211,11 +311,37 @@ export async function writeAcpSessionRecord(record) {
 
   await ensureProviderDir(normalizedProvider);
   const filePath = getSessionFilePath(normalizedProvider, normalizedSessionId);
-  await fs.writeFile(filePath, `${JSON.stringify(nextRecord, null, 2)}\n`, 'utf8');
+  await writeJsonFileAtomically(filePath, `${JSON.stringify(nextRecord, null, 2)}\n`);
+  await upsertSessionIndexEntry(nextRecord);
 
   return nextRecord;
 }
 
+export async function writeAcpSessionRecord(record) {
+  const normalizedProvider = normalizeProvider(record?.provider);
+  const normalizedSessionId = normalizeSessionId(record?.sessionId);
+
+  if (!normalizedProvider || !normalizedSessionId) {
+    throw new Error('provider and sessionId are required to persist an ACP session');
+  }
+
+  const queueKey = `${normalizedProvider}\u0000${normalizedSessionId}`;
+  const previousWrite = sessionRecordWriteQueues.get(queueKey) || Promise.resolve();
+  const currentWrite = previousWrite
+    .catch(() => {})
+    .then(() => writeAcpSessionRecordUnlocked(record, normalizedProvider, normalizedSessionId));
+
+  sessionRecordWriteQueues.set(queueKey, currentWrite);
+
+  try {
+    return await currentWrite;
+  } finally {
+    if (sessionRecordWriteQueues.get(queueKey) === currentWrite) {
+      sessionRecordWriteQueues.delete(queueKey);
+    }
+  }
+}
+
 export async function touchAcpSessionRecord(record) {
   return writeAcpSessionRecord(record);
 }
@@ -232,13 +358,45 @@ export async function closeAcpSessionRecord(provider, sessionId, updates = {}) {
   });
 }
 
+async function deleteAcpSessionRecordUnlocked(normalizedProvider, normalizedSessionId) {
+  const existing = await readAcpSessionRecord(normalizedProvider, normalizedSessionId);
+  await fs.rm(getSessionFilePath(normalizedProvider, normalizedSessionId), { force: true });
+  await removeAcpSessionIndexEntry(normalizedProvider, normalizedSessionId);
+  return Boolean(existing);
+}
+
+export async function deleteAcpSessionRecord(provider, sessionId) {
+  const normalizedProvider = normalizeProvider(provider);
+  const normalizedSessionId = normalizeSessionId(sessionId);
+
+  if (!normalizedProvider || !normalizedSessionId) {
+    return false;
+  }
+
+  const queueKey = `${normalizedProvider}\u0000${normalizedSessionId}`;
+  const previousWrite = sessionRecordWriteQueues.get(queueKey) || Promise.resolve();
+  const currentWrite = previousWrite
+    .catch(() => {})
+    .then(() => deleteAcpSessionRecordUnlocked(normalizedProvider, normalizedSessionId));
+
+  sessionRecordWriteQueues.set(queueKey, currentWrite);
+
+  try {
+    return await currentWrite;
+  } finally {
+    if (sessionRecordWriteQueues.get(queueKey) === currentWrite) {
+      sessionRecordWriteQueues.delete(queueKey);
+    }
+  }
+}
+
 export async function gcOldAcpSessions({ provider = null, maxAgeDays = DEFAULT_SESSION_GC_MAX_AGE_DAYS, includeOpen = false } = {}) {
   const normalizedMaxAgeDays = Number(maxAgeDays);
   if (!Number.isFinite(normalizedMaxAgeDays) || normalizedMaxAgeDays <= 0) {
     return { removed: 0 };
   }
 
-  const providers = provider ? [normalizeProvider(provider)] : ['claude', 'codex', 'gemini', 'opencode'];
+  const providers = provider ? [normalizeProvider(provider)] : SUPPORTED_SESSION_PROVIDERS;
   const cutoffTime = Date.now() - (normalizedMaxAgeDays * 24 * 60 * 60 * 1000);
   let removed = 0;
 
@@ -264,6 +422,7 @@ export async function gcOldAcpSessions({ provider = null, maxAgeDays = DEFAULT_S
       }
 
       await fs.rm(filePath, { force: true });
+      await removeAcpSessionIndexEntry(currentProvider, record.sessionId).catch(() => {});
       removed += 1;
     }
   }
@@ -273,35 +432,19 @@ export async function gcOldAcpSessions({ provider = null, maxAgeDays = DEFAULT_S
 
 export async function listAcpSessions({ provider = null, projectPath = null } = {}) {
   await gcOldAcpSessions({ provider }).catch(() => {});
-  const providers = provider ? [normalizeProvider(provider)] : ['claude', 'codex', 'gemini', 'opencode'];
-  const sessions = [];
-
-  for (const currentProvider of providers) {
-    if (!currentProvider) {
-      continue;
+  const providers = new Set(provider ? [normalizeProvider(provider)] : SUPPORTED_SESSION_PROVIDERS);
+  const index = await readOrRebuildSessionIndex();
+  const sessions = (index.sessions || []).filter((session) => {
+    if (!providers.has(normalizeProvider(session.provider))) {
+      return false;
     }
 
-    const filePaths = await listProviderSessionFiles(currentProvider);
-    for (const filePath of filePaths) {
-      const record = await readJsonFile(filePath);
-      const hydratedRecord = record && !record.summary
-        ? {
-            ...record,
-            summary: await deriveSummaryFromMirroredEvents(record)
-          }
-        : record;
-      const summary = createSessionSummary(hydratedRecord);
-      if (!summary) {
-        continue;
-      }
-
-      if (projectPath && summary.projectPath !== projectPath) {
-        continue;
-      }
-
-      sessions.push(summary);
+    if (projectPath && session.projectPath !== projectPath) {
+      return false;
     }
-  }
+
+    return true;
+  });
 
   return sortSessionsByActivity(sessions);
 }
@@ -316,7 +459,7 @@ export async function findAcpSessionRecord(sessionId, provider = null) {
     return readAcpSessionRecord(provider, normalizedSessionId);
   }
 
-  const providers = ['claude', 'codex', 'gemini', 'opencode'];
+  const providers = SUPPORTED_SESSION_PROVIDERS;
   for (const currentProvider of providers) {
     const record = await readAcpSessionRecord(currentProvider, normalizedSessionId);
     if (record) {

package/server/database/db.js

@@ -79,9 +79,18 @@ function normalizeState(rawState) {
 
 function persistStateSync(nextState) {
   ensureDataDirectory();
-  const tempPath = `${DATA_FILE_PATH}.tmp`;
-  fs.writeFileSync(tempPath, `${JSON.stringify(nextState, null, 2)}\n`, 'utf8');
-  fs.renameSync(tempPath, DATA_FILE_PATH);
+  const tempPath = `${DATA_FILE_PATH}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    fs.writeFileSync(tempPath, `${JSON.stringify(nextState, null, 2)}\n`, 'utf8');
+    fs.renameSync(tempPath, DATA_FILE_PATH);
+  } catch (error) {
+    try {
+      fs.rmSync(tempPath, { force: true });
+    } catch {
+      // Best-effort cleanup for failed atomic writes.
+    }
+    throw error;
+  }
   stateCache = nextState;
 }