@axhub/genie 0.1.8 → 0.2.0

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

@@ -20,6 +20,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
 import { CLAUDE_MODELS } from '../shared/modelConstants.js';
+import { resolveWorkingDirectory } from './utils/defaultWorkingDirectory.js';
 
 // Session tracking: Map of session IDs to active query instances
 const activeSessions = new Map();
@@ -32,6 +33,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 +276,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
@@ -468,24 +513,98 @@ async function loadMcpConfig(cwd) {
  * @returns {Promise<void>}
  */
 async function queryClaudeSDK(command, options = {}, ws) {
+  const workingDirectory = resolveWorkingDirectory(options);
+  const effectiveOptions = {
+    ...options,
+    cwd: workingDirectory
+  };
   const { sessionId } = options;
   let capturedSessionId = sessionId;
   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
-    const sdkOptions = mapCliOptionsToSDK(options);
+    const sdkOptions = mapCliOptionsToSDK(effectiveOptions);
 
     // Load MCP configuration
-    const mcpServers = await loadMcpConfig(options.cwd);
+    const mcpServers = await loadMcpConfig(effectiveOptions.cwd);
     if (mcpServers) {
       sdkOptions.mcpServers = mcpServers;
     }
 
     // Handle images - save to temp files and modify prompt
-    const imageResult = await handleImages(command, options.images, options.cwd);
+    const imageResult = await handleImages(command, effectiveOptions.images, effectiveOptions.cwd);
     const finalCommand = imageResult.modifiedCommand;
     tempImagePaths = imageResult.tempImagePaths;
     tempDir = imageResult.tempDir;
@@ -554,14 +673,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 +707,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 +728,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 +743,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 +759,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 +782,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 +803,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();
   }
 }