@axhub/genie 0.2.9 → 0.2.10

package/server/routes/settings.js

@@ -2,40 +2,50 @@ import express from 'express';
 import { apiKeysDb, credentialsDb } from '../database/db.js';
 
 const router = express.Router();
-
-// ===============================
-// API Keys Management
-// ===============================
-
-// Get all API keys for the authenticated user
-router.get('/api-keys', async (req, res) => {
+const DISALLOWED_CREDENTIAL_TYPES = new Set(['github_token']);
+
+function parseNumericId(rawValue) {
+  const parsed = Number.parseInt(String(rawValue || ''), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function sanitizeApiKeyRecord(record) {
+  const visiblePrefix = String(record?.api_key || '').slice(0, 10);
+  return {
+    ...record,
+    api_key: visiblePrefix ? `${visiblePrefix}...` : ''
+  };
+}
+
+function badRequest(res, error) {
+  return res.status(400).json({ error });
+}
+
+function notFound(res, error) {
+  return res.status(404).json({ error });
+}
+
+router.get('/api-keys', (req, res) => {
   try {
-    const apiKeys = apiKeysDb.getApiKeys(req.user.id);
-    // Don't send the full API key in the list for security
-    const sanitizedKeys = apiKeys.map(key => ({
-      ...key,
-      api_key: key.api_key.substring(0, 10) + '...'
-    }));
-    res.json({ apiKeys: sanitizedKeys });
+    const apiKeys = apiKeysDb.getApiKeys(req.user.id).map(sanitizeApiKeyRecord);
+    res.json({ apiKeys });
   } catch (error) {
     console.error('Error fetching API keys:', error);
     res.status(500).json({ error: 'Failed to fetch API keys' });
   }
 });
 
-// Create a new API key
-router.post('/api-keys', async (req, res) => {
-  try {
-    const { keyName } = req.body;
-
-    if (!keyName || !keyName.trim()) {
-      return res.status(400).json({ error: 'Key name is required' });
-    }
+router.post('/api-keys', (req, res) => {
+  const keyName = String(req.body?.keyName || '').trim();
+  if (!keyName) {
+    return badRequest(res, 'Key name is required');
+  }
 
-    const result = apiKeysDb.createApiKey(req.user.id, keyName.trim());
+  try {
+    const apiKey = apiKeysDb.createApiKey(req.user.id, keyName);
     res.json({
       success: true,
-      apiKey: result
+      apiKey
     });
   } catch (error) {
     console.error('Error creating API key:', error);
@@ -43,56 +53,54 @@ router.post('/api-keys', async (req, res) => {
   }
 });
 
-// Delete an API key
-router.delete('/api-keys/:keyId', async (req, res) => {
-  try {
-    const { keyId } = req.params;
-    const success = apiKeysDb.deleteApiKey(req.user.id, parseInt(keyId));
+router.delete('/api-keys/:keyId', (req, res) => {
+  const keyId = parseNumericId(req.params.keyId);
+  if (keyId === null) {
+    return badRequest(res, 'Invalid API key id');
+  }
 
-    if (success) {
-      res.json({ success: true });
-    } else {
-      res.status(404).json({ error: 'API key not found' });
+  try {
+    const removed = apiKeysDb.deleteApiKey(req.user.id, keyId);
+    if (!removed) {
+      return notFound(res, 'API key not found');
     }
+
+    res.json({ success: true });
   } catch (error) {
     console.error('Error deleting API key:', error);
     res.status(500).json({ error: 'Failed to delete API key' });
   }
 });
 
-// Toggle API key active status
-router.patch('/api-keys/:keyId/toggle', async (req, res) => {
-  try {
-    const { keyId } = req.params;
-    const { isActive } = req.body;
+router.patch('/api-keys/:keyId/toggle', (req, res) => {
+  const keyId = parseNumericId(req.params.keyId);
+  const isActive = req.body?.isActive;
 
-    if (typeof isActive !== 'boolean') {
-      return res.status(400).json({ error: 'isActive must be a boolean' });
-    }
+  if (keyId === null) {
+    return badRequest(res, 'Invalid API key id');
+  }
 
-    const success = apiKeysDb.toggleApiKey(req.user.id, parseInt(keyId), isActive);
+  if (typeof isActive !== 'boolean') {
+    return badRequest(res, 'isActive must be a boolean');
+  }
 
-    if (success) {
-      res.json({ success: true });
-    } else {
-      res.status(404).json({ error: 'API key not found' });
+  try {
+    const updated = apiKeysDb.toggleApiKey(req.user.id, keyId, isActive);
+    if (!updated) {
+      return notFound(res, 'API key not found');
     }
+
+    res.json({ success: true });
   } catch (error) {
     console.error('Error toggling API key:', error);
     res.status(500).json({ error: 'Failed to toggle API key' });
   }
 });
 
-// ===============================
-// Generic Credentials Management
-// ===============================
-
-// Get all credentials for the authenticated user (optionally filtered by type)
-router.get('/credentials', async (req, res) => {
+router.get('/credentials', (req, res) => {
   try {
-    const { type } = req.query;
-    const credentials = credentialsDb.getCredentials(req.user.id, type || null);
-    // Don't send the actual credential values for security
+    const credentialType = typeof req.query.type === 'string' ? req.query.type.trim() : null;
+    const credentials = credentialsDb.getCredentials(req.user.id, credentialType || null);
     res.json({ credentials });
   } catch (error) {
     console.error('Error fetching credentials:', error);
@@ -100,38 +108,40 @@ router.get('/credentials', async (req, res) => {
   }
 });
 
-// Create a new credential
-router.post('/credentials', async (req, res) => {
-  try {
-    const { credentialName, credentialType, credentialValue, description } = req.body;
+router.post('/credentials', (req, res) => {
+  const credentialName = String(req.body?.credentialName || '').trim();
+  const credentialType = String(req.body?.credentialType || '').trim();
+  const credentialValue = String(req.body?.credentialValue || '').trim();
+  const description = String(req.body?.description || '').trim();
 
-    if (!credentialName || !credentialName.trim()) {
-      return res.status(400).json({ error: 'Credential name is required' });
-    }
+  if (!credentialName) {
+    return badRequest(res, 'Credential name is required');
+  }
 
-    if (!credentialType || !credentialType.trim()) {
-      return res.status(400).json({ error: 'Credential type is required' });
-    }
+  if (!credentialType) {
+    return badRequest(res, 'Credential type is required');
+  }
 
-    if (!credentialValue || !credentialValue.trim()) {
-      return res.status(400).json({ error: 'Credential value is required' });
-    }
+  if (!credentialValue) {
+    return badRequest(res, 'Credential value is required');
+  }
 
-    if (credentialType.trim() === 'github_token') {
-      return res.status(400).json({ error: 'GitHub tokens are no longer supported.' });
-    }
+  if (DISALLOWED_CREDENTIAL_TYPES.has(credentialType.toLowerCase())) {
+    return badRequest(res, 'GitHub tokens are no longer supported.');
+  }
 
-    const result = credentialsDb.createCredential(
+  try {
+    const credential = credentialsDb.createCredential(
       req.user.id,
-      credentialName.trim(),
-      credentialType.trim(),
-      credentialValue.trim(),
-      description?.trim() || null
+      credentialName,
+      credentialType,
+      credentialValue,
+      description || null
     );
 
     res.json({
       success: true,
-      credential: result
+      credential
     });
   } catch (error) {
     console.error('Error creating credential:', error);
@@ -139,40 +149,44 @@ router.post('/credentials', async (req, res) => {
   }
 });
 
-// Delete a credential
-router.delete('/credentials/:credentialId', async (req, res) => {
-  try {
-    const { credentialId } = req.params;
-    const success = credentialsDb.deleteCredential(req.user.id, parseInt(credentialId));
+router.delete('/credentials/:credentialId', (req, res) => {
+  const credentialId = parseNumericId(req.params.credentialId);
+  if (credentialId === null) {
+    return badRequest(res, 'Invalid credential id');
+  }
 
-    if (success) {
-      res.json({ success: true });
-    } else {
-      res.status(404).json({ error: 'Credential not found' });
+  try {
+    const removed = credentialsDb.deleteCredential(req.user.id, credentialId);
+    if (!removed) {
+      return notFound(res, 'Credential not found');
     }
+
+    res.json({ success: true });
   } catch (error) {
     console.error('Error deleting credential:', error);
     res.status(500).json({ error: 'Failed to delete credential' });
   }
 });
 
-// Toggle credential active status
-router.patch('/credentials/:credentialId/toggle', async (req, res) => {
-  try {
-    const { credentialId } = req.params;
-    const { isActive } = req.body;
+router.patch('/credentials/:credentialId/toggle', (req, res) => {
+  const credentialId = parseNumericId(req.params.credentialId);
+  const isActive = req.body?.isActive;
 
-    if (typeof isActive !== 'boolean') {
-      return res.status(400).json({ error: 'isActive must be a boolean' });
-    }
+  if (credentialId === null) {
+    return badRequest(res, 'Invalid credential id');
+  }
 
-    const success = credentialsDb.toggleCredential(req.user.id, parseInt(credentialId), isActive);
+  if (typeof isActive !== 'boolean') {
+    return badRequest(res, 'isActive must be a boolean');
+  }
 
-    if (success) {
-      res.json({ success: true });
-    } else {
-      res.status(404).json({ error: 'Credential not found' });
+  try {
+    const updated = credentialsDb.toggleCredential(req.user.id, credentialId, isActive);
+    if (!updated) {
+      return notFound(res, 'Credential not found');
     }
+
+    res.json({ success: true });
   } catch (error) {
     console.error('Error toggling credential:', error);
     res.status(500).json({ error: 'Failed to toggle credential' });

package/server/session-core/eventStore.js

@@ -9,8 +9,18 @@ import {
   isConversationEvent
 } from '../../shared/conversationEvents.js';
 
-const MIRRORED_EVENT_STORE_ROOT = path.join(os.homedir(), '.axhub-genie', 'session-events');
+function getMirroredEventStoreRoot() {
+  if (process.env.AXHUB_GENIE_SESSION_EVENTS_ROOT) {
+    return path.resolve(process.env.AXHUB_GENIE_SESSION_EVENTS_ROOT);
+  }
+
+  return path.join(os.homedir(), '.axhub-genie', 'session-events');
+}
 const PERSISTED_EVENT_KINDS = new Set([
+  CONVERSATION_EVENT_KINDS.USER_MESSAGE,
+  CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_START,
+  CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_DELTA,
+  CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_END,
   CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED,
   CONVERSATION_EVENT_KINDS.ERROR,
   CONVERSATION_EVENT_KINDS.APPROVAL_REQUEST,
@@ -18,12 +28,15 @@ const PERSISTED_EVENT_KINDS = new Set([
   CONVERSATION_EVENT_KINDS.SYSTEM_NOTICE,
   CONVERSATION_EVENT_KINDS.MODE_UPDATE,
   CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE,
+  CONVERSATION_EVENT_KINDS.CONFIG_OPTION_UPDATE,
+  CONVERSATION_EVENT_KINDS.SESSION_INFO_UPDATE,
+  CONVERSATION_EVENT_KINDS.USAGE_UPDATE,
   CONVERSATION_EVENT_KINDS.PLAN_UPDATE,
   CONVERSATION_EVENT_KINDS.ARTIFACT_CREATED
 ]);
 
 function getSessionEventFilePath(provider, sessionId) {
-  return path.join(MIRRORED_EVENT_STORE_ROOT, String(provider || 'claude'), `${sessionId}.jsonl`);
+  return path.join(getMirroredEventStoreRoot(), String(provider || 'claude'), `${sessionId}.jsonl`);
 }
 
 function normalizePersistedEvents(events = []) {

package/server/session-core/providerAdapters.js

@@ -14,12 +14,26 @@ import {
   findAcpSessionRecord,
   listAcpSessions
 } from '../acp-runtime/session-store.js';
+import { mergeSessionLists } from './sessionListMerge.js';
 
 async function flattenLegacyMessages(result) {
   if (Array.isArray(result)) return result;
   return Array.isArray(result?.messages) ? result.messages : [];
 }
 
+function hasReplayableTranscriptContent(events = []) {
+  return (Array.isArray(events) ? events : []).some((event) => (
+    event?.kind === 'user_message' ||
+    event?.kind === 'assistant_text_delta' ||
+    event?.kind === 'assistant_content_block' ||
+    event?.kind === 'reasoning_delta' ||
+    event?.kind === 'tool_call_start' ||
+    event?.kind === 'tool_result' ||
+    event?.kind === 'plan_update' ||
+    event?.kind === 'system_notice'
+  ));
+}
+
 async function normalizeLegacyLoadResult(result, provider, sessionId) {
   const messages = await flattenLegacyMessages(result);
   const legacyEvents = normalizeLegacyHistoryEntries(messages, provider, sessionId);
@@ -49,34 +63,17 @@ function createEventLoadResult(events = [], source = 'acp') {
   };
 }
 
-function mergeSessionLists(legacySessions = [], acpSessions = []) {
-  const merged = new Map();
-
-  legacySessions.forEach((session) => {
-    if (session?.id) {
-      merged.set(session.id, session);
-    }
-  });
-
-  acpSessions.forEach((session) => {
-    if (session?.id) {
-      merged.set(session.id, session);
-    }
-  });
-
-  return Array.from(merged.values()).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 loadAcpEvents(provider, sessionId, nativeHistoryLoader = null) {
   const record = await findAcpSessionRecord(sessionId, provider);
   if (!record) {
     return null;
   }
 
+  const mirroredEvents = await readMirroredConversationEvents(provider, sessionId);
+  if (hasReplayableTranscriptContent(mirroredEvents)) {
+    return createEventLoadResult(mirroredEvents, 'acp');
+  }
+
   if (typeof nativeHistoryLoader === 'function') {
     try {
       const nativeResult = await nativeHistoryLoader();
@@ -93,8 +90,7 @@ async function loadAcpEvents(provider, sessionId, nativeHistoryLoader = null) {
     }
   }
 
-  const events = await readMirroredConversationEvents(provider, sessionId);
-  return createEventLoadResult(events, 'acp');
+  return createEventLoadResult(mirroredEvents, 'acp');
 }
 
 const PROVIDER_ADAPTERS = {
@@ -106,7 +102,8 @@ const PROVIDER_ADAPTERS = {
       ]);
       return mergeSessionLists(
         (result?.sessions || []).map((session) => ({ ...session, provider: 'claude', source: 'legacy' })),
-        acpSessions
+        acpSessions,
+        { fallbackProvider: 'claude' }
       );
     },
     async loadEvents({ projectName, sessionId, limit = null, offset = 0 }) {
@@ -131,7 +128,8 @@ const PROVIDER_ADAPTERS = {
       ]);
       return mergeSessionLists(
         sessions.map((session) => ({ ...session, provider: 'codex', source: 'legacy' })),
-        acpSessions
+        acpSessions,
+        { fallbackProvider: 'codex' }
       );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
@@ -156,7 +154,8 @@ const PROVIDER_ADAPTERS = {
       ]);
       return mergeSessionLists(
         sessions.map((session) => ({ ...session, provider: 'gemini', source: 'legacy' })),
-        acpSessions
+        acpSessions,
+        { fallbackProvider: 'gemini' }
       );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
@@ -181,7 +180,8 @@ const PROVIDER_ADAPTERS = {
       ]);
       return mergeSessionLists(
         sessions.map((session) => ({ ...session, provider: 'opencode', source: 'legacy' })),
-        acpSessions
+        acpSessions,
+        { fallbackProvider: 'opencode' }
       );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {

package/server/session-core/sessionListMerge.js

@@ -0,0 +1,47 @@
+function getSessionActivityTime(session) {
+  return new Date(
+    session?.lastActivity
+    || session?.updatedAt
+    || session?.updated_at
+    || session?.createdAt
+    || session?.created_at
+    || 0
+  ).getTime();
+}
+
+function buildSessionMergeKey(session, fallbackProvider = '') {
+  const provider = String(session?.provider || session?.__provider || fallbackProvider || '').trim().toLowerCase();
+  const sessionId = String(session?.id || session?.sessionId || '').trim();
+
+  if (!sessionId) {
+    return null;
+  }
+
+  return `${provider}:${sessionId}`;
+}
+
+export function mergeSessionLists(legacySessions = [], acpSessions = [], options = {}) {
+  const { fallbackProvider = '' } = options;
+  const merged = new Map();
+
+  for (const session of legacySessions) {
+    const mergeKey = buildSessionMergeKey(session, fallbackProvider);
+    if (!mergeKey) {
+      continue;
+    }
+
+    merged.set(mergeKey, { ...session });
+  }
+
+  for (const session of acpSessions) {
+    const mergeKey = buildSessionMergeKey(session, fallbackProvider);
+    if (!mergeKey) {
+      continue;
+    }
+
+    const existing = merged.get(mergeKey) || {};
+    merged.set(mergeKey, { ...existing, ...session });
+  }
+
+  return Array.from(merged.values()).sort((left, right) => getSessionActivityTime(right) - getSessionActivityTime(left));
+}

package/shared/conversationEvents.js

@@ -27,6 +27,9 @@ export const CONVERSATION_EVENT_KINDS = {
   PLAN_UPDATE: 'plan_update',
   MODE_UPDATE: 'mode_update',
   AVAILABLE_COMMANDS_UPDATE: 'available_commands_update',
+  CONFIG_OPTION_UPDATE: 'config_option_update',
+  SESSION_INFO_UPDATE: 'session_info_update',
+  USAGE_UPDATE: 'usage_update',
   APPROVAL_REQUEST: 'approval_request',
   APPROVAL_RESOLVED: 'approval_resolved',
   ARTIFACT_CREATED: 'artifact_created',
@@ -417,6 +420,71 @@ function normalizeAcpAvailableCommands(value) {
     }));
 }
 
+function normalizeAcpConfigOptions(value) {
+  const configOptions = Array.isArray(value?.configOptions)
+    ? value.configOptions
+    : Array.isArray(value)
+      ? value
+      : [];
+
+  return configOptions
+    .filter((option) => option && typeof option === 'object' && String(option.key || '').trim())
+    .map((option) => ({
+      key: String(option.key).trim(),
+      description: typeof option.description === 'string' ? option.description : '',
+      value: cloneJsonValue(option.value),
+      schema: option.schema && typeof option.schema === 'object' ? cloneJsonValue(option.schema) : null
+    }));
+}
+
+function normalizeAcpSessionInfo(value) {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+
+  const title = Object.prototype.hasOwnProperty.call(value, 'title')
+    ? (value.title == null ? null : String(value.title))
+    : undefined;
+  const updatedAt = Object.prototype.hasOwnProperty.call(value, 'updatedAt')
+    ? (value.updatedAt == null ? null : String(value.updatedAt))
+    : undefined;
+
+  if (title === undefined && updatedAt === undefined) {
+    return null;
+  }
+
+  return {
+    ...(title !== undefined ? { title } : {}),
+    ...(updatedAt !== undefined ? { updatedAt } : {})
+  };
+}
+
+function normalizeAcpTokenUsage(value) {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+
+  const used = Number(value.used);
+  const total = Number(value.size);
+  if (!Number.isFinite(used) || used < 0 || !Number.isFinite(total) || total < 0) {
+    return null;
+  }
+
+  const safeUsed = Math.round(used);
+  const safeTotal = Math.round(total);
+  const percentage = safeTotal > 0
+    ? Math.min(100, Math.max(0, Math.round((safeUsed / safeTotal) * 100)))
+    : 0;
+
+  return {
+    used: safeUsed,
+    total: safeTotal,
+    percentage,
+    remaining: Math.max(0, safeTotal - safeUsed),
+    cost: value.cost && typeof value.cost === 'object' ? cloneJsonValue(value.cost) : null
+  };
+}
+
 function mergeToolCallSnapshot(existingSnapshot = null, payload = {}) {
   const nextSnapshot = existingSnapshot && typeof existingSnapshot === 'object'
     ? { ...existingSnapshot }
@@ -993,6 +1061,9 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
     case CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED:
     case CONVERSATION_EVENT_KINDS.MODE_UPDATE:
     case CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE:
+    case CONVERSATION_EVENT_KINDS.CONFIG_OPTION_UPDATE:
+    case CONVERSATION_EVENT_KINDS.SESSION_INFO_UPDATE:
+    case CONVERSATION_EVENT_KINDS.USAGE_UPDATE:
     case CONVERSATION_EVENT_KINDS.ARTIFACT_CREATED:
     default:
       break;
@@ -1016,7 +1087,10 @@ export function conversationEventsToTimelineMessages(events = [], sessionProvide
 export function extractAcpSessionMetadataFromConversationEvents(events = []) {
   const metadata = {
     modeState: null,
-    availableCommands: []
+    availableCommands: [],
+    configOptions: [],
+    sessionInfo: null,
+    tokenUsage: null
   };
 
   for (const event of Array.isArray(events) ? events : []) {
@@ -1041,6 +1115,27 @@ export function extractAcpSessionMetadataFromConversationEvents(events = []) {
     if (event.kind === CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE) {
       metadata.availableCommands = normalizeAcpAvailableCommands(event.payload || {});
     }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.CONFIG_OPTION_UPDATE) {
+      metadata.configOptions = normalizeAcpConfigOptions(event.payload || {});
+    }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.SESSION_INFO_UPDATE) {
+      const nextSessionInfo = normalizeAcpSessionInfo(event.payload || {});
+      if (nextSessionInfo) {
+        metadata.sessionInfo = {
+          ...(metadata.sessionInfo && typeof metadata.sessionInfo === 'object' ? metadata.sessionInfo : {}),
+          ...nextSessionInfo
+        };
+      }
+    }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.USAGE_UPDATE) {
+      const nextTokenUsage = normalizeAcpTokenUsage(event.payload || {});
+      if (nextTokenUsage) {
+        metadata.tokenUsage = nextTokenUsage;
+      }
+    }
   }
 
   return metadata;