@axhub/genie 0.1.6 → 0.1.8

package/server/channels/store/ChannelStore.js

@@ -0,0 +1,236 @@
+import crypto from 'crypto';
+
+import { db } 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 parseConfig(value, platform) {
+  const defaults = getDefaultConfig(platform);
+  if (!value) {
+    return defaults;
+  }
+
+  try {
+    const parsed = JSON.parse(value);
+    return {
+      ...defaults,
+      ...(parsed || {}),
+    };
+  } catch {
+    return defaults;
+  }
+}
+
+export class ChannelStore {
+  normalizePlatform(platform) {
+    return normalizePlatform(platform);
+  }
+
+  getPluginId(platform) {
+    return resolvePluginIdByPlatform(platform);
+  }
+
+  getPluginConfig(pluginId = 'lark_default') {
+    const row = db.prepare('SELECT * FROM channel_plugins WHERE id = ?').get(pluginId);
+    const platform = resolvePlatformByPluginId(pluginId);
+
+    if (!row) {
+      return {
+        id: pluginId,
+        type: platform,
+        enabled: 0,
+        status: 'stopped',
+        config: getDefaultConfig(platform),
+      };
+    }
+
+    return {
+      id: row.id,
+      type: row.type || platform,
+      enabled: row.enabled,
+      status: row.status,
+      config: parseConfig(row.config_json, row.type || platform),
+      updatedAt: row.updated_at,
+    };
+  }
+
+  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,
+      type,
+      existing.enabled || 0,
+      existing.status || 'stopped',
+      JSON.stringify(nextConfig),
+      updatedAt
+    );
+
+    return this.getPluginConfig(pluginId);
+  }
+
+  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,
+      type,
+      enabled ? 1 : 0,
+      status,
+      JSON.stringify(existing.config),
+      updatedAt
+    );
+
+    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);
+  }
+
+  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');
+    }
+
+    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);
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  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 });
+  }
+}

package/server/database/db.js

@@ -55,6 +55,111 @@ if (process.env.DATABASE_PATH) {
 console.log(c.dim('═'.repeat(60)));
 console.log('');
 
+const tableExists = (tableName) => {
+  const row = db
+    .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+    .get(tableName);
+  return !!row;
+};
+
+const getTableColumns = (tableName) => {
+  if (!tableExists(tableName)) {
+    return [];
+  }
+  return db.prepare(`PRAGMA table_info(${tableName})`).all().map((col) => col.name);
+};
+
+const hasIndex = (indexName) => {
+  const row = db
+    .prepare("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?")
+    .get(indexName);
+  return !!row;
+};
+
+const ensureChannelAllowedUsersSchema = () => {
+  if (!tableExists('channel_allowed_users')) {
+    return;
+  }
+
+  const columns = getTableColumns('channel_allowed_users');
+  const tableSqlRow = db
+    .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'channel_allowed_users'")
+    .get();
+  const tableSql = String(tableSqlRow?.sql || '');
+  const hasLegacyUserIdUnique = /user_id\s+TEXT\s+UNIQUE/i.test(tableSql);
+  const needsRebuild = !columns.includes('platform_type') || hasLegacyUserIdUnique;
+
+  if (needsRebuild) {
+    console.log('Running migration: Rebuilding channel_allowed_users with platform isolation');
+    const beforeCount = db.prepare('SELECT COUNT(*) AS count FROM channel_allowed_users').get()?.count || 0;
+
+    db.transaction(() => {
+      db.exec('ALTER TABLE channel_allowed_users RENAME TO channel_allowed_users_old');
+      db.exec(`
+        CREATE TABLE channel_allowed_users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          platform_type TEXT NOT NULL DEFAULT 'lark',
+          user_id TEXT NOT NULL,
+          display_name TEXT,
+          note TEXT,
+          is_active BOOLEAN DEFAULT 1,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+
+      const oldColumns = getTableColumns('channel_allowed_users_old');
+      const hasOldPlatformType = oldColumns.includes('platform_type');
+
+      if (hasOldPlatformType) {
+        db.exec(`
+          INSERT INTO channel_allowed_users (id, platform_type, user_id, display_name, note, is_active, created_at, updated_at)
+          SELECT id, COALESCE(platform_type, 'lark'), user_id, display_name, note, is_active, created_at, updated_at
+          FROM channel_allowed_users_old
+        `);
+      } else {
+        db.exec(`
+          INSERT INTO channel_allowed_users (id, platform_type, user_id, display_name, note, is_active, created_at, updated_at)
+          SELECT id, 'lark', user_id, display_name, note, is_active, created_at, updated_at
+          FROM channel_allowed_users_old
+        `);
+      }
+
+      db.exec('DROP TABLE channel_allowed_users_old');
+    })();
+
+    const afterCount = db.prepare('SELECT COUNT(*) AS count FROM channel_allowed_users').get()?.count || 0;
+    console.log(`channel_allowed_users rows migrated: ${beforeCount} -> ${afterCount}`);
+  }
+
+  db.exec("UPDATE channel_allowed_users SET platform_type = 'lark' WHERE platform_type IS NULL OR TRIM(platform_type) = ''");
+  db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_allowed_users_platform_user ON channel_allowed_users(platform_type, user_id)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_allowed_users_user_id ON channel_allowed_users(user_id)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_allowed_users_platform_type ON channel_allowed_users(platform_type)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_allowed_users_active ON channel_allowed_users(is_active)');
+};
+
+const ensureChannelSessionsSchema = () => {
+  if (!tableExists('channel_sessions')) {
+    return;
+  }
+
+  const columns = getTableColumns('channel_sessions');
+  if (!columns.includes('platform_type')) {
+    console.log('Running migration: Adding platform_type to channel_sessions');
+    db.exec("ALTER TABLE channel_sessions ADD COLUMN platform_type TEXT NOT NULL DEFAULT 'lark'");
+  }
+
+  db.exec("UPDATE channel_sessions SET platform_type = 'lark' WHERE platform_type IS NULL OR TRIM(platform_type) = ''");
+
+  if (hasIndex('idx_channel_sessions_unique')) {
+    db.exec('DROP INDEX IF EXISTS idx_channel_sessions_unique');
+  }
+  db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_sessions_unique ON channel_sessions(platform_type, user_id, chat_id, backend)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_sessions_platform_type ON channel_sessions(platform_type)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_sessions_user_id ON channel_sessions(user_id)');
+};
+
 const runMigrations = () => {
   try {
     const tableInfo = db.prepare("PRAGMA table_info(users)").all();
@@ -75,6 +180,9 @@ const runMigrations = () => {
       db.exec('ALTER TABLE users ADD COLUMN has_completed_onboarding BOOLEAN DEFAULT 0');
     }
 
+    ensureChannelAllowedUsersSchema();
+    ensureChannelSessionsSchema();
+
     console.log('Database migrations completed successfully');
   } catch (error) {
     console.error('Error running migrations:', error.message);
@@ -358,4 +466,4 @@ export {
   apiKeysDb,
   credentialsDb,
   githubTokensDb // Backward compatibility
-};
+};

package/server/database/init.sql

@@ -49,4 +49,50 @@ CREATE TABLE IF NOT EXISTS user_credentials (
 
 CREATE INDEX IF NOT EXISTS idx_user_credentials_user_id ON user_credentials(user_id);
 CREATE INDEX IF NOT EXISTS idx_user_credentials_type ON user_credentials(credential_type);
-CREATE INDEX IF NOT EXISTS idx_user_credentials_active ON user_credentials(is_active);
+CREATE INDEX IF NOT EXISTS idx_user_credentials_active ON user_credentials(is_active);
+
+-- Channel plugins table (Lark and future channels)
+CREATE TABLE IF NOT EXISTS channel_plugins (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    enabled BOOLEAN DEFAULT 0,
+    status TEXT DEFAULT 'stopped',
+    config_json TEXT NOT NULL,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_channel_plugins_type ON channel_plugins(type);
+CREATE INDEX IF NOT EXISTS idx_channel_plugins_enabled ON channel_plugins(enabled);
+
+-- Allowed channel users (whitelist by platform user ID)
+CREATE TABLE IF NOT EXISTS channel_allowed_users (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    platform_type TEXT NOT NULL DEFAULT 'lark',
+    user_id TEXT NOT NULL,
+    display_name TEXT,
+    note TEXT,
+    is_active BOOLEAN DEFAULT 1,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_allowed_users_platform_user ON channel_allowed_users(platform_type, user_id);
+CREATE INDEX IF NOT EXISTS idx_channel_allowed_users_user_id ON channel_allowed_users(user_id);
+CREATE INDEX IF NOT EXISTS idx_channel_allowed_users_platform_type ON channel_allowed_users(platform_type);
+CREATE INDEX IF NOT EXISTS idx_channel_allowed_users_active ON channel_allowed_users(is_active);
+
+-- Channel session bindings
+CREATE TABLE IF NOT EXISTS channel_sessions (
+    id TEXT PRIMARY KEY,
+    platform_type TEXT NOT NULL DEFAULT 'lark',
+    user_id TEXT NOT NULL,
+    chat_id TEXT NOT NULL,
+    backend TEXT NOT NULL,
+    provider_session_id TEXT,
+    project_path TEXT,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_sessions_unique ON channel_sessions(platform_type, user_id, chat_id, backend);
+CREATE INDEX IF NOT EXISTS idx_channel_sessions_platform_type ON channel_sessions(platform_type);
+CREATE INDEX IF NOT EXISTS idx_channel_sessions_user_id ON channel_sessions(user_id);

package/server/gemini-cli.js

@@ -0,0 +1,280 @@
+import { spawn } from 'child_process';
+import crossSpawn from 'cross-spawn';
+
+const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
+
+const activeGeminiProcesses = new Map();
+
+function collectTextChunks(payload) {
+  if (!payload) return [];
+  if (typeof payload === 'string') return payload.trim() ? [payload] : [];
+
+  const chunks = [];
+
+  if (Array.isArray(payload)) {
+    payload.forEach(item => {
+      chunks.push(...collectTextChunks(item));
+    });
+    return chunks;
+  }
+
+  if (typeof payload !== 'object') {
+    return chunks;
+  }
+
+  const directKeys = ['text', 'response', 'content', 'message', 'delta'];
+  for (const key of directKeys) {
+    if (payload[key] !== undefined) {
+      chunks.push(...collectTextChunks(payload[key]));
+    }
+  }
+
+  if (Array.isArray(payload.parts)) {
+    payload.parts.forEach(part => {
+      chunks.push(...collectTextChunks(part));
+    });
+  }
+
+  if (payload.data && typeof payload.data === 'object') {
+    chunks.push(...collectTextChunks(payload.data));
+  }
+
+  return chunks;
+}
+
+function getEventRole(event) {
+  return (
+    event?.role ||
+    event?.author ||
+    event?.sender ||
+    event?.message?.role ||
+    event?.data?.role ||
+    event?.content?.role ||
+    null
+  );
+}
+
+function extractAssistantTextChunks(event, command) {
+  const role = String(getEventRole(event) || '').toLowerCase();
+  if (role === 'user') return [];
+
+  const eventType = String(event?.type || event?.event || event?.kind || '').toLowerCase();
+  const hasAssistantPayload = !!(event?.response || event?.candidates || event?.delta || event?.text || event?.content || event?.message);
+  if (eventType.includes('prompt') && !hasAssistantPayload) {
+    return [];
+  }
+
+  const normalizedPrompt = String(command || '').trim();
+  return collectTextChunks(event).filter((text) => {
+    const trimmed = String(text || '').trim();
+    if (!trimmed) return false;
+    if (normalizedPrompt && trimmed === normalizedPrompt) return false;
+    return true;
+  });
+}
+
+function parseGeminiJsonLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+
+  const payload = trimmed.startsWith('data:') ? trimmed.slice(5).trim() : trimmed;
+  if (!payload) return null;
+
+  return JSON.parse(payload);
+}
+
+function emitTextChunks(ws, sessionId, chunks) {
+  chunks.forEach((text) => {
+    if (!text) return;
+    ws.send({
+      type: 'claude-response',
+      data: {
+        type: 'content_block_delta',
+        delta: {
+          type: 'text_delta',
+          text
+        }
+      },
+      provider: 'gemini',
+      sessionId
+    });
+  });
+}
+
+async function queryGemini(command, options = {}, ws) {
+  return new Promise((resolve, reject) => {
+    const { sessionId, cwd, projectPath, resume, model, permissionMode } = options;
+    let capturedSessionId = sessionId;
+    let sentSessionCreated = false;
+
+    const args = ['-y', '@google/gemini-cli'];
+
+    if (sessionId && (resume || !command || !command.trim())) {
+      args.push('--resume', sessionId);
+    }
+
+    if (command && command.trim()) {
+      args.push('--prompt', command);
+      args.push('--output-format', 'stream-json');
+    }
+
+    if (model) {
+      args.push('--model', model);
+    }
+
+    if (permissionMode === 'bypassPermissions' || permissionMode === 'acceptEdits') {
+      args.push('--yolo');
+    }
+
+    const workingDir = cwd || projectPath || process.cwd();
+
+    const geminiProcess = spawnFunction('npx', args, {
+      cwd: workingDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        GEMINI_NONINTERACTIVE: '1'
+      }
+    });
+
+    const processKey = capturedSessionId || Date.now().toString();
+    let processRegistryKey = processKey;
+    activeGeminiProcesses.set(processRegistryKey, geminiProcess);
+
+    const finalizeSessionId = () => capturedSessionId || sessionId || null;
+
+    const handleJsonEvent = (event) => {
+      const incomingSessionId = event?.session_id || event?.sessionId || event?.data?.session_id || event?.data?.sessionId;
+      if (incomingSessionId && !capturedSessionId) {
+        capturedSessionId = incomingSessionId;
+        if (ws.setSessionId && typeof ws.setSessionId === 'function') {
+          ws.setSessionId(capturedSessionId);
+        }
+
+        if (processRegistryKey !== capturedSessionId) {
+          activeGeminiProcesses.delete(processRegistryKey);
+          activeGeminiProcesses.set(capturedSessionId, geminiProcess);
+          processRegistryKey = capturedSessionId;
+        }
+
+        if (!sessionId && !sentSessionCreated) {
+          sentSessionCreated = true;
+          ws.send({
+            type: 'session-created',
+            sessionId: capturedSessionId,
+            provider: 'gemini'
+          });
+        }
+      }
+
+      const type = event?.type || event?.event || event?.kind;
+      if (type === 'result' || type === 'done' || type === 'complete') {
+        ws.send({
+          type: 'claude-response',
+          data: { type: 'content_block_stop' },
+          provider: 'gemini',
+          sessionId: finalizeSessionId()
+        });
+
+        ws.send({
+          type: 'gemini-result',
+          data: event,
+          sessionId: finalizeSessionId()
+        });
+        return;
+      }
+
+      const textChunks = extractAssistantTextChunks(event, command);
+      emitTextChunks(ws, finalizeSessionId(), textChunks);
+    };
+
+    let stdoutBuffer = '';
+    geminiProcess.stdout.on('data', (data) => {
+      stdoutBuffer += data.toString();
+      const lines = stdoutBuffer.split('\n');
+      stdoutBuffer = lines.pop() || '';
+
+      for (const line of lines) {
+        try {
+          const event = parseGeminiJsonLine(line);
+          if (!event) continue;
+          handleJsonEvent(event);
+        } catch {}
+      }
+    });
+
+    geminiProcess.stderr.on('data', (data) => {
+      ws.send({
+        type: 'claude-error',
+        error: data.toString(),
+        sessionId: finalizeSessionId()
+      });
+    });
+
+    geminiProcess.on('close', (code) => {
+      if (stdoutBuffer.trim()) {
+        try {
+          const finalEvent = parseGeminiJsonLine(stdoutBuffer);
+          if (finalEvent) {
+            handleJsonEvent(finalEvent);
+          }
+        } catch {}
+      }
+
+      activeGeminiProcesses.delete(processRegistryKey);
+
+      ws.send({
+        type: 'claude-complete',
+        sessionId: finalizeSessionId(),
+        provider: 'gemini',
+        exitCode: code,
+        isNewSession: !sessionId && !!command
+      });
+
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Gemini CLI exited with code ${code}`));
+      }
+    });
+
+    geminiProcess.on('error', (error) => {
+      activeGeminiProcesses.delete(processRegistryKey);
+
+      ws.send({
+        type: 'claude-error',
+        error: error.message,
+        sessionId: finalizeSessionId()
+      });
+
+      reject(error);
+    });
+
+    geminiProcess.stdin.end();
+  });
+}
+
+function abortGeminiSession(sessionId) {
+  const process = activeGeminiProcesses.get(sessionId);
+  if (process) {
+    process.kill('SIGTERM');
+    activeGeminiProcesses.delete(sessionId);
+    return true;
+  }
+  return false;
+}
+
+function isGeminiSessionActive(sessionId) {
+  return activeGeminiProcesses.has(sessionId);
+}
+
+function getActiveGeminiSessions() {
+  return Array.from(activeGeminiProcesses.keys());
+}
+
+export {
+  queryGemini,
+  abortGeminiSession,
+  isGeminiSessionActive,
+  getActiveGeminiSessions
+};