@axhub/genie 0.1.8 → 0.2.0

package/server/session-core/eventStore.js

@@ -0,0 +1,139 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+import {
+  CONVERSATION_EVENT_KINDS,
+  isConversationEvent
+} from '../../shared/conversationEvents.js';
+
+const MIRRORED_EVENT_STORE_ROOT = path.join(os.homedir(), '.axhub-genie', 'session-events');
+const PERSISTED_EVENT_KINDS = new Set([
+  CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED,
+  CONVERSATION_EVENT_KINDS.ERROR,
+  CONVERSATION_EVENT_KINDS.APPROVAL_REQUEST,
+  CONVERSATION_EVENT_KINDS.APPROVAL_RESOLVED,
+  CONVERSATION_EVENT_KINDS.SYSTEM_NOTICE
+]);
+
+function getSessionEventFilePath(provider, sessionId) {
+  return path.join(MIRRORED_EVENT_STORE_ROOT, String(provider || 'claude'), `${sessionId}.jsonl`);
+}
+
+function normalizePersistedEvents(events = []) {
+  return events.filter((event) => (
+    isConversationEvent(event) &&
+    event.sessionId &&
+    PERSISTED_EVENT_KINDS.has(event.kind)
+  ));
+}
+
+function sortObjectKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortObjectKeys);
+  }
+
+  if (value && typeof value === 'object') {
+    return Object.keys(value)
+      .sort()
+      .reduce((accumulator, key) => {
+        accumulator[key] = sortObjectKeys(value[key]);
+        return accumulator;
+      }, {});
+  }
+
+  return value;
+}
+
+function createEventSignature(event) {
+  return JSON.stringify(sortObjectKeys({
+    kind: event.kind,
+    provider: event.provider,
+    sessionId: event.sessionId,
+    timestamp: event.timestamp,
+    payload: event.payload || {},
+    extensions: event.extensions || {},
+    rawRef: event.rawRef || null
+  }));
+}
+
+export async function appendMirroredConversationEvents(events = []) {
+  const normalizedEvents = normalizePersistedEvents(events);
+  if (normalizedEvents.length === 0) {
+    return;
+  }
+
+  const eventsByFile = new Map();
+  normalizedEvents.forEach((event) => {
+    const filePath = getSessionEventFilePath(event.provider, event.sessionId);
+    if (!eventsByFile.has(filePath)) {
+      eventsByFile.set(filePath, []);
+    }
+    eventsByFile.get(filePath).push(event);
+  });
+
+  await Promise.all(Array.from(eventsByFile.entries()).map(async ([filePath, fileEvents]) => {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const serialized = fileEvents.map((event) => JSON.stringify(event)).join('\n');
+    await fs.appendFile(filePath, `${serialized}\n`, 'utf8');
+  }));
+}
+
+export async function readMirroredConversationEvents(provider, sessionId) {
+  if (!provider || !sessionId) {
+    return [];
+  }
+
+  const filePath = getSessionEventFilePath(provider, sessionId);
+
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    return content
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter(isConversationEvent);
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+}
+
+export function mergeConversationEventHistories(primaryEvents = [], mirroredEvents = []) {
+  const merged = [];
+  const seenSignatures = new Set();
+
+  [...primaryEvents, ...mirroredEvents].forEach((event) => {
+    if (!isConversationEvent(event)) {
+      return;
+    }
+
+    const signature = createEventSignature(event);
+    if (seenSignatures.has(signature)) {
+      return;
+    }
+
+    seenSignatures.add(signature);
+    merged.push(event);
+  });
+
+  merged.sort((left, right) => {
+    const leftTime = new Date(left.timestamp || 0).getTime();
+    const rightTime = new Date(right.timestamp || 0).getTime();
+    if (leftTime !== rightTime) {
+      return leftTime - rightTime;
+    }
+    return 0;
+  });
+
+  return merged;
+}

package/server/session-core/providerAdapters.js

@@ -0,0 +1,84 @@
+import { normalizeLegacyHistoryEntries, SUPPORTED_PROVIDERS } from '../../shared/conversationEvents.js';
+import { mergeConversationEventHistories, readMirroredConversationEvents } from './eventStore.js';
+import {
+  getSessionMessages,
+  getCodexSessionMessages,
+  getOpencodeSessionMessages,
+  getGeminiSessionMessages,
+  getSessions,
+  getCodexSessions,
+  getOpencodeSessions,
+  getGeminiSessions
+} from '../projects.js';
+
+async function flattenLegacyMessages(result) {
+  if (Array.isArray(result)) return result;
+  return Array.isArray(result?.messages) ? result.messages : [];
+}
+
+async function normalizeLegacyLoadResult(result, provider, sessionId) {
+  const messages = await flattenLegacyMessages(result);
+  const legacyEvents = normalizeLegacyHistoryEntries(messages, provider, sessionId);
+  const mirroredEvents = await readMirroredConversationEvents(provider, sessionId);
+  const events = mergeConversationEventHistories(legacyEvents, mirroredEvents);
+
+  if (Array.isArray(result)) {
+    return events;
+  }
+
+  return {
+    ...result,
+    events
+  };
+}
+
+const PROVIDER_ADAPTERS = {
+  claude: {
+    async listSessions({ projectName, limit = 50, offset = 0 }) {
+      const result = await getSessions(projectName, limit, offset);
+      return (result?.sessions || []).map((session) => ({ ...session, provider: 'claude' }));
+    },
+    async loadEvents({ projectName, sessionId, limit = null, offset = 0 }) {
+      const rawMessages = await getSessionMessages(projectName, sessionId, limit, offset);
+      return normalizeLegacyLoadResult(rawMessages, 'claude', sessionId);
+    }
+  },
+  codex: {
+    async listSessions({ projectPath, limit = 50 }) {
+      const sessions = await getCodexSessions(projectPath, { limit });
+      return sessions.map((session) => ({ ...session, provider: 'codex' }));
+    },
+    async loadEvents({ sessionId, limit = null, offset = 0 }) {
+      const rawMessages = await getCodexSessionMessages(sessionId, limit, offset);
+      return normalizeLegacyLoadResult(rawMessages, 'codex', sessionId);
+    }
+  },
+  gemini: {
+    async listSessions({ projectPath, limit = 50 }) {
+      const sessions = await getGeminiSessions(projectPath, { limit });
+      return sessions.map((session) => ({ ...session, provider: 'gemini' }));
+    },
+    async loadEvents({ sessionId, limit = null, offset = 0 }) {
+      const rawMessages = await getGeminiSessionMessages(sessionId, limit, offset);
+      return normalizeLegacyLoadResult(rawMessages, 'gemini', sessionId);
+    }
+  },
+  opencode: {
+    async listSessions({ projectPath, limit = 50 }) {
+      const sessions = await getOpencodeSessions(projectPath, { limit });
+      return sessions.map((session) => ({ ...session, provider: 'opencode' }));
+    },
+    async loadEvents({ sessionId, limit = null, offset = 0 }) {
+      const rawMessages = await getOpencodeSessionMessages(sessionId, limit, offset);
+      return normalizeLegacyLoadResult(rawMessages, 'opencode', sessionId);
+    }
+  }
+};
+
+export function getProviderAdapter(provider) {
+  const normalizedProvider = String(provider || '').toLowerCase();
+  if (!SUPPORTED_PROVIDERS.includes(normalizedProvider)) {
+    throw new Error(`Unsupported provider: ${provider}`);
+  }
+  return PROVIDER_ADAPTERS[normalizedProvider];
+}

package/server/session-core/providerDiscovery.js

@@ -0,0 +1,235 @@
+import { spawn } from 'child_process';
+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
+} from '../routes/cli-auth.js';
+import { listOpencodeModels } from '../opencode-cli.js';
+import {
+  CLAUDE_MODELS,
+  CODEX_MODELS,  GEMINI_MODELS,
+  OPENCODE_MODELS
+} from '../../shared/modelConstants.js';
+
+const PROVIDER_CAPABILITIES = {
+  claude: { modes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'], thinking: true, resume: true },  codex: { modes: ['default', 'acceptEdits', 'bypassPermissions'], thinking: true, resume: true },
+  gemini: { modes: ['default', 'acceptEdits', 'bypassPermissions'], thinking: false, resume: true },
+  opencode: { modes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'], thinking: false, resume: true }
+};
+
+function runCommand(command, args = [], options = {}) {
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    let child;
+
+    const finalize = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+
+    try {
+      child = spawn(command, args, {
+        cwd: options.cwd || process.cwd(),
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, ...(options.env || {}) }
+      });
+    } catch (error) {
+      finalize({ ok: false, stdout: '', stderr: error.message, error });
+      return;
+    }
+
+    const timeoutId = setTimeout(() => {
+      try {
+        child.kill('SIGTERM');
+      } catch {}
+      finalize({ ok: false, stdout, stderr: `${stderr}\nCommand timeout`.trim() });
+    }, options.timeoutMs || 8000);
+
+    child.stdout.on('data', (data) => { stdout += data.toString(); });
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+    child.on('close', (code) => {
+      clearTimeout(timeoutId);
+      finalize({ ok: code === 0, stdout, stderr, exitCode: code });
+    });
+    child.on('error', (error) => {
+      clearTimeout(timeoutId);
+      finalize({ ok: false, stdout, stderr: error.message, error });
+    });
+  });
+}
+
+function mapModelOptions(options = [], source = 'fallback') {
+  return options.map(({ value, label }) => ({ id: value, displayName: label || value, source, availability: 'available' }));
+}
+
+function parseOpencodeModels(stdout = '') {
+  return String(stdout)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .map((line) => line.replace(/^[*-]\s*/, ''))
+    .filter(Boolean)
+    .filter((line) => line.includes('/'))
+    .filter((line) => !line.endsWith(':'))
+    .map((line) => line.split(/\s+/)[0])
+    .filter((line, index, items) => items.indexOf(line) === index)
+    .map((value) => ({
+      id: value,
+      displayName: value,
+      source: 'runtime',
+      availability: 'available'
+    }));
+}
+
+function derivePreferredOpencodeModel(discovery = {}) {
+  const models = Array.isArray(discovery?.models) ? discovery.models : [];
+  if (models.length === 0) {
+    return null;
+  }
+
+  const defaults = discovery?.defaults && typeof discovery.defaults === 'object'
+    ? discovery.defaults
+    : {};
+  const connectedProviders = Array.isArray(discovery?.connected)
+    ? discovery.connected.filter(Boolean).map((value) => String(value).trim())
+    : [];
+
+  const candidateProviders = [
+    'opencode',
+    ...connectedProviders.filter((providerId) => providerId !== 'opencode')
+  ];
+
+  for (const providerId of candidateProviders) {
+    const defaultModelId = typeof defaults[providerId] === 'string'
+      ? defaults[providerId].trim()
+      : '';
+    if (!defaultModelId) {
+      continue;
+    }
+
+    const candidate = `${providerId}/${defaultModelId}`;
+    if (models.includes(candidate)) {
+      return candidate;
+    }
+  }
+
+  const firstOpencodeModel = models.find((modelId) => String(modelId).startsWith('opencode/'));
+  if (firstOpencodeModel) {
+    return firstOpencodeModel;
+  }
+
+  return models[0] || null;
+}
+
+async function discoverOpenCodeModels(projectPath) {
+  if (projectPath) {
+    try {
+      const discovery = await listOpencodeModels({ projectPath, cwd: projectPath });
+      if (Array.isArray(discovery?.models) && discovery.models.length > 0) {
+        return {
+          models: discovery.models.map((value) => ({ id: value, displayName: value, source: 'runtime', availability: 'available' })),
+          source: 'runtime',
+          error: null,
+          currentModel: derivePreferredOpencodeModel(discovery)
+        };
+      }
+    } catch {
+    }
+  }
+
+  const result = await runCommand('opencode', ['models'], { cwd: projectPath || process.cwd(), timeoutMs: 12000 });
+  const models = parseOpencodeModels(result.stdout);
+  if (models.length > 0) return { models, source: 'runtime', error: null };
+  return { models: mapModelOptions(OPENCODE_MODELS.OPTIONS), source: 'fallback', error: result.stderr || null };
+}
+
+async function discoverClaudeModels() {
+  return { models: mapModelOptions(CLAUDE_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: process.env.CLAUDE_MODEL || CLAUDE_MODELS.DEFAULT };
+}
+
+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 || CODEX_MODELS.DEFAULT };
+}
+
+async function discoverGeminiModels() {
+  return { models: mapModelOptions(GEMINI_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: GEMINI_MODELS.DEFAULT };
+}
+
+const AUTH_CHECKERS = {
+  claude: checkClaudeCredentials,  codex: checkCodexCredentials,
+  gemini: checkGeminiCredentials,
+  opencode: checkOpencodeCredentials
+};
+
+const MODEL_DISCOVERY = {
+  claude: discoverClaudeModels,  codex: discoverCodexModels,
+  gemini: discoverGeminiModels,
+  opencode: discoverOpenCodeModels
+};
+
+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 modelsResult = installation.installed
+    ? await MODEL_DISCOVERY[normalizedProvider](options.projectPath)
+    : { 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,
+    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
+  };
+}
+
+export async function discoverAllProviders(options = {}) {
+  return Promise.all(SUPPORTED_PROVIDERS.map((provider) =>
+    discoverProvider(provider, options).catch((error) => ({
+      provider,
+      availability: 'probe_failed',
+      installed: false,
+      authenticated: false,
+      auth: { authenticated: false, email: null, error: error.message },
+      installation: null,
+      capabilities: PROVIDER_CAPABILITIES[provider],
+      models: [],
+      modelSource: 'unavailable',
+      discoveryError: error.message,
+      currentModel: null
+    }))
+  ));
+}