@axhub/genie 0.1.7 → 0.1.9

package/server/channels/store/ChannelStore.js

@@ -0,0 +1,202 @@
+import { channelDb } from '../../database/db.js';
+
+const DEFAULT_CONFIGS = {
+  lark: {
+    appId: '',
+    appSecret: '',
+    encryptKey: '',
+    verificationToken: '',
+    defaultBackend: 'codex',
+    defaultModel: '',
+    defaultProjectPath: '',
+  },
+  dingtalk: {
+    clientId: '',
+    clientSecret: '',
+    defaultBackend: 'codex',
+    defaultModel: '',
+    defaultProjectPath: '',
+  },
+};
+
+const PLATFORM_TO_PLUGIN_ID = {
+  lark: 'lark_default',
+  dingtalk: 'dingtalk_default',
+};
+
+const PLUGIN_ID_TO_PLATFORM = {
+  lark_default: 'lark',
+  dingtalk_default: 'dingtalk',
+};
+
+function now() {
+  return new Date().toISOString();
+}
+
+function normalizePlatform(platform) {
+  const normalized = String(platform || '').trim().toLowerCase();
+  return normalized === 'dingtalk' ? 'dingtalk' : 'lark';
+}
+
+function resolvePlatformByPluginId(pluginId) {
+  return PLUGIN_ID_TO_PLATFORM[pluginId] || 'lark';
+}
+
+function resolvePluginIdByPlatform(platform) {
+  return PLATFORM_TO_PLUGIN_ID[normalizePlatform(platform)] || PLATFORM_TO_PLUGIN_ID.lark;
+}
+
+function getDefaultConfig(platform) {
+  return { ...(DEFAULT_CONFIGS[normalizePlatform(platform)] || DEFAULT_CONFIGS.lark) };
+}
+
+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,
+  };
+}
+
+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 {
+  normalizePlatform(platform) {
+    return normalizePlatform(platform);
+  }
+
+  getPluginId(platform) {
+    return resolvePluginIdByPlatform(platform);
+  }
+
+  getPluginConfig(pluginId = 'lark_default') {
+    const row = channelDb.getPlugin(pluginId);
+    const platform = resolvePlatformByPluginId(pluginId);
+
+    if (!row) {
+      return {
+        id: pluginId,
+        type: platform,
+        enabled: false,
+        status: 'stopped',
+        config: getDefaultConfig(platform),
+      };
+    }
+
+    return {
+      id: row.id,
+      type: row.type || platform,
+      enabled: !!row.enabled,
+      status: row.status,
+      config: {
+        ...getDefaultConfig(row.type || platform),
+        ...(row.config || {}),
+      },
+      updatedAt: row.updated_at,
+    };
+  }
+
+  upsertPluginConfig(pluginId = 'lark_default', patch = {}) {
+    const existing = this.getPluginConfig(pluginId);
+    const type = resolvePlatformByPluginId(pluginId);
+
+    channelDb.upsertPlugin({
+      id: pluginId,
+      type,
+      enabled: !!existing.enabled,
+      status: existing.status || 'stopped',
+      config: {
+        ...existing.config,
+        ...patch,
+      },
+      updated_at: now(),
+    });
+
+    return this.getPluginConfig(pluginId);
+  }
+
+  updatePluginRuntimeStatus(pluginId = 'lark_default', enabled, status) {
+    const existing = this.getPluginConfig(pluginId);
+    const type = resolvePlatformByPluginId(pluginId);
+
+    channelDb.upsertPlugin({
+      id: pluginId,
+      type,
+      enabled: !!enabled,
+      status,
+      config: existing.config,
+      updated_at: now(),
+    });
+
+    return this.getPluginConfig(pluginId);
+  }
+
+  listAllowedUsers(platform = 'lark') {
+    return channelDb.listAllowedUsers(normalizePlatform(platform)).map(mapAllowedUser);
+  }
+
+  addAllowedUser(platform = 'lark', { userId, displayName = null, note = null }) {
+    const normalizedPlatform = normalizePlatform(platform);
+    const trimmedUserId = String(userId || '').trim();
+    if (!trimmedUserId) {
+      throw new Error('userId is required');
+    }
+
+    return mapAllowedUser(channelDb.addAllowedUser(normalizedPlatform, {
+      userId: trimmedUserId,
+      displayName: displayName ? String(displayName).trim() : null,
+      note: note ? String(note).trim() : null,
+    }));
+  }
+
+  removeAllowedUser(platform = 'lark', id) {
+    return channelDb.removeAllowedUser(normalizePlatform(platform), id);
+  }
+
+  toggleAllowedUser(platform = 'lark', id, isActive) {
+    return channelDb.toggleAllowedUser(normalizePlatform(platform), id, isActive);
+  }
+
+  isAllowedUser(platform = 'lark', userId) {
+    if (!userId) return false;
+    return channelDb.isAllowedUser(normalizePlatform(platform), String(userId));
+  }
+
+  getChannelSession({ platform = 'lark', userId, chatId, backend }) {
+    return mapChannelSession(channelDb.getChannelSession({
+      platform: normalizePlatform(platform),
+      userId,
+      chatId,
+      backend,
+    }));
+  }
+
+  upsertChannelSession({ platform = 'lark', userId, chatId, backend, providerSessionId, projectPath }) {
+    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) {