@axhub/genie 0.2.5 → 0.2.7

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

@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict';
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import test from 'node:test';
+import { pathToFileURL } from 'node:url';
+
+async function loadSessionStore(sessionRoot) {
+  process.env.AXHUB_GENIE_ACP_SESSION_ROOT = sessionRoot;
+  const moduleUrl = `${pathToFileURL(path.resolve('server/acp-runtime/session-store.js')).href}?root=${encodeURIComponent(sessionRoot)}&ts=${Date.now()}`;
+  return import(moduleUrl);
+}
+
+async function createTempSessionRoot() {
+  return fs.mkdtemp(path.join(os.tmpdir(), 'axhub-genie-acp-sessions-'));
+}
+
+test('session-store persists and lists ACP sessions', async () => {
+  const sessionRoot = await createTempSessionRoot();
+
+  try {
+    const sessionStore = await loadSessionStore(sessionRoot);
+
+    await sessionStore.writeAcpSessionRecord({
+      provider: 'claude',
+      sessionId: 'session-a',
+      projectPath: '/tmp/project-a',
+      model: 'claude-sonnet-4',
+      title: 'Session A',
+      lastActivity: '2026-03-30T10:00:00.000Z',
+      lastPromptAt: '2026-03-30T10:00:00.000Z'
+    });
+
+    const record = await sessionStore.readAcpSessionRecord('claude', 'session-a');
+    assert.equal(record.provider, 'claude');
+    assert.equal(record.sessionId, 'session-a');
+    assert.equal(record.projectPath, '/tmp/project-a');
+
+    const sessions = await sessionStore.listAcpSessions({
+      provider: 'claude',
+      projectPath: '/tmp/project-a'
+    });
+
+    assert.equal(sessions.length, 1);
+    assert.equal(sessions[0].id, 'session-a');
+    assert.equal(sessions[0].model, 'claude-sonnet-4');
+    assert.equal(sessions[0].source, 'acp');
+  } finally {
+    delete process.env.AXHUB_GENIE_ACP_SESSION_ROOT;
+    await fs.rm(sessionRoot, { recursive: true, force: true });
+  }
+});
+
+test('session-store GC removes only stale closed session records by default', async () => {
+  const sessionRoot = await createTempSessionRoot();
+
+  try {
+    const sessionStore = await loadSessionStore(sessionRoot);
+
+    await sessionStore.writeAcpSessionRecord({
+      provider: 'codex',
+      sessionId: 'closed-session',
+      projectPath: '/tmp/project-b',
+      lastActivity: '2025-01-01T00:00:00.000Z',
+      closedAt: '2025-01-01T00:00:00.000Z',
+      isClosed: true
+    });
+
+    await sessionStore.writeAcpSessionRecord({
+      provider: 'codex',
+      sessionId: 'open-session',
+      projectPath: '/tmp/project-b',
+      lastActivity: '2025-01-01T00:00:00.000Z',
+      isClosed: false
+    });
+
+    const gcResult = await sessionStore.gcOldAcpSessions({
+      provider: 'codex',
+      maxAgeDays: 30
+    });
+
+    assert.equal(gcResult.removed, 1);
+    assert.equal(await sessionStore.readAcpSessionRecord('codex', 'closed-session'), null);
+    assert.ok(await sessionStore.readAcpSessionRecord('codex', 'open-session'));
+  } finally {
+    delete process.env.AXHUB_GENIE_ACP_SESSION_ROOT;
+    await fs.rm(sessionRoot, { recursive: true, force: true });
+  }
+});

package/server/channels/runtime/AgentRuntimeAdapter.js

@@ -1,8 +1,5 @@
-import { queryClaudeSDK } from '../../claude-sdk.js';
-import { queryCodex } from '../../openai-codex.js';
-import { queryGemini } from '../../gemini-cli.js';
-import { queryOpencode } from '../../opencode-cli.js';
 import { CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../../shared/modelConstants.js';
+import { executeAgentPrompt } from '../../acp-runtime/index.js';
 
 function normalizeBackend(backend) {
   const normalized = String(backend || '').trim().toLowerCase();
@@ -55,69 +52,28 @@ function createWriter(callbacks) {
         return;
       }
 
-      if (payload.type === 'claude-response') {
-        const delta = payload?.data?.delta?.text;
-        if (payload?.data?.type === 'content_block_delta' && typeof delta === 'string' && delta.length > 0) {
-          callbacks.onDelta?.(delta);
+      if (payload.type === 'conversation-event' && payload.event) {
+        if (payload.event.kind === 'assistant_text_delta' && typeof payload.event.payload?.text === 'string') {
+          callbacks.onDelta?.(payload.event.payload.text);
           return;
         }
 
-        if (payload?.data?.type === 'content_block_stop') {
-          state.done = true;
-        }
-
-        return;
-      }
-
-      if (payload.type === 'codex-response') {
-        if (payload?.data?.type === 'item_delta' && typeof payload?.data?.delta === 'string' && payload.data.delta.length > 0) {
-          const itemId = payload?.data?.itemId ? String(payload.data.itemId) : null;
-          const isReasoning = !!payload?.data?.isReasoning || payload?.data?.itemType === 'reasoning';
-
-          // Feishu channel does not output model reasoning/thinking content.
-          if (isReasoning) {
-            return;
+        if (payload.event.kind === 'session_state_changed') {
+          const nextState = String(payload.event.payload?.state || '').trim().toLowerCase();
+          if (nextState === 'completed') {
+            state.done = true;
+          } else if (nextState === 'errored') {
+            state.failed = true;
+            callbacks.onError?.(new Error(payload.event.payload?.message || 'Agent runtime error'));
+          } else if (nextState === 'aborted') {
+            state.failed = true;
+            callbacks.onError?.(new Error('Agent session aborted'));
           }
-
-          if (itemId) {
-            state.codexDeltaItems.add(itemId);
-          }
-
-          callbacks.onDelta?.(payload.data.delta);
-          return;
         }
-
-        if (payload?.data?.type === 'item_done' && typeof payload?.data?.content === 'string' && payload.data.content.length > 0) {
-          const itemId = payload?.data?.itemId ? String(payload.data.itemId) : null;
-          const isReasoning = !!payload?.data?.isReasoning || payload?.data?.itemType === 'reasoning';
-          const hasDeltaStreamed = !!(itemId && state.codexDeltaItems.has(itemId));
-
-          // Feishu channel does not output model reasoning/thinking content.
-          if (isReasoning) {
-            if (itemId) {
-              state.codexDeltaItems.delete(itemId);
-            }
-            return;
-          }
-
-          if (!hasDeltaStreamed) {
-            callbacks.onDelta?.(payload.data.content);
-          }
-
-          if (itemId) {
-            state.codexDeltaItems.delete(itemId);
-          }
-        }
-
         return;
       }
 
-      if (payload.type === 'claude-complete' || payload.type === 'codex-complete') {
-        state.done = true;
-        return;
-      }
-
-      if (payload.type === 'claude-error' || payload.type === 'codex-error') {
+      if (payload.type === 'error') {
         state.failed = true;
         callbacks.onError?.(new Error(payload.error || 'Agent runtime error'));
       }
@@ -158,17 +114,12 @@ export async function runBackendSession({
     skipPermissions: true,
   };
 
-  if (resolvedBackend === 'claude') {
-    await queryClaudeSDK(message, options, writer);
-  } else if (resolvedBackend === 'codex') {
-    await queryCodex(message, options, writer);
-  } else if (resolvedBackend === 'gemini') {
-    await queryGemini(message, options, writer);
-  } else if (resolvedBackend === 'opencode') {
-    await queryOpencode(message, options, writer);
-  } else {
-    throw new Error(`Unsupported backend: ${resolvedBackend}`);
-  }
+  await executeAgentPrompt({
+    agentKey: resolvedBackend,
+    command: message,
+    options,
+    writer
+  });
 
   return {
     sessionId: writer.getState().sessionId || sessionId || null,