@axhub/genie 0.1.8 → 0.1.9

package/server/channels/store/ChannelStore.js

@@ -1,6 +1,4 @@
-import crypto from 'crypto';
-
-import { db } from '../../database/db.js';
+import { channelDb } from '../../database/db.js';
 
 const DEFAULT_CONFIGS = {
   lark: {
@@ -52,21 +50,32 @@ function getDefaultConfig(platform) {
   return { ...(DEFAULT_CONFIGS[normalizePlatform(platform)] || DEFAULT_CONFIGS.lark) };
 }
 
-function parseConfig(value, platform) {
-  const defaults = getDefaultConfig(platform);
-  if (!value) {
-    return defaults;
-  }
+function mapAllowedUser(entry) {
+  if (!entry) return null;
+  return {
+    id: entry.id,
+    platformType: entry.platform_type,
+    userId: entry.user_id,
+    displayName: entry.display_name,
+    note: entry.note,
+    isActive: entry.is_active,
+    createdAt: entry.created_at,
+    updatedAt: entry.updated_at,
+  };
+}
 
-  try {
-    const parsed = JSON.parse(value);
-    return {
-      ...defaults,
-      ...(parsed || {}),
-    };
-  } catch {
-    return defaults;
-  }
+function mapChannelSession(entry) {
+  if (!entry) return null;
+  return {
+    id: entry.id,
+    platformType: entry.platform_type,
+    userId: entry.user_id,
+    chatId: entry.chat_id,
+    backend: entry.backend,
+    providerSessionId: entry.provider_session_id,
+    projectPath: entry.project_path,
+    updatedAt: entry.updated_at,
+  };
 }
 
 export class ChannelStore {
@@ -79,14 +88,14 @@ export class ChannelStore {
   }
 
   getPluginConfig(pluginId = 'lark_default') {
-    const row = db.prepare('SELECT * FROM channel_plugins WHERE id = ?').get(pluginId);
+    const row = channelDb.getPlugin(pluginId);
     const platform = resolvePlatformByPluginId(pluginId);
 
     if (!row) {
       return {
         id: pluginId,
         type: platform,
-        enabled: 0,
+        enabled: false,
         status: 'stopped',
         config: getDefaultConfig(platform),
       };
@@ -95,9 +104,12 @@ export class ChannelStore {
     return {
       id: row.id,
       type: row.type || platform,
-      enabled: row.enabled,
+      enabled: !!row.enabled,
       status: row.status,
-      config: parseConfig(row.config_json, row.type || platform),
+      config: {
+        ...getDefaultConfig(row.type || platform),
+        ...(row.config || {}),
+      },
       updatedAt: row.updated_at,
     };
   }
@@ -105,30 +117,18 @@ export class ChannelStore {
   upsertPluginConfig(pluginId = 'lark_default', patch = {}) {
     const existing = this.getPluginConfig(pluginId);
     const type = resolvePlatformByPluginId(pluginId);
-    const nextConfig = {
-      ...existing.config,
-      ...patch,
-    };
 
-    const updatedAt = now();
-
-    db.prepare(`
-      INSERT INTO channel_plugins (id, type, enabled, status, config_json, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        type = excluded.type,
-        enabled = excluded.enabled,
-        status = excluded.status,
-        config_json = excluded.config_json,
-        updated_at = excluded.updated_at
-    `).run(
-      pluginId,
+    channelDb.upsertPlugin({
+      id: pluginId,
       type,
-      existing.enabled || 0,
-      existing.status || 'stopped',
-      JSON.stringify(nextConfig),
-      updatedAt
-    );
+      enabled: !!existing.enabled,
+      status: existing.status || 'stopped',
+      config: {
+        ...existing.config,
+        ...patch,
+      },
+      updated_at: now(),
+    });
 
     return this.getPluginConfig(pluginId);
   }
@@ -136,35 +136,21 @@ export class ChannelStore {
   updatePluginRuntimeStatus(pluginId = 'lark_default', enabled, status) {
     const existing = this.getPluginConfig(pluginId);
     const type = resolvePlatformByPluginId(pluginId);
-    const updatedAt = now();
-
-    db.prepare(`
-      INSERT INTO channel_plugins (id, type, enabled, status, config_json, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        enabled = excluded.enabled,
-        status = excluded.status,
-        updated_at = excluded.updated_at
-    `).run(
-      pluginId,
+
+    channelDb.upsertPlugin({
+      id: pluginId,
       type,
-      enabled ? 1 : 0,
+      enabled: !!enabled,
       status,
-      JSON.stringify(existing.config),
-      updatedAt
-    );
+      config: existing.config,
+      updated_at: now(),
+    });
 
     return this.getPluginConfig(pluginId);
   }
 
   listAllowedUsers(platform = 'lark') {
-    const normalizedPlatform = normalizePlatform(platform);
-    return db.prepare(`
-      SELECT id, platform_type AS platformType, user_id AS userId, display_name AS displayName, note, is_active AS isActive, created_at AS createdAt, updated_at AS updatedAt
-      FROM channel_allowed_users
-      WHERE platform_type = ?
-      ORDER BY created_at DESC
-    `).all(normalizedPlatform);
+    return channelDb.listAllowedUsers(normalizePlatform(platform)).map(mapAllowedUser);
   }
 
   addAllowedUser(platform = 'lark', { userId, displayName = null, note = null }) {
@@ -174,63 +160,43 @@ export class ChannelStore {
       throw new Error('userId is required');
     }
 
-    const current = now();
-
-    db.prepare(`
-      INSERT INTO channel_allowed_users (platform_type, user_id, display_name, note, is_active, created_at, updated_at)
-      VALUES (?, ?, ?, ?, 1, ?, ?)
-    `).run(normalizedPlatform, trimmedUserId, displayName ? String(displayName).trim() : null, note ? String(note).trim() : null, current, current);
-
-    return db.prepare(`
-      SELECT id, platform_type AS platformType, user_id AS userId, display_name AS displayName, note, is_active AS isActive, created_at AS createdAt, updated_at AS updatedAt
-      FROM channel_allowed_users
-      WHERE platform_type = ? AND user_id = ?
-    `).get(normalizedPlatform, trimmedUserId);
+    return mapAllowedUser(channelDb.addAllowedUser(normalizedPlatform, {
+      userId: trimmedUserId,
+      displayName: displayName ? String(displayName).trim() : null,
+      note: note ? String(note).trim() : null,
+    }));
   }
 
   removeAllowedUser(platform = 'lark', id) {
-    const normalizedPlatform = normalizePlatform(platform);
-    const result = db.prepare('DELETE FROM channel_allowed_users WHERE platform_type = ? AND id = ?').run(normalizedPlatform, id);
-    return result.changes > 0;
+    return channelDb.removeAllowedUser(normalizePlatform(platform), id);
   }
 
   toggleAllowedUser(platform = 'lark', id, isActive) {
-    const normalizedPlatform = normalizePlatform(platform);
-    const result = db.prepare('UPDATE channel_allowed_users SET is_active = ?, updated_at = ? WHERE platform_type = ? AND id = ?').run(isActive ? 1 : 0, now(), normalizedPlatform, id);
-    return result.changes > 0;
+    return channelDb.toggleAllowedUser(normalizePlatform(platform), id, isActive);
   }
 
   isAllowedUser(platform = 'lark', userId) {
-    const normalizedPlatform = normalizePlatform(platform);
     if (!userId) return false;
-    const row = db.prepare('SELECT id FROM channel_allowed_users WHERE platform_type = ? AND user_id = ? AND is_active = 1').get(normalizedPlatform, String(userId));
-    return !!row;
+    return channelDb.isAllowedUser(normalizePlatform(platform), String(userId));
   }
 
   getChannelSession({ platform = 'lark', userId, chatId, backend }) {
-    const normalizedPlatform = normalizePlatform(platform);
-    return db.prepare(`
-      SELECT id, platform_type AS platformType, user_id AS userId, chat_id AS chatId, backend, provider_session_id AS providerSessionId, project_path AS projectPath, updated_at AS updatedAt
-      FROM channel_sessions
-      WHERE platform_type = ? AND user_id = ? AND chat_id = ? AND backend = ?
-      LIMIT 1
-    `).get(normalizedPlatform, userId, chatId, backend) || null;
+    return mapChannelSession(channelDb.getChannelSession({
+      platform: normalizePlatform(platform),
+      userId,
+      chatId,
+      backend,
+    }));
   }
 
   upsertChannelSession({ platform = 'lark', userId, chatId, backend, providerSessionId, projectPath }) {
-    const normalizedPlatform = normalizePlatform(platform);
-    const id = crypto.randomUUID();
-    const updatedAt = now();
-
-    db.prepare(`
-      INSERT INTO channel_sessions (id, platform_type, user_id, chat_id, backend, provider_session_id, project_path, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(platform_type, user_id, chat_id, backend) DO UPDATE SET
-        provider_session_id = excluded.provider_session_id,
-        project_path = excluded.project_path,
-        updated_at = excluded.updated_at
-    `).run(id, normalizedPlatform, userId, chatId, backend, providerSessionId || null, projectPath || null, updatedAt);
-
-    return this.getChannelSession({ platform: normalizedPlatform, userId, chatId, backend });
+    return mapChannelSession(channelDb.upsertChannelSession({
+      platform: normalizePlatform(platform),
+      userId,
+      chatId,
+      backend,
+      providerSessionId,
+      projectPath,
+    }));
   }
 }

package/server/claude-sdk.js

@@ -32,6 +32,8 @@ const pendingToolApprovals = new Map();
 // This does not change SDK limits; it only defines how long we wait for the UI,
 // introduced to avoid hanging the run when no decision arrives.
 const TOOL_APPROVAL_TIMEOUT_MS = parseInt(process.env.CLAUDE_TOOL_APPROVAL_TIMEOUT_MS, 10) || 55000;
+const CLAUDE_STREAM_START_TIMEOUT_MS = parseInt(process.env.CLAUDE_STREAM_START_TIMEOUT_MS, 10) || 20000;
+const CLAUDE_MEANINGFUL_OUTPUT_TIMEOUT_MS = parseInt(process.env.CLAUDE_MEANINGFUL_OUTPUT_TIMEOUT_MS, 10) || 45000;
 
 // Generate a stable request ID for UI approval flows.
 // This does not encode tool details or get shown to users; it exists so the UI
@@ -273,6 +275,48 @@ function transformMessage(sdkMessage) {
   return sdkMessage;
 }
 
+function messageHasMeaningfulClaudeOutput(message) {
+  if (!message || typeof message !== 'object') {
+    return false;
+  }
+
+  if (message.type === 'system' && message.subtype === 'init') {
+    return false;
+  }
+
+  if (message.type === 'content_block_delta') {
+    return typeof message.delta?.text === 'string' && message.delta.text.trim().length > 0;
+  }
+
+  if (message.type === 'thinking') {
+    return typeof message.message?.content === 'string' && message.message.content.trim().length > 0;
+  }
+
+  if (message.type === 'tool_use' || message.type === 'tool_result') {
+    return true;
+  }
+
+  const contentParts = Array.isArray(message.content)
+    ? message.content
+    : Array.isArray(message.message?.content)
+      ? message.message.content
+      : null;
+
+  if (contentParts) {
+    return contentParts.some((part) => (
+      (part?.type === 'text' && typeof part.text === 'string' && part.text.trim().length > 0) ||
+      part?.type === 'tool_use' ||
+      part?.type === 'tool_result'
+    ));
+  }
+
+  if (typeof message.content === 'string' && message.content.trim().length > 0) {
+    return true;
+  }
+
+  return false;
+}
+
 /**
  * Extracts token usage from SDK result messages
  * @param {Object} resultMessage - SDK result message
@@ -473,6 +517,75 @@ async function queryClaudeSDK(command, options = {}, ws) {
   let sessionCreatedSent = false;
   let tempImagePaths = [];
   let tempDir = null;
+  let queryInstance = null;
+  let startupTimeoutId = null;
+  let meaningfulOutputTimeoutId = null;
+  let timeoutTriggered = false;
+  let timeoutErrorMessage = null;
+
+  const clearStartupTimeout = () => {
+    if (startupTimeoutId) {
+      clearTimeout(startupTimeoutId);
+      startupTimeoutId = null;
+    }
+  };
+
+  const clearMeaningfulOutputTimeout = () => {
+    if (meaningfulOutputTimeoutId) {
+      clearTimeout(meaningfulOutputTimeoutId);
+      meaningfulOutputTimeoutId = null;
+    }
+  };
+
+  const interruptTimedOutQuery = () => {
+    if (!queryInstance || typeof queryInstance.interrupt !== 'function') {
+      return;
+    }
+
+    Promise.resolve(queryInstance.interrupt()).catch((interruptError) => {
+      console.warn('Failed to interrupt Claude SDK query after timeout:', interruptError);
+    });
+  };
+
+  const triggerStreamTimeout = (message) => {
+    if (timeoutTriggered) {
+      return;
+    }
+
+    timeoutTriggered = true;
+    timeoutErrorMessage = message;
+    interruptTimedOutQuery();
+  };
+
+  const armStartupTimeout = () => {
+    clearStartupTimeout();
+
+    if (!Number.isFinite(CLAUDE_STREAM_START_TIMEOUT_MS) || CLAUDE_STREAM_START_TIMEOUT_MS <= 0) {
+      return;
+    }
+
+    startupTimeoutId = setTimeout(() => {
+      triggerStreamTimeout(
+        `Claude did not produce any stream events within ${Math.round(CLAUDE_STREAM_START_TIMEOUT_MS / 1000)} seconds. ` +
+        'This usually means the Claude client or upstream service is unavailable.'
+      );
+    }, CLAUDE_STREAM_START_TIMEOUT_MS);
+  };
+
+  const armMeaningfulOutputTimeout = () => {
+    clearMeaningfulOutputTimeout();
+
+    if (!Number.isFinite(CLAUDE_MEANINGFUL_OUTPUT_TIMEOUT_MS) || CLAUDE_MEANINGFUL_OUTPUT_TIMEOUT_MS <= 0) {
+      return;
+    }
+
+    meaningfulOutputTimeoutId = setTimeout(() => {
+      triggerStreamTimeout(
+        `Claude did not produce any assistant output within ${Math.round(CLAUDE_MEANINGFUL_OUTPUT_TIMEOUT_MS / 1000)} seconds. ` +
+        'The upstream Claude service may be unavailable or stuck before the first response.'
+      );
+    }, CLAUDE_MEANINGFUL_OUTPUT_TIMEOUT_MS);
+  };
 
   try {
     // Map CLI options to SDK format
@@ -554,14 +667,29 @@ async function queryClaudeSDK(command, options = {}, ws) {
             sdkOptions.disallowedTools = sdkOptions.disallowedTools.filter(entry => entry !== decision.rememberEntry);
           }
         }
+        ws.send({
+          type: 'claude-permission-resolved',
+          requestId,
+          status: 'approved',
+          toolName,
+          sessionId: capturedSessionId || sessionId || null
+        });
         return { behavior: 'allow', updatedInput: decision.updatedInput ?? input };
       }
 
+      ws.send({
+        type: 'claude-permission-resolved',
+        requestId,
+        status: 'denied',
+        toolName,
+        message: decision.message ?? 'User denied tool use',
+        sessionId: capturedSessionId || sessionId || null
+      });
       return { behavior: 'deny', message: decision.message ?? 'User denied tool use' };
     };
 
     // Create SDK query instance
-    const queryInstance = query({
+    queryInstance = query({
       prompt: finalCommand,
       options: sdkOptions
     });
@@ -573,7 +701,11 @@ async function queryClaudeSDK(command, options = {}, ws) {
 
     // Process streaming messages
     console.log('Starting async generator loop for session:', capturedSessionId || 'NEW');
+    armStartupTimeout();
+    armMeaningfulOutputTimeout();
     for await (const message of queryInstance) {
+      clearStartupTimeout();
+
       // Capture session ID from first message
       if (message.session_id && !capturedSessionId) {
 
@@ -590,7 +722,8 @@ async function queryClaudeSDK(command, options = {}, ws) {
           sessionCreatedSent = true;
           ws.send({
             type: 'session-created',
-            sessionId: capturedSessionId
+            sessionId: capturedSessionId,
+            provider: 'claude'
           });
         } else {
           console.log('Not sending session-created. sessionId:', sessionId, 'sessionCreatedSent:', sessionCreatedSent);
@@ -604,9 +737,14 @@ async function queryClaudeSDK(command, options = {}, ws) {
       ws.send({
         type: 'claude-response',
         data: transformedMessage,
+        provider: 'claude',
         sessionId: capturedSessionId || sessionId || null
       });
 
+      if (messageHasMeaningfulClaudeOutput(message)) {
+        clearMeaningfulOutputTimeout();
+      }
+
       // Extract and send token budget updates from result messages
       if (message.type === 'result') {
         const tokenBudget = extractTokenBudget(message);
@@ -615,12 +753,17 @@ async function queryClaudeSDK(command, options = {}, ws) {
           ws.send({
             type: 'token-budget',
             data: tokenBudget,
+            provider: 'claude',
             sessionId: capturedSessionId || sessionId || null
           });
         }
       }
     }
 
+    if (timeoutTriggered) {
+      throw new Error(timeoutErrorMessage);
+    }
+
     // Clean up session on completion
     if (capturedSessionId) {
       removeSession(capturedSessionId);
@@ -633,6 +776,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
     console.log('Streaming complete, sending claude-complete event');
     ws.send({
       type: 'claude-complete',
+      provider: 'claude',
       sessionId: capturedSessionId,
       exitCode: 0,
       isNewSession: !sessionId && !!command
@@ -653,11 +797,15 @@ async function queryClaudeSDK(command, options = {}, ws) {
     // Send error to WebSocket
     ws.send({
       type: 'claude-error',
-      error: error.message,
+      error: timeoutErrorMessage || error.message,
+      provider: 'claude',
       sessionId: capturedSessionId || sessionId || null
     });
 
     throw error;
+  } finally {
+    clearStartupTimeout();
+    clearMeaningfulOutputTimeout();
   }
 }
 

package/server/cli.js

@@ -72,10 +72,10 @@ function loadEnvFile() {
     }
 }
 
-// Get the database path (same logic as db.js)
-function getDatabasePath() {
+// Get the data file path (same logic as db.js)
+function getDataFilePath() {
     loadEnvFile();
-    return process.env.DATABASE_PATH || path.join(__dirname, 'database', 'auth.db');
+    return process.env.DATA_FILE_PATH || path.join(__dirname, 'database', 'state.json');
 }
 
 // Get the installation directory
@@ -253,15 +253,15 @@ function showStatus(options = {}) {
     console.log(`\n${c.info('[INFO]')} Installation Directory:`);
     console.log(`       ${c.dim(installDir)}`);
 
-    // Database location
-    const dbPath = getDatabasePath();
-    const dbExists = fs.existsSync(dbPath);
-    console.log(`\n${c.info('[INFO]')} Database Location:`);
-    console.log(`       ${c.dim(dbPath)}`);
-    console.log(`       Status: ${dbExists ? c.ok('[OK] Exists') : c.warn('[WARN] Not created yet (will be created on first run)')}`);
+    // Data file location
+    const dataFilePath = getDataFilePath();
+    const dataFileExists = fs.existsSync(dataFilePath);
+    console.log(`\n${c.info('[INFO]')} Data File Location:`);
+    console.log(`       ${c.dim(dataFilePath)}`);
+    console.log(`       Status: ${dataFileExists ? c.ok('[OK] Exists') : c.warn('[WARN] Not created yet (will be created on first run)')}`);
 
-    if (dbExists) {
-        const stats = fs.statSync(dbPath);
+    if (dataFileExists) {
+        const stats = fs.statSync(dataFilePath);
         console.log(`       Size: ${c.dim((stats.size / 1024).toFixed(2) + ' KB')}`);
         console.log(`       Modified: ${c.dim(stats.mtime.toLocaleString())}`);
     }
@@ -295,7 +295,7 @@ function showStatus(options = {}) {
     // Environment variables
     console.log(`\n${c.info('[INFO]')} Configuration:`);
     console.log(`       PORT: ${c.bright(configuredPort)} ${c.dim(process.env.PORT ? '' : '(default)')}`);
-    console.log(`       DATABASE_PATH: ${c.dim(process.env.DATABASE_PATH || '(using default location)')}`);
+    console.log(`       DATA_FILE_PATH: ${c.dim(process.env.DATA_FILE_PATH || '(using default location)')}`);
     console.log(`       CLAUDE_CLI_PATH: ${c.dim(process.env.CLAUDE_CLI_PATH || 'claude (default)')}`);
     console.log(`       CONTEXT_WINDOW: ${c.dim(process.env.CONTEXT_WINDOW || '160000 (default)')}`);
 
@@ -316,7 +316,7 @@ function showStatus(options = {}) {
     console.log('\n' + c.dim('═'.repeat(60)));
     console.log(`\n${c.tip('[TIP]')} Hints:`);
     console.log(`      ${c.dim('>')} Use ${c.bright('axhub-genie --port 8080')} to run on a custom port`);
-    console.log(`      ${c.dim('>')} Use ${c.bright('axhub-genie --database-path /path/to/db')} for custom database`);
+    console.log(`      ${c.dim('>')} Use ${c.bright('axhub-genie --data-file-path /path/to/state.json')} for custom data file`);
     console.log(`      ${c.dim('>')} Run ${c.bright('axhub-genie help')} for all options`);
     console.log(`      ${c.dim('>')} Access the UI at http://localhost:${displayPort}\n`);
 }
@@ -341,7 +341,7 @@ Commands:
 
 Options:
   -p, --port <port>           Set server port (default: 32123)
-  --database-path <path>      Set custom database location
+  --data-file-path <path>      Set custom data file location
   --json                      Output status as JSON (for scripts)
   -h, --help                  Show this help information
   -v, --version               Show version information
@@ -357,7 +357,7 @@ Examples:
 
 Environment Variables:
   PORT                Set server port (default: 32123)
-  DATABASE_PATH       Set custom database location
+  DATA_FILE_PATH       Set custom data file location
   CLAUDE_CLI_PATH     Set custom Claude CLI path
   CONTEXT_WINDOW      Set context window size (default: 160000)
   AXHUB_GENIE_STATUS_PATH  Set runtime status file path
@@ -453,10 +453,10 @@ function parseArgs(args) {
             parsed.options.port = args[++i];
         } else if (arg.startsWith('--port=')) {
             parsed.options.port = arg.split('=')[1];
-        } else if (arg === '--database-path') {
-            parsed.options.databasePath = args[++i];
-        } else if (arg.startsWith('--database-path=')) {
-            parsed.options.databasePath = arg.split('=')[1];
+        } else if (arg === '--data-file-path') {
+            parsed.options.dataFilePath = args[++i];
+        } else if (arg.startsWith('--data-file-path=')) {
+            parsed.options.dataFilePath = arg.split('=')[1];
         } else if (arg === '--json') {
             parsed.options.json = true;
         } else if (arg === '--help' || arg === '-h') {
@@ -482,8 +482,8 @@ async function main() {
     if (options.port) {
         process.env.PORT = options.port;
     }
-    if (options.databasePath) {
-        process.env.DATABASE_PATH = options.databasePath;
+    if (options.dataFilePath) {
+        process.env.DATA_FILE_PATH = options.dataFilePath;
     }
 
     switch (command) {