@axhub/genie 0.2.6 → 0.2.8

package/server/acp-runtime/index.js

@@ -0,0 +1,408 @@
+import { resolveWorkingDirectory } from '../utils/defaultWorkingDirectory.js';
+import { AcpClient } from './client.js';
+import {
+  findAcpSessionRecord,
+  touchAcpSessionRecord
+} from './session-store.js';
+
+const activeSessionClients = new Map();
+const pendingSessionClientLoads = new Map();
+const DEFAULT_ACTIVE_SESSION_IDLE_TIMEOUT_MS = parseInt(process.env.ACP_SESSION_IDLE_TIMEOUT_MS, 10) || (5 * 60 * 1000);
+
+function normalizeProvider(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function createActiveSessionKey(provider, sessionId) {
+  const normalizedProvider = normalizeProvider(provider);
+  const normalizedSessionId = String(sessionId || '').trim();
+  if (!normalizedProvider || !normalizedSessionId) {
+    return null;
+  }
+  return `${normalizedProvider}:${normalizedSessionId}`;
+}
+
+function registerActiveClient(provider, sessionId, client) {
+  const key = createActiveSessionKey(provider, sessionId);
+  if (!key) {
+    return null;
+  }
+
+  const existing = activeSessionClients.get(key);
+  if (existing?.idleTimer) {
+    clearTimeout(existing.idleTimer);
+  }
+
+  const entry = existing && existing.client === client
+    ? existing
+    : {
+        client,
+        idleTimer: null,
+        lastUsedAt: null
+      };
+
+  entry.client = client;
+  entry.lastUsedAt = Date.now();
+  entry.idleTimer = null;
+  activeSessionClients.set(key, entry);
+  return entry;
+}
+
+export function resolveDefaultModel(agentKey, requestedModel) {
+  const normalizedRequestedModel = typeof requestedModel === 'string'
+    ? requestedModel.trim()
+    : '';
+  return normalizedRequestedModel || null;
+}
+
+function unregisterActiveClient(provider, sessionId, client = null) {
+  const key = createActiveSessionKey(provider, sessionId);
+  if (!key) {
+    return null;
+  }
+
+  const entry = activeSessionClients.get(key);
+  if (!entry) {
+    return null;
+  }
+
+  if (client && entry.client !== client) {
+    return null;
+  }
+
+  if (entry.idleTimer) {
+    clearTimeout(entry.idleTimer);
+  }
+
+  activeSessionClients.delete(key);
+  return entry.client;
+}
+
+function getActiveClient(provider, sessionId) {
+  const key = createActiveSessionKey(provider, sessionId);
+  return key ? activeSessionClients.get(key)?.client || null : null;
+}
+
+async function disposeActiveClient(provider, sessionId, client = null) {
+  const resolvedClient = unregisterActiveClient(provider, sessionId, client) || client;
+  if (resolvedClient) {
+    await resolvedClient.close().catch(() => {});
+  }
+}
+
+function scheduleActiveClientCleanup(provider, sessionId, metadata = {}) {
+  if (DEFAULT_ACTIVE_SESSION_IDLE_TIMEOUT_MS <= 0) {
+    return;
+  }
+
+  const key = createActiveSessionKey(provider, sessionId);
+  const entry = key ? activeSessionClients.get(key) : null;
+  if (!entry) {
+    return;
+  }
+
+  if (entry.idleTimer) {
+    clearTimeout(entry.idleTimer);
+  }
+
+  entry.lastUsedAt = Date.now();
+  entry.idleTimer = setTimeout(() => {
+    void (async () => {
+      const activeClient = unregisterActiveClient(provider, sessionId, entry.client);
+      if (!activeClient) {
+        return;
+      }
+
+      await touchAcpSessionRecord({
+        ...metadata,
+        provider,
+        sessionId,
+        lastActivity: new Date().toISOString(),
+        isClosed: false
+      }).catch(() => {});
+
+      await activeClient.close().catch(() => {});
+    })();
+  }, DEFAULT_ACTIVE_SESSION_IDLE_TIMEOUT_MS);
+
+  entry.idleTimer.unref?.();
+}
+
+async function resolveProjectPath(options = {}) {
+  const explicitProjectPath = resolveWorkingDirectory({
+    cwd: options.cwd,
+    projectPath: options.projectPath
+  });
+
+  if (explicitProjectPath) {
+    return explicitProjectPath;
+  }
+
+  if (options.sessionId) {
+    const record = await findAcpSessionRecord(options.sessionId, options.provider || options.agentKey || null);
+    if (record?.projectPath) {
+      return record.projectPath;
+    }
+  }
+
+  return process.cwd();
+}
+
+function createClient({ normalizedAgent, writer, projectPath, options = {} }) {
+  return new AcpClient({
+    agentKey: normalizedAgent,
+    writer,
+    projectPath,
+    agentCommandOverrides: options.agentCommandOverrides,
+    model: resolveDefaultModel(normalizedAgent, options.model),
+    permissionMode: options.permissionMode || 'default'
+  });
+}
+
+async function createOrResumeClient({ normalizedAgent, options = {}, projectPath, writer }) {
+  const requestedSessionId = typeof options.sessionId === 'string' ? options.sessionId.trim() : '';
+  const activeClient = requestedSessionId ? getActiveClient(normalizedAgent, requestedSessionId) : null;
+  if (activeClient) {
+    registerActiveClient(normalizedAgent, requestedSessionId, activeClient);
+    return activeClient;
+  }
+
+  const pendingKey = requestedSessionId ? createActiveSessionKey(normalizedAgent, requestedSessionId) : null;
+  if (pendingKey && pendingSessionClientLoads.has(pendingKey)) {
+    return pendingSessionClientLoads.get(pendingKey);
+  }
+
+  const clientPromise = (async () => {
+    const client = createClient({
+      normalizedAgent,
+      writer,
+      projectPath,
+      options
+    });
+
+    try {
+      await client.start();
+
+      if (requestedSessionId) {
+        try {
+          await client.loadSession(requestedSessionId);
+        } catch (error) {
+          console.warn(`[ACP:${normalizedAgent}] Unable to resume session ${requestedSessionId}: ${error.message}`);
+          await client.createSession();
+          client.emitSystemNotice(`Unable to resume session ${requestedSessionId}; started a new session instead.`);
+        }
+      } else {
+        await client.createSession();
+      }
+
+      registerActiveClient(normalizedAgent, client.sessionId, client);
+      writer?.setSessionId?.(client.sessionId);
+      return client;
+    } catch (error) {
+      await client.close().catch(() => {});
+      throw error;
+    }
+  })();
+
+  if (pendingKey) {
+    pendingSessionClientLoads.set(pendingKey, clientPromise);
+  }
+
+  try {
+    return await clientPromise;
+  } finally {
+    if (pendingKey) {
+      pendingSessionClientLoads.delete(pendingKey);
+    }
+  }
+}
+
+export async function executeAgentPrompt({ agentKey, command, options = {}, writer }) {
+  const normalizedAgent = normalizeProvider(agentKey || options.provider);
+  const projectPath = await resolveProjectPath({
+    ...options,
+    agentKey: normalizedAgent,
+    provider: normalizedAgent
+  });
+  const resolvedModel = resolveDefaultModel(normalizedAgent, options.model);
+  const agentCommand = options.agentCommand || null;
+  let sessionRecord = null;
+  let client = null;
+
+  try {
+    client = await createOrResumeClient({
+      normalizedAgent,
+      options,
+      projectPath,
+      writer
+    });
+
+    const effectiveProjectPath = client.projectPath || projectPath;
+    const response = await client.runExclusive(async () => {
+      registerActiveClient(normalizedAgent, client.sessionId, client);
+      await client.configureForTurn({
+        writer,
+        permissionMode: options.permissionMode || 'default',
+        model: resolvedModel
+      });
+      writer?.setSessionId?.(client.sessionId);
+
+      sessionRecord = await touchAcpSessionRecord({
+        provider: normalizedAgent,
+        sessionId: client.sessionId,
+        projectPath: effectiveProjectPath,
+        agentCommand,
+        model: resolvedModel,
+        lastActivity: new Date().toISOString(),
+        lastPromptAt: new Date().toISOString(),
+        isClosed: false
+      });
+
+      return client.sendPrompt(command, {
+        images: options.images || [],
+        resourceLinks: options.resourceLinks || [],
+        clientRequestId: options.clientRequestId || null
+      });
+    });
+
+    await touchAcpSessionRecord({
+      provider: normalizedAgent,
+      sessionId: client.sessionId,
+      projectPath: effectiveProjectPath,
+      agentCommand,
+      model: resolvedModel,
+      lastActivity: new Date().toISOString(),
+      lastPromptAt: new Date().toISOString(),
+      isClosed: false
+    });
+
+    scheduleActiveClientCleanup(normalizedAgent, client.sessionId, {
+      projectPath: effectiveProjectPath,
+      agentCommand,
+      model: resolvedModel
+    });
+
+    return {
+      sessionId: client.sessionId,
+      provider: normalizedAgent,
+      runtime: 'acp',
+      stopReason: response?.stopReason || null,
+      source: sessionRecord?.source || 'acp'
+    };
+  } catch (error) {
+    if (client?.sessionId && !client.hasReportedPromptFatalError) {
+      writer?.send?.({
+        type: 'error',
+        provider: normalizedAgent,
+        sessionId: client.sessionId,
+        runtime: 'acp',
+        error: error.message
+      });
+    }
+
+    if (client?.sessionId) {
+      await disposeActiveClient(normalizedAgent, client.sessionId, client);
+    } else if (client) {
+      await client.close().catch(() => {});
+    }
+
+    throw error;
+  }
+}
+
+export async function abortAgentSession(agentKey, sessionId) {
+  const normalizedAgent = normalizeProvider(agentKey);
+  const client = getActiveClient(normalizedAgent, sessionId);
+
+  if (!client) {
+    return false;
+  }
+
+  const cancelled = await client.cancel(sessionId);
+  if (cancelled) {
+    await touchAcpSessionRecord({
+      provider: normalizedAgent,
+      sessionId,
+      lastActivity: new Date().toISOString()
+    }).catch(() => {});
+  }
+  return cancelled;
+}
+
+export async function setAgentSessionMode(agentKey, sessionId, modeId, { writer = null } = {}) {
+  const normalizedAgent = normalizeProvider(agentKey);
+  const normalizedSessionId = String(sessionId || '').trim();
+  const normalizedModeId = String(modeId || '').trim();
+
+  if (!normalizedAgent || !normalizedSessionId || !normalizedModeId) {
+    return false;
+  }
+
+  let client = getActiveClient(normalizedAgent, normalizedSessionId);
+  if (!client) {
+    const projectPath = await resolveProjectPath({
+      provider: normalizedAgent,
+      sessionId: normalizedSessionId
+    });
+
+    client = await createOrResumeClient({
+      normalizedAgent,
+      options: {
+        sessionId: normalizedSessionId
+      },
+      projectPath,
+      writer
+    });
+  }
+
+  const changed = await client.runExclusive(async () => {
+    registerActiveClient(normalizedAgent, normalizedSessionId, client);
+    if (writer) {
+      client.attachWriter(writer);
+      writer.setSessionId?.(normalizedSessionId);
+    }
+    return client.setMode(normalizedModeId);
+  });
+
+  if (changed) {
+    await touchAcpSessionRecord({
+      provider: normalizedAgent,
+      sessionId: normalizedSessionId,
+      projectPath: client.projectPath || null,
+      model: client.model || null,
+      lastActivity: new Date().toISOString(),
+      isClosed: false
+    }).catch(() => {});
+
+    scheduleActiveClientCleanup(normalizedAgent, normalizedSessionId, {
+      projectPath: client.projectPath || null,
+      model: client.model || null
+    });
+  }
+
+  return changed;
+}
+
+export function isAgentSessionActive(agentKey, sessionId) {
+  const key = createActiveSessionKey(agentKey, sessionId);
+  return key ? activeSessionClients.has(key) : false;
+}
+
+export function getActiveAgentSessions(agentKey = null) {
+  const normalizedAgent = agentKey ? normalizeProvider(agentKey) : null;
+  const sessions = [];
+
+  for (const key of activeSessionClients.keys()) {
+    const [provider, sessionId] = key.split(':');
+    if (normalizedAgent && provider !== normalizedAgent) {
+      continue;
+    }
+    sessions.push(sessionId);
+  }
+
+  return sessions;
+}
+
+export function resolveAgentPermission(requestId, decision = {}) {
+  return AcpClient.resolvePermissionRequest(requestId, decision);
+}

package/server/acp-runtime/registry.js

@@ -0,0 +1,45 @@
+const ACP_ADAPTER_PACKAGE_RANGES = {
+  claude: '^0.24.2',
+  codex: '^0.10.0'
+};
+
+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'
+};
+
+const AGENT_ALIASES = {
+  openai: 'codex'
+};
+
+export function normalizeAgentName(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return AGENT_ALIASES[normalized] || normalized;
+}
+
+export function mergeAgentRegistry(overrides = {}) {
+  const merged = { ...AGENT_REGISTRY };
+
+  Object.entries(overrides || {}).forEach(([agentName, command]) => {
+    const normalizedAgent = normalizeAgentName(agentName);
+    const normalizedCommand = typeof command === 'string' ? command.trim() : '';
+    if (!normalizedAgent || !normalizedCommand) {
+      return;
+    }
+    merged[normalizedAgent] = normalizedCommand;
+  });
+
+  return merged;
+}
+
+export function resolveAgentCommand(agentKey, overrides = {}) {
+  const normalizedAgent = normalizeAgentName(agentKey);
+  const registry = mergeAgentRegistry(overrides);
+  return registry[normalizedAgent] || registry[AGENT_ALIASES[normalizedAgent] || normalizedAgent] || '';
+}
+
+export function listBuiltInAgents(overrides = {}) {
+  return Object.keys(mergeAgentRegistry(overrides)).sort();
+}

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

@@ -0,0 +1,254 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+function parsePositiveInteger(value, fallback) {
+  const parsed = parseInt(value, 10);
+  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) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function normalizeSessionId(value) {
+  const normalized = String(value || '').trim();
+  return normalized || null;
+}
+
+function getProviderDir(provider) {
+  return path.join(ACP_SESSION_ROOT, normalizeProvider(provider));
+}
+
+function getSessionFilePath(provider, sessionId) {
+  return path.join(getProviderDir(provider), `${encodeURIComponent(sessionId)}.json`);
+}
+
+function sortSessionsByActivity(sessions = []) {
+  return sessions.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 ensureProviderDir(provider) {
+  await fs.mkdir(getProviderDir(provider), { recursive: true });
+}
+
+async function listProviderSessionFiles(provider) {
+  try {
+    const entries = await fs.readdir(getProviderDir(provider), { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+      .map((entry) => path.join(getProviderDir(provider), entry.name));
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+}
+
+async function readJsonFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return null;
+    }
+    throw error;
+  }
+}
+
+function createSessionSummary(record) {
+  if (!record || typeof record !== 'object') {
+    return null;
+  }
+
+  return {
+    id: record.sessionId,
+    sessionId: record.sessionId,
+    provider: record.provider,
+    source: 'acp',
+    runtime: 'acp',
+    projectPath: record.projectPath || null,
+    cwd: record.projectPath || null,
+    title: record.title || record.sessionId,
+    summary: record.summary || null,
+    model: record.model || null,
+    createdAt: record.createdAt || null,
+    updatedAt: record.updatedAt || null,
+    lastActivity: record.lastActivity || record.updatedAt || record.createdAt || null,
+    lastPromptAt: record.lastPromptAt || null,
+    closedAt: record.closedAt || null,
+    isClosed: Boolean(record.isClosed)
+  };
+}
+
+function getSessionActivityTime(record) {
+  return new Date(
+    record?.closedAt
+    || record?.lastActivity
+    || record?.updatedAt
+    || record?.createdAt
+    || 0
+  ).getTime();
+}
+
+export async function readAcpSessionRecord(provider, sessionId) {
+  const normalizedProvider = normalizeProvider(provider);
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedProvider || !normalizedSessionId) {
+    return null;
+  }
+
+  const record = await readJsonFile(getSessionFilePath(normalizedProvider, normalizedSessionId));
+  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');
+  }
+
+  const now = new Date().toISOString();
+  const existing = await readAcpSessionRecord(normalizedProvider, normalizedSessionId);
+  const nextRecord = {
+    source: 'acp',
+    runtime: 'acp',
+    provider: normalizedProvider,
+    sessionId: normalizedSessionId,
+    createdAt: existing?.createdAt || record.createdAt || now,
+    updatedAt: now,
+    lastActivity: record.lastActivity || now,
+    projectPath: record.projectPath || existing?.projectPath || null,
+    agentCommand: record.agentCommand || existing?.agentCommand || null,
+    model: record.model || existing?.model || null,
+    summary: record.summary || existing?.summary || null,
+    title: record.title || existing?.title || null,
+    lastPromptAt: record.lastPromptAt || existing?.lastPromptAt || null,
+    closedAt: record.closedAt || existing?.closedAt || null,
+    isClosed: record.isClosed ?? existing?.isClosed ?? false
+  };
+
+  await ensureProviderDir(normalizedProvider);
+  const filePath = getSessionFilePath(normalizedProvider, normalizedSessionId);
+  await fs.writeFile(filePath, `${JSON.stringify(nextRecord, null, 2)}\n`, 'utf8');
+
+  return nextRecord;
+}
+
+export async function touchAcpSessionRecord(record) {
+  return writeAcpSessionRecord(record);
+}
+
+export async function closeAcpSessionRecord(provider, sessionId, updates = {}) {
+  const now = new Date().toISOString();
+  return writeAcpSessionRecord({
+    ...updates,
+    provider,
+    sessionId,
+    isClosed: true,
+    closedAt: updates.closedAt || now,
+    lastActivity: updates.lastActivity || now
+  });
+}
+
+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 cutoffTime = Date.now() - (normalizedMaxAgeDays * 24 * 60 * 60 * 1000);
+  let removed = 0;
+
+  for (const currentProvider of providers) {
+    if (!currentProvider) {
+      continue;
+    }
+
+    const filePaths = await listProviderSessionFiles(currentProvider);
+    for (const filePath of filePaths) {
+      const record = await readJsonFile(filePath);
+      if (!record || typeof record !== 'object') {
+        continue;
+      }
+
+      if (!includeOpen && !record.isClosed) {
+        continue;
+      }
+
+      const activityTime = getSessionActivityTime(record);
+      if (!Number.isFinite(activityTime) || activityTime >= cutoffTime) {
+        continue;
+      }
+
+      await fs.rm(filePath, { force: true });
+      removed += 1;
+    }
+  }
+
+  return { removed };
+}
+
+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 filePaths = await listProviderSessionFiles(currentProvider);
+    for (const filePath of filePaths) {
+      const record = await readJsonFile(filePath);
+      const summary = createSessionSummary(record);
+      if (!summary) {
+        continue;
+      }
+
+      if (projectPath && summary.projectPath !== projectPath) {
+        continue;
+      }
+
+      sessions.push(summary);
+    }
+  }
+
+  return sortSessionsByActivity(sessions);
+}
+
+export async function findAcpSessionRecord(sessionId, provider = null) {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedSessionId) {
+    return null;
+  }
+
+  if (provider) {
+    return readAcpSessionRecord(provider, normalizedSessionId);
+  }
+
+  const providers = ['claude', 'codex', 'gemini', 'opencode'];
+  for (const currentProvider of providers) {
+    const record = await readAcpSessionRecord(currentProvider, normalizedSessionId);
+    if (record) {
+      return record;
+    }
+  }
+
+  return null;
+}