@axhub/genie 0.2.10 → 0.2.12

package/server/session-core/providerDiscovery.js

@@ -1,18 +1,12 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
 import { SUPPORTED_PROVIDERS } from '../../shared/conversationEvents.js';
 import {
-  detectProviderInstallationStatus,
-  checkClaudeCredentials,  checkCodexCredentials,
-  checkGeminiCredentials,
-  checkOpencodeCredentials
+  detectProviderInstallationStatus
 } from '../routes/cli-auth.js';
 import { listOpencodeModels } from '../opencode-cli.js';
 import { spawnCommand } from '../utils/spawnCommand.js';
 import {
   CLAUDE_MODELS,
-  CODEX_MODELS,  GEMINI_MODELS,
+  GEMINI_MODELS,
   OPENCODE_MODELS
 } from '../../shared/modelConstants.js';
 
@@ -21,6 +15,9 @@ const PROVIDER_CAPABILITIES = {
   gemini: { modes: ['default', 'acceptEdits', 'bypassPermissions'], thinking: false, resume: true },
   opencode: { modes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'], thinking: false, resume: true }
 };
+const MODEL_DISCOVERY_CACHE_TTL_MS = 30 * 60 * 1000;
+const modelDiscoveryCache = new Map();
+const modelDiscoveryInFlight = new Map();
 
 function runCommand(command, args = [], options = {}) {
   return new Promise((resolve) => {
@@ -160,64 +157,92 @@ async function discoverClaudeModels() {
 }
 
 async function discoverCodexModels() {
-  let currentModel = null;
-  try {
-    const configPath = path.join(os.homedir(), '.codex', 'config.toml');
-    const content = await fs.readFile(configPath, 'utf8');
-    const match = content.match(/^model\s*=\s*["']([^"']+)["']/m);
-    if (match) currentModel = match[1];
-  } catch {
-  }
-  return { models: mapModelOptions(CODEX_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: currentModel || null };
+  return { models: [], source: 'acp-only', error: null, currentModel: null };
 }
 
 async function discoverGeminiModels() {
   return { models: mapModelOptions(GEMINI_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: null };
 }
 
-const AUTH_CHECKERS = {
-  claude: checkClaudeCredentials,  codex: checkCodexCredentials,
-  gemini: checkGeminiCredentials,
-  opencode: checkOpencodeCredentials
-};
-
 const MODEL_DISCOVERY = {
   claude: discoverClaudeModels,  codex: discoverCodexModels,
   gemini: discoverGeminiModels,
   opencode: discoverOpenCodeModels
 };
 
+function createModelDiscoveryCacheKey(provider, projectPath) {
+  const normalizedProvider = String(provider || '').trim().toLowerCase();
+  const normalizedProjectPath = String(projectPath || '').trim();
+  return `${normalizedProvider}:${normalizedProjectPath || 'global'}`;
+}
+
+function cloneJsonValue(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  return JSON.parse(JSON.stringify(value));
+}
+
+async function discoverProviderModels(provider, projectPath, options = {}) {
+  const cacheKey = createModelDiscoveryCacheKey(provider, projectPath);
+  const now = Date.now();
+  const force = options.force === true || String(options.force || '').toLowerCase() === 'true';
+
+  if (!force) {
+    const cached = modelDiscoveryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+      return cloneJsonValue(cached.result);
+    }
+
+    if (modelDiscoveryInFlight.has(cacheKey)) {
+      return modelDiscoveryInFlight.get(cacheKey);
+    }
+  }
+
+  const discoveryPromise = MODEL_DISCOVERY[provider](projectPath)
+    .then((result) => {
+      const normalizedResult = result && typeof result === 'object'
+        ? result
+        : { models: [], source: 'unavailable', error: 'Model discovery failed' };
+
+      modelDiscoveryCache.set(cacheKey, {
+        result: cloneJsonValue(normalizedResult),
+        expiresAt: Date.now() + MODEL_DISCOVERY_CACHE_TTL_MS
+      });
+
+      return normalizedResult;
+    })
+    .finally(() => {
+      modelDiscoveryInFlight.delete(cacheKey);
+    });
+
+  modelDiscoveryInFlight.set(cacheKey, discoveryPromise);
+  return discoveryPromise;
+}
+
 export async function discoverProvider(provider, options = {}) {
   const normalizedProvider = String(provider || '').toLowerCase();
   if (!SUPPORTED_PROVIDERS.includes(normalizedProvider)) {
     throw new Error(`Unsupported provider: ${provider}`);
   }
 
-  const [installation, auth] = await Promise.all([
-    detectProviderInstallationStatus(normalizedProvider),
-    AUTH_CHECKERS[normalizedProvider]().catch((error) => ({ authenticated: false, email: null, error: error.message }))
-  ]);
+  const installation = await detectProviderInstallationStatus(normalizedProvider);
 
   const modelsResult = installation.installed
-    ? await MODEL_DISCOVERY[normalizedProvider](options.projectPath)
+    ? await discoverProviderModels(normalizedProvider, options.projectPath, options)
     : { models: [], source: 'unavailable', error: installation.reason || 'Provider not installed' };
 
-  let availability = 'unavailable';
-  if (installation.installed && auth.authenticated) availability = 'available';
-  else if (installation.installed && !auth.authenticated) availability = 'unauthenticated';
-
   return {
     provider: normalizedProvider,
-    availability,
+    availability: installation.installed ? 'available' : 'unavailable',
     installed: !!installation.installed,
-    authenticated: !!auth.authenticated,
-    auth,
     installation,
     capabilities: PROVIDER_CAPABILITIES[normalizedProvider],
     models: modelsResult.models,
     modelSource: modelsResult.source,
     discoveryError: modelsResult.error || null,
-    currentModel: modelsResult.currentModel || modelsResult.models?.[0]?.id || null
+    currentModel: modelsResult.currentModel || null
   };
 }
 
@@ -227,8 +252,6 @@ export async function discoverAllProviders(options = {}) {
       provider,
       availability: 'probe_failed',
       installed: false,
-      authenticated: false,
-      auth: { authenticated: false, email: null, error: error.message },
       installation: null,
       capabilities: PROVIDER_CAPABILITIES[provider],
       models: [],
@@ -238,3 +261,8 @@ export async function discoverAllProviders(options = {}) {
     }))
   ));
 }
+
+export function resetProviderDiscoveryCachesForTests() {
+  modelDiscoveryCache.clear();
+  modelDiscoveryInFlight.clear();
+}

package/server/session-core/runRegistry.js

@@ -0,0 +1,244 @@
+import crypto from 'node:crypto';
+
+export const RUN_ACTIVE_STATUSES = new Set([
+  'queued',
+  'running',
+  'awaiting_approval',
+  'awaiting_input',
+]);
+
+export const RUN_TERMINAL_STATUSES = new Set([
+  'succeeded',
+  'failed',
+  'canceled',
+]);
+
+const RUN_STATUSES = new Set([
+  ...RUN_ACTIVE_STATUSES,
+  ...RUN_TERMINAL_STATUSES,
+]);
+
+const DEFAULT_TERMINAL_TTL_MS = 30 * 60 * 1000;
+const SUPPORTED_PROVIDERS = new Set(['claude', 'codex', 'gemini', 'opencode']);
+
+function normalizeProvider(provider) {
+  const normalized = String(provider || '').trim().toLowerCase();
+  return SUPPORTED_PROVIDERS.has(normalized) ? normalized : 'claude';
+}
+
+function normalizeNullableString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function createRunId() {
+  if (typeof crypto.randomUUID === 'function') {
+    return `run_${crypto.randomUUID()}`;
+  }
+  return `run_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function clone(value) {
+  return value && typeof value === 'object'
+    ? structuredClone(value)
+    : value;
+}
+
+export function createRunRegistry({
+  now = () => new Date().toISOString(),
+  ttlMs = DEFAULT_TERMINAL_TTL_MS,
+} = {}) {
+  const runs = new Map();
+  const eventsByRunId = new Map();
+  const terminalExpiresAtByRunId = new Map();
+  const subscribersByRunId = new Map();
+
+  const currentTimestamp = () => now();
+  const currentTimeMs = () => Date.parse(currentTimestamp());
+
+  const pruneExpiredRun = (runId) => {
+    const expiresAt = terminalExpiresAtByRunId.get(runId);
+    if (!Number.isFinite(expiresAt)) {
+      return false;
+    }
+
+    if (currentTimeMs() <= expiresAt) {
+      return false;
+    }
+
+    runs.delete(runId);
+    eventsByRunId.delete(runId);
+    terminalExpiresAtByRunId.delete(runId);
+    subscribersByRunId.delete(runId);
+    return true;
+  };
+
+  const notifyRunEventSubscribers = (event) => {
+    const subscribers = subscribersByRunId.get(event.runId);
+    if (!subscribers || subscribers.size === 0) {
+      return;
+    }
+
+    subscribers.forEach((subscriber) => {
+      try {
+        subscriber(clone(event));
+      } catch (error) {
+        console.warn('[WARN] Run event subscriber failed:', error?.message || error);
+      }
+    });
+  };
+
+  const getMutableRun = (runId) => {
+    const normalizedRunId = normalizeNullableString(runId);
+    if (!normalizedRunId || pruneExpiredRun(normalizedRunId)) {
+      return null;
+    }
+    return runs.get(normalizedRunId) || null;
+  };
+
+  const rememberTerminalExpiry = (run) => {
+    if (RUN_TERMINAL_STATUSES.has(run.status)) {
+      terminalExpiresAtByRunId.set(run.runId, currentTimeMs() + ttlMs);
+    }
+  };
+
+  return {
+    createRun({ provider, sessionId = null, clientRequestId = null } = {}) {
+      const timestamp = currentTimestamp();
+      const run = {
+        runId: createRunId(),
+        provider: normalizeProvider(provider),
+        sessionId: normalizeNullableString(sessionId),
+        clientRequestId: normalizeNullableString(clientRequestId),
+        status: 'queued',
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        lastEventSeq: 0,
+      };
+      runs.set(run.runId, run);
+      eventsByRunId.set(run.runId, []);
+      return clone(run);
+    },
+
+    getRun(runId) {
+      const run = getMutableRun(runId);
+      return run ? clone(run) : null;
+    },
+
+    updateRun(runId, patch = {}) {
+      const run = getMutableRun(runId);
+      if (!run) {
+        return null;
+      }
+
+      if (patch.sessionId !== undefined) {
+        run.sessionId = normalizeNullableString(patch.sessionId);
+      }
+
+      if (patch.clientRequestId !== undefined) {
+        run.clientRequestId = normalizeNullableString(patch.clientRequestId);
+      }
+
+      if (patch.status !== undefined) {
+        const nextStatus = String(patch.status || '').trim();
+        if (RUN_STATUSES.has(nextStatus) && !RUN_TERMINAL_STATUSES.has(run.status)) {
+          run.status = nextStatus;
+          rememberTerminalExpiry(run);
+        }
+      }
+
+      run.updatedAt = currentTimestamp();
+      return clone(run);
+    },
+
+    appendRunEvent(runId, eventInput = {}) {
+      const run = getMutableRun(runId);
+      if (!run) {
+        return null;
+      }
+
+      const nextSeq = run.lastEventSeq + 1;
+      const event = {
+        runId: run.runId,
+        seq: nextSeq,
+        type: eventInput.type || 'conversation-event',
+        provider: String(eventInput.provider || run.provider || '').trim() || run.provider,
+        sessionId: normalizeNullableString(eventInput.sessionId) || run.sessionId,
+        clientRequestId: normalizeNullableString(eventInput.clientRequestId) || run.clientRequestId,
+        event: clone(eventInput.event ?? null),
+        createdAt: currentTimestamp(),
+      };
+
+      run.lastEventSeq = nextSeq;
+      run.updatedAt = event.createdAt;
+      if (event.sessionId && !run.sessionId) {
+        run.sessionId = event.sessionId;
+      }
+      if (event.clientRequestId && !run.clientRequestId) {
+        run.clientRequestId = event.clientRequestId;
+      }
+
+      eventsByRunId.get(run.runId).push(event);
+      notifyRunEventSubscribers(event);
+      return clone(event);
+    },
+
+    listRunEvents(runId, { after = 0 } = {}) {
+      const run = getMutableRun(runId);
+      if (!run) {
+        return [];
+      }
+
+      const minSeq = Number.isFinite(Number(after)) ? Number(after) : 0;
+      return (eventsByRunId.get(run.runId) || [])
+        .filter((event) => event.seq > minSeq)
+        .map(clone);
+    },
+
+    listSessionRuns({ provider, sessionId, status = null } = {}) {
+      const normalizedProvider = normalizeProvider(provider);
+      const normalizedSessionId = normalizeNullableString(sessionId);
+      if (!normalizedSessionId) {
+        return [];
+      }
+
+      return Array.from(runs.values())
+        .filter((run) => {
+          if (pruneExpiredRun(run.runId)) {
+            return false;
+          }
+          if (run.provider !== normalizedProvider || run.sessionId !== normalizedSessionId) {
+            return false;
+          }
+          if (status === 'active') {
+            return RUN_ACTIVE_STATUSES.has(run.status);
+          }
+          return true;
+        })
+        .sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt))
+        .map(clone);
+    },
+
+    subscribeRunEvents(runId, callback) {
+      const run = getMutableRun(runId);
+      if (!run || typeof callback !== 'function') {
+        return () => {};
+      }
+
+      if (!subscribersByRunId.has(run.runId)) {
+        subscribersByRunId.set(run.runId, new Set());
+      }
+
+      const subscribers = subscribersByRunId.get(run.runId);
+      subscribers.add(callback);
+
+      return () => {
+        subscribers.delete(callback);
+        if (subscribers.size === 0) {
+          subscribersByRunId.delete(run.runId);
+        }
+      };
+    },
+  };
+}
+
+export const runRegistry = createRunRegistry();

package/server/session-core/runtimeState.js

@@ -15,6 +15,7 @@ export const AGENT_RUNTIME_PHASES = {
   QUEUED: 'queued',
   STREAMING: 'streaming',
   AWAITING_APPROVAL: 'awaiting_approval',
+  AWAITING_INPUT: 'awaiting_input',
   COMPLETED: 'completed',
   ABORTED: 'aborted',
   ERRORED: 'errored'
@@ -23,7 +24,8 @@ export const AGENT_RUNTIME_PHASES = {
 const ACTIVE_PHASES = new Set([
   AGENT_RUNTIME_PHASES.QUEUED,
   AGENT_RUNTIME_PHASES.STREAMING,
-  AGENT_RUNTIME_PHASES.AWAITING_APPROVAL
+  AGENT_RUNTIME_PHASES.AWAITING_APPROVAL,
+  AGENT_RUNTIME_PHASES.AWAITING_INPUT
 ]);
 const TERMINAL_PHASES = new Set([
   AGENT_RUNTIME_PHASES.COMPLETED,
@@ -188,11 +190,21 @@ function inferPhaseFromEvents(events = []) {
       continue;
     }
 
+    if (event.kind === CONVERSATION_EVENT_KINDS.ELICITATION_REQUEST) {
+      inferredPhase = AGENT_RUNTIME_PHASES.AWAITING_INPUT;
+      continue;
+    }
+
     if (event.kind === CONVERSATION_EVENT_KINDS.APPROVAL_RESOLVED) {
       inferredPhase = AGENT_RUNTIME_PHASES.STREAMING;
       continue;
     }
 
+    if (event.kind === CONVERSATION_EVENT_KINDS.ELICITATION_RESOLVED) {
+      inferredPhase = AGENT_RUNTIME_PHASES.STREAMING;
+      continue;
+    }
+
     if (
       event.kind === CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_START ||
       event.kind === CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_DELTA ||
@@ -252,6 +264,46 @@ function inferPendingApproval(events = []) {
   return pendingRequests.size > 0;
 }
 
+function inferPendingElicitation(events = []) {
+  const pendingRequests = new Set();
+
+  for (const event of events) {
+    if (!event || typeof event !== 'object') {
+      continue;
+    }
+
+    const requestId = normalizeNonEmptyString(event.payload?.requestId) || normalizeNonEmptyString(event.extensions?.requestId);
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.ELICITATION_REQUEST) {
+      if (requestId) {
+        pendingRequests.add(requestId);
+      }
+      continue;
+    }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.ELICITATION_RESOLVED) {
+      if (requestId) {
+        pendingRequests.delete(requestId);
+      }
+      continue;
+    }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED) {
+      const sessionState = normalizePhase(event.payload?.state);
+      if (
+        sessionState === AGENT_RUNTIME_PHASES.IDLE ||
+        sessionState === AGENT_RUNTIME_PHASES.COMPLETED ||
+        sessionState === AGENT_RUNTIME_PHASES.ABORTED ||
+        sessionState === AGENT_RUNTIME_PHASES.ERRORED
+      ) {
+        pendingRequests.clear();
+      }
+    }
+  }
+
+  return pendingRequests.size > 0;
+}
+
 function getLatestEventTimestamp(events = []) {
   const latestEvent = [...events].reverse().find((event) => normalizeNonEmptyString(event?.timestamp));
   return latestEvent?.timestamp || null;
@@ -294,7 +346,17 @@ export async function buildSessionRuntimeSnapshot(provider, sessionId, options =
   }
 
   const recentEvents = Array.isArray(options.recentEvents) ? options.recentEvents : [];
-  const { events: persistedEvents, context, error } = await loadProviderEvents(normalizedProvider, normalizedSessionId);
+  let persistedEvents = [];
+  let context = null;
+  let error = null;
+
+  if (!options.skipPersistedEvents) {
+    const loaded = await loadProviderEvents(normalizedProvider, normalizedSessionId);
+    persistedEvents = loaded.events;
+    context = loaded.context;
+    error = loaded.error;
+  }
+
   const mergedEvents = mergeConversationEventHistories(
     persistedEvents,
     recentEvents.filter((event) => event?.provider === normalizedProvider && event?.sessionId === normalizedSessionId)
@@ -308,11 +370,14 @@ export async function buildSessionRuntimeSnapshot(provider, sessionId, options =
 
   let phase = inferPhaseFromEvents(mergedEvents);
   const hasPendingApproval = active ? inferPendingApproval(mergedEvents) : false;
+  const hasPendingElicitation = active ? inferPendingElicitation(mergedEvents) : false;
 
   if (TERMINAL_PHASES.has(phase)) {
     // Keep terminal phase as-is.
   } else if (hasPendingApproval) {
     phase = AGENT_RUNTIME_PHASES.AWAITING_APPROVAL;
+  } else if (hasPendingElicitation) {
+    phase = AGENT_RUNTIME_PHASES.AWAITING_INPUT;
   } else if (active) {
     phase = ACTIVE_PHASES.has(phase) ? phase : AGENT_RUNTIME_PHASES.STREAMING;
   } else {
@@ -346,6 +411,10 @@ export function subscribeToSessionRuntimeStateChanges(listener) {
 }
 
 export async function publishSessionRuntimeStateChanges(events = []) {
+  if (sessionRuntimeListeners.size === 0) {
+    return;
+  }
+
   const groupedRecentEvents = new Map();
 
   events.forEach((event) => {
@@ -363,7 +432,10 @@ export async function publishSessionRuntimeStateChanges(events = []) {
 
   await Promise.all(Array.from(groupedRecentEvents.entries()).map(async ([subscriptionKey, recentEvents]) => {
     const [provider, sessionId] = subscriptionKey.split(':');
-    const snapshot = await buildSessionRuntimeSnapshot(provider, sessionId, { recentEvents });
+    const snapshot = await buildSessionRuntimeSnapshot(provider, sessionId, {
+      recentEvents,
+      skipPersistedEvents: true
+    });
     if (!snapshot) {
       return;
     }