@cerulin/chell 0.2.5

package/dist/runGemini-C03RUmvr.mjs

@@ -0,0 +1,788 @@
+import { useStdout, useInput, Box, Text, render } from 'ink';
+import React, { useState, useRef, useEffect, useCallback } from 'react';
+import { l as logger, A as ApiClient, r as readSettings, p as projectPath, c as configuration, b as packageJson, u as updateActivityTimestamp } from './types-fM_iFuNp.mjs';
+import { spawn } from 'child_process';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+import { randomUUID as randomUUID$1 } from 'node:crypto';
+import { i as initialMachineMetadata, M as MessageQueue2, h as hashObject, r as registerKillSessionHandler, a as MessageBuffer, s as startChellServer } from './index-B443j7JQ.mjs';
+import os from 'node:os';
+import { join as join$1 } from 'node:path';
+import 'axios';
+import 'chalk';
+import 'node:fs';
+import 'node:fs/promises';
+import 'zod';
+import 'tweetnacl';
+import 'node:events';
+import 'socket.io-client';
+import 'util';
+import 'fs/promises';
+import 'url';
+import 'node-pty';
+import 'expo-server-sdk';
+import 'node:child_process';
+import 'node:readline';
+import 'node:url';
+import 'ps-list';
+import 'cross-spawn';
+import 'qrcode-terminal';
+import 'open';
+import 'fastify';
+import 'fastify-type-provider-zod';
+import '@modelcontextprotocol/sdk/server/mcp.js';
+import 'node:http';
+import '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import 'http';
+import 'readline';
+
+class GeminiClient {
+  originalSettings = null;
+  settingsPath;
+  handler = null;
+  isRunning = false;
+  sessionId = null;
+  config = null;
+  checkpointDir = null;
+  constructor() {
+    const geminiHome = process.env.GEMINI_HOME || join(homedir(), ".gemini");
+    this.settingsPath = join(geminiHome, "settings.json");
+  }
+  /**
+   * Set event handler for Gemini events
+   */
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  /**
+   * Inject chell MCP server into Gemini settings
+   * Backs up existing settings and merges our MCP server config
+   */
+  injectMcpServerConfig(chellServerUrl, bridgeCommand) {
+    if (existsSync(this.settingsPath)) {
+      this.originalSettings = readFileSync(this.settingsPath, "utf-8");
+      logger.debug("[GeminiClient] Backed up existing settings");
+    }
+    let existingSettings = {};
+    if (this.originalSettings) {
+      try {
+        existingSettings = JSON.parse(this.originalSettings);
+      } catch (error) {
+        logger.debug("[GeminiClient] Failed to parse existing settings, using empty config");
+      }
+    }
+    const updatedSettings = {
+      ...existingSettings,
+      mcpServers: {
+        ...existingSettings.mcpServers,
+        chell: {
+          command: "node",
+          args: [bridgeCommand, "--url", chellServerUrl],
+          trust: true
+        }
+      }
+    };
+    mkdirSync(join(this.settingsPath, ".."), { recursive: true });
+    writeFileSync(this.settingsPath, JSON.stringify(updatedSettings, null, 2));
+    logger.debug("[GeminiClient] Injected MCP server config into:", this.settingsPath);
+  }
+  /**
+   * Start Gemini session (stores config, injects MCP, creates checkpoint dir)
+   */
+  async startSession(config, chellServerUrl, bridgeCommand, options) {
+    if (this.isRunning) {
+      throw new Error("Session already running");
+    }
+    this.sessionId = randomUUID();
+    this.config = config;
+    this.isRunning = true;
+    const geminiHome = process.env.GEMINI_HOME || join(homedir(), ".gemini");
+    this.checkpointDir = join(geminiHome, "chell-checkpoints", this.sessionId);
+    mkdirSync(this.checkpointDir, { recursive: true });
+    this.injectMcpServerConfig(chellServerUrl, bridgeCommand);
+    logger.debug("[GeminiClient] Session initialized with checkpoint dir:", this.checkpointDir);
+  }
+  /**
+   * Send user message to Gemini (spawns one-shot process)
+   */
+  async sendMessage(message) {
+    if (!this.isRunning || !this.config) {
+      throw new Error("No active session");
+    }
+    logger.debug("[GeminiClient] Running one-shot Gemini:", message);
+    const args = [
+      "--output-format",
+      "json",
+      "--checkpointing",
+      // Enable checkpointing for conversation history
+      "--prompt",
+      message
+    ];
+    if (this.config.model) {
+      args.push("-m", this.config.model);
+    }
+    if (this.config.yolo) {
+      args.push("--yolo");
+    }
+    if (this.config.debug) {
+      args.push("--debug");
+    }
+    if (this.config.includeDirectories && this.config.includeDirectories.length > 0) {
+      args.push("--include-directories", this.config.includeDirectories.join(","));
+    }
+    return new Promise((resolve, reject) => {
+      const proc = spawn("gemini", args, {
+        cwd: this.checkpointDir || process.cwd(),
+        // Run in checkpoint dir to use same checkpoint files
+        env: {
+          ...process.env,
+          DISABLE_PROGRESS_BAR: "1",
+          NO_COLOR: "1",
+          FORCE_COLOR: "0"
+        }
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+        logger.debug("[GeminiClient] stderr:", data.toString());
+      });
+      proc.on("exit", (code) => {
+        if (code !== 0) {
+          logger.debug("[GeminiClient] Process exited with code:", code);
+          this.handler?.({
+            type: "error",
+            message: `Gemini failed: ${stderr || "Unknown error"}`
+          });
+          reject(new Error(`Gemini exited with code ${code}`));
+          return;
+        }
+        try {
+          const response = JSON.parse(stdout);
+          logger.debug("[GeminiClient] Response:", response);
+          const text = response.response || response.text || JSON.stringify(response);
+          this.handler?.({
+            type: "message",
+            role: "assistant",
+            content: text
+          });
+          resolve();
+        } catch (error) {
+          logger.debug("[GeminiClient] Failed to parse JSON:", stdout);
+          if (stdout.trim()) {
+            this.handler?.({
+              type: "message",
+              role: "assistant",
+              content: stdout.trim()
+            });
+          }
+          resolve();
+        }
+      });
+      proc.on("error", (error) => {
+        logger.debug("[GeminiClient] Process error:", error);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Abort current task (no-op for one-shot mode)
+   */
+  abort() {
+    logger.debug("[GeminiClient] Abort called (no-op in one-shot mode)");
+  }
+  /**
+   * Check if session is active
+   */
+  hasActiveSession() {
+    return this.isRunning;
+  }
+  /**
+   * Get current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Kill session and cleanup
+   */
+  async disconnect() {
+    logger.debug("[GeminiClient] Disconnecting");
+    if (this.originalSettings !== null) {
+      try {
+        writeFileSync(this.settingsPath, this.originalSettings);
+        logger.debug("[GeminiClient] Restored original settings");
+      } catch (error) {
+        logger.debug("[GeminiClient] Failed to restore settings:", error);
+      }
+      this.originalSettings = null;
+    } else {
+      try {
+        if (existsSync(this.settingsPath)) {
+          unlinkSync(this.settingsPath);
+          logger.debug("[GeminiClient] Removed injected settings");
+        }
+      } catch (error) {
+        logger.debug("[GeminiClient] Failed to remove settings:", error);
+      }
+    }
+    if (this.checkpointDir) {
+      try {
+        logger.debug("[GeminiClient] Keeping checkpoint dir for potential resume:", this.checkpointDir);
+      } catch (error) {
+        logger.debug("[GeminiClient] Error with checkpoint cleanup:", error);
+      }
+      this.checkpointDir = null;
+    }
+    this.isRunning = false;
+    this.sessionId = null;
+    this.config = null;
+    logger.debug("[GeminiClient] Disconnected");
+  }
+}
+
+class GeminiPermissionHandler {
+  session;
+  pendingRequests = /* @__PURE__ */ new Map();
+  constructor(session) {
+    this.session = session;
+    this.setupRpcHandler();
+  }
+  /**
+   * Handle tool permission request
+   */
+  async handleToolCall(callId, toolName, input) {
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(callId, {
+        resolve,
+        reject,
+        toolName,
+        input
+      });
+      this.session.updateAgentState((currentState) => ({
+        ...currentState,
+        requests: {
+          ...currentState.requests,
+          [callId]: {
+            tool: toolName,
+            arguments: input,
+            createdAt: Date.now()
+          }
+        }
+      }));
+      logger.debug(`[Gemini] Permission request sent for tool: ${toolName} (${callId})`);
+    });
+  }
+  /**
+   * Setup RPC handler for permission responses
+   */
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler(
+      "permission",
+      async (response) => {
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+          logger.debug("[Gemini] Permission request not found or already resolved");
+          return;
+        }
+        this.pendingRequests.delete(response.id);
+        const result = response.approved ? { decision: "approved" } : { decision: "denied" };
+        pending.resolve(result);
+        this.session.updateAgentState((currentState) => {
+          const request = currentState.requests?.[response.id];
+          if (!request) return currentState;
+          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+          return {
+            ...currentState,
+            requests: remainingRequests,
+            completedRequests: {
+              ...currentState.completedRequests,
+              [response.id]: {
+                ...request,
+                completedAt: Date.now(),
+                status: response.approved ? "approved" : "denied",
+                decision: result.decision
+              }
+            }
+          };
+        });
+        logger.debug(`[Gemini] Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
+      }
+    );
+  }
+  /**
+   * Reset handler state (on abort or task completion)
+   */
+  reset() {
+    for (const [id, pending] of this.pendingRequests.entries()) {
+      pending.reject(new Error("Permission handler reset"));
+    }
+    this.pendingRequests.clear();
+    this.session.updateAgentState((currentState) => {
+      const pendingRequests = currentState.requests || {};
+      const completedRequests = { ...currentState.completedRequests };
+      for (const [id, request] of Object.entries(pendingRequests)) {
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason: "Session reset"
+        };
+      }
+      return {
+        ...currentState,
+        requests: {},
+        completedRequests
+      };
+    });
+    logger.debug("[Gemini] Permission handler reset");
+  }
+}
+
+const GeminiDisplay = ({ messageBuffer, logPath, onExit }) => {
+  const [messages, setMessages] = useState([]);
+  const [confirmationMode, setConfirmationMode] = useState(false);
+  const [actionInProgress, setActionInProgress] = useState(false);
+  const confirmationTimeoutRef = useRef(null);
+  const { stdout } = useStdout();
+  const terminalWidth = stdout.columns || 80;
+  const terminalHeight = stdout.rows || 24;
+  useEffect(() => {
+    setMessages(messageBuffer.getMessages());
+    const unsubscribe = messageBuffer.onUpdate((newMessages) => {
+      setMessages(newMessages);
+    });
+    return () => {
+      unsubscribe();
+      if (confirmationTimeoutRef.current) {
+        clearTimeout(confirmationTimeoutRef.current);
+      }
+    };
+  }, [messageBuffer]);
+  const resetConfirmation = useCallback(() => {
+    setConfirmationMode(false);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+      confirmationTimeoutRef.current = null;
+    }
+  }, []);
+  const setConfirmationWithTimeout = useCallback(() => {
+    setConfirmationMode(true);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+    }
+    confirmationTimeoutRef.current = setTimeout(() => {
+      resetConfirmation();
+    }, 15e3);
+  }, [resetConfirmation]);
+  useInput(useCallback(async (input, key) => {
+    if (actionInProgress) return;
+    if (key.ctrl && input === "c") {
+      if (confirmationMode) {
+        resetConfirmation();
+        setActionInProgress(true);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        onExit?.();
+      } else {
+        setConfirmationWithTimeout();
+      }
+      return;
+    }
+    if (confirmationMode) {
+      resetConfirmation();
+    }
+  }, [confirmationMode, actionInProgress, onExit, setConfirmationWithTimeout, resetConfirmation]));
+  const getMessageColor = (type) => {
+    switch (type) {
+      case "user":
+        return "magenta";
+      case "assistant":
+        return "cyan";
+      case "system":
+        return "blue";
+      case "tool":
+        return "yellow";
+      case "result":
+        return "green";
+      case "status":
+        return "gray";
+      default:
+        return "white";
+    }
+  };
+  const formatMessage = (msg) => {
+    const lines = msg.content.split("\n");
+    const maxLineLength = terminalWidth - 10;
+    return lines.map((line) => {
+      if (line.length <= maxLineLength) return line;
+      const chunks = [];
+      for (let i = 0; i < line.length; i += maxLineLength) {
+        chunks.push(line.slice(i, i + maxLineLength));
+      }
+      return chunks.join("\n");
+    }).join("\n");
+  };
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: terminalWidth, height: terminalHeight }, /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      flexDirection: "column",
+      width: terminalWidth,
+      height: terminalHeight - 4,
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      overflow: "hidden"
+    },
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "\u{1F916} Gemini Agent Messages"), /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "\u2500".repeat(Math.min(terminalWidth - 4, 60)))),
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", height: terminalHeight - 10, overflow: "hidden" }, messages.length === 0 ? /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Waiting for messages...") : (
+      // Show only the last messages that fit in the available space
+      messages.slice(-Math.max(1, terminalHeight - 10)).map((msg) => /* @__PURE__ */ React.createElement(Box, { key: msg.id, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: getMessageColor(msg.type), dimColor: true }, formatMessage(msg))))
+    ))
+  ), /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      width: terminalWidth,
+      borderStyle: "round",
+      borderColor: actionInProgress ? "gray" : confirmationMode ? "red" : "green",
+      paddingX: 2,
+      justifyContent: "center",
+      alignItems: "center",
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", alignItems: "center" }, actionInProgress ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode ? /* @__PURE__ */ React.createElement(Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "\u{1F916} Gemini Agent Running \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+  ));
+};
+
+function emitReadyIfIdle({ pending, queueSize, shouldExit, sendReady, notify }) {
+  if (shouldExit) {
+    return false;
+  }
+  if (queueSize() > 0) {
+    return false;
+  }
+  sendReady();
+  notify?.();
+  return true;
+}
+async function runGemini(opts) {
+  const sessionTag = randomUUID$1();
+  const api = new ApiClient(opts.token, opts.secret);
+  logger.debug(`[gemini] Starting Gemini session`);
+  const settings = await readSettings();
+  let machineId = settings?.machineId;
+  if (!machineId) {
+    console.error(`[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Please report this issue.`);
+    process.exit(1);
+  }
+  logger.debug(`Using machineId: ${machineId}`);
+  await api.getOrCreateMachine({
+    machineId,
+    metadata: initialMachineMetadata
+  });
+  let state = {
+    controlledByUser: false
+  };
+  let metadata = {
+    path: process.cwd(),
+    host: os.hostname(),
+    version: packageJson.version,
+    os: os.platform(),
+    machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.happyHomeDir,
+    happyLibDir: projectPath(),
+    happyToolsDir: join$1(projectPath(), "tools", "unpacked"),
+    startedFromDaemon: false,
+    hostPid: process.pid,
+    startedBy: "terminal",
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: "gemini"
+  };
+  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  const session = api.sessionSyncClient(response);
+  const messageQueue = new MessageQueue2((mode) => hashObject({
+    permissionMode: mode.permissionMode,
+    model: mode.model
+  }));
+  let currentPermissionMode = void 0;
+  let currentModel = void 0;
+  session.onUserMessage((message) => {
+    let messagePermissionMode = currentPermissionMode;
+    if (message.meta?.permissionMode) {
+      const validModes = ["default", "read-only", "safe-yolo", "yolo"];
+      if (validModes.includes(message.meta.permissionMode)) {
+        messagePermissionMode = message.meta.permissionMode;
+        currentPermissionMode = messagePermissionMode;
+        logger.debug(`[Gemini] Permission mode updated: ${currentPermissionMode}`);
+      }
+    }
+    let messageModel = currentModel;
+    if (message.meta?.hasOwnProperty("model")) {
+      messageModel = message.meta.model || void 0;
+      currentModel = messageModel;
+      logger.debug(`[Gemini] Model updated: ${messageModel || "default"}`);
+    }
+    const enhancedMode = {
+      permissionMode: messagePermissionMode || "default",
+      model: messageModel
+    };
+    messageQueue.push(message.content.text, enhancedMode);
+  });
+  let thinking = false;
+  session.keepAlive(thinking, "remote");
+  const keepAliveInterval = setInterval(() => {
+    session.keepAlive(thinking, "remote");
+  }, 2e3);
+  const sendReady = () => {
+    session.sendSessionEvent({ type: "ready" });
+  };
+  let abortController = new AbortController();
+  let shouldExit = false;
+  async function handleAbort() {
+    logger.debug("[Gemini] Abort requested");
+    try {
+      abortController.abort();
+      messageQueue.reset();
+      permissionHandler.reset();
+      if (client.hasActiveSession()) {
+        client.abort();
+      }
+      logger.debug("[Gemini] Abort completed");
+    } catch (error) {
+      logger.debug("[Gemini] Error during abort:", error);
+    } finally {
+      abortController = new AbortController();
+    }
+  }
+  const handleKillSession = async () => {
+    logger.debug("[Gemini] Kill session requested");
+    await handleAbort();
+    try {
+      if (session) {
+        session.updateMetadata((currentMetadata) => ({
+          ...currentMetadata,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: "cli",
+          archiveReason: "User terminated"
+        }));
+        session.sendSessionDeath();
+        await session.flush();
+        await session.close();
+      }
+      chellServer.stop();
+      logger.debug("[Gemini] Session termination complete");
+      process.exit(0);
+    } catch (error) {
+      logger.debug("[Gemini] Error during termination:", error);
+      process.exit(1);
+    }
+  };
+  session.rpcHandlerManager.registerHandler("abort", handleAbort);
+  registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
+  const messageBuffer = new MessageBuffer();
+  const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  let inkInstance = null;
+  if (hasTTY) {
+    console.clear();
+    inkInstance = render(React.createElement(GeminiDisplay, {
+      messageBuffer,
+      logPath: process.env.DEBUG ? logger.getLogPath() : void 0,
+      onExit: async () => {
+        logger.debug("[gemini]: Exiting via Ctrl-C");
+        shouldExit = true;
+        await handleAbort();
+      }
+    }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
+  }
+  if (hasTTY) {
+    process.stdin.resume();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.setEncoding("utf8");
+    let inputBuffer = "";
+    process.stdin.on("data", (data) => {
+      for (let i = 0; i < data.length; i++) {
+        const char = data[i];
+        const code = data.charCodeAt(i);
+        if (code === 3) continue;
+        if (code === 127 || code === 8) {
+          if (inputBuffer.length > 0) {
+            inputBuffer = inputBuffer.slice(0, -1);
+          }
+          continue;
+        }
+        if (char === "\r" || char === "\n") {
+          const trimmed = inputBuffer.trim();
+          if (trimmed) {
+            const enhancedMode = {
+              permissionMode: currentPermissionMode || "default",
+              model: currentModel
+            };
+            messageQueue.push(trimmed, enhancedMode);
+            messageBuffer.addMessage(trimmed, "user");
+            logger.debug(`[Gemini] Local input: ${trimmed}`);
+            try {
+              session.sendClaudeSessionMessage({
+                type: "user",
+                uuid: randomUUID$1(),
+                message: {
+                  content: [{ type: "text", text: trimmed }]
+                }
+              });
+            } catch (e) {
+              logger.debug("[Gemini] Failed to mirror input:", e);
+            }
+          }
+          inputBuffer = "";
+          continue;
+        }
+        if (code >= 32 && code < 127) {
+          inputBuffer += char;
+        }
+      }
+    });
+  }
+  const client = new GeminiClient();
+  const permissionHandler = new GeminiPermissionHandler(session);
+  const chellServer = await startChellServer(session);
+  const bridgeCommand = join$1(projectPath(), "bin", "chell-mcp.mjs");
+  client.setHandler((event) => {
+    logger.debug(`[Gemini] Event: ${event.type}`);
+    updateActivityTimestamp();
+    if (event.type === "message") {
+      messageBuffer.addMessage(event.content, event.role);
+    } else if (event.type === "tool_use") {
+      messageBuffer.addMessage(`Using tool: ${event.toolName}`, "tool");
+    } else if (event.type === "tool_result") {
+      const output = event.output ? JSON.stringify(event.output).substring(0, 200) : "Done";
+      messageBuffer.addMessage(`Result: ${output}`, "result");
+    } else if (event.type === "error") {
+      messageBuffer.addMessage(`Error: ${event.message}`, "status");
+    } else if (event.type === "task_started") {
+      messageBuffer.addMessage("Task started", "status");
+      if (!thinking) {
+        thinking = true;
+        session.keepAlive(thinking, "remote");
+      }
+    } else if (event.type === "task_complete") {
+      messageBuffer.addMessage("Task completed", "status");
+      if (thinking) {
+        thinking = false;
+        session.keepAlive(thinking, "remote");
+      }
+      sendReady();
+    }
+    if (event.type === "message") {
+      session.sendCodexMessage({
+        type: "message",
+        message: event.content,
+        id: randomUUID$1()
+      });
+      try {
+        session.sendClaudeSessionMessage({
+          type: "assistant",
+          uuid: randomUUID$1(),
+          message: {
+            content: [{ type: "text", text: event.content }]
+          }
+        });
+      } catch (e) {
+        logger.debug("[Gemini] Failed to mirror message:", e);
+      }
+    }
+  });
+  try {
+    let sessionStarted = false;
+    while (!shouldExit) {
+      const waitSignal = abortController.signal;
+      const batch = await messageQueue.waitForMessagesAndGetAsString(waitSignal);
+      if (!batch) {
+        if (waitSignal.aborted && !shouldExit) {
+          logger.debug("[gemini]: Wait aborted while idle");
+          continue;
+        }
+        break;
+      }
+      messageBuffer.addMessage(batch.message, "user");
+      try {
+        if (!sessionStarted) {
+          const config = {
+            model: batch.mode.model || "gemini-2.5-flash",
+            yolo: batch.mode.permissionMode === "yolo",
+            debug: !!process.env.DEBUG
+          };
+          await client.startSession(
+            config,
+            chellServer.url,
+            bridgeCommand,
+            { signal: abortController.signal }
+          );
+          sessionStarted = true;
+        }
+        await client.sendMessage(batch.message);
+      } catch (error) {
+        logger.warn("Error in gemini session:", error);
+        const isAbortError = error instanceof Error && error.name === "AbortError";
+        if (isAbortError) {
+          messageBuffer.addMessage("Aborted by user", "status");
+          session.sendSessionEvent({ type: "message", message: "Aborted by user" });
+        } else {
+          messageBuffer.addMessage("Process exited unexpectedly", "status");
+          session.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+        }
+      } finally {
+        permissionHandler.reset();
+        thinking = false;
+        session.keepAlive(thinking, "remote");
+        emitReadyIfIdle({
+          pending: null,
+          queueSize: () => messageQueue.size(),
+          shouldExit,
+          sendReady
+        });
+      }
+    }
+  } finally {
+    logger.debug("[gemini]: Final cleanup");
+    try {
+      session.sendSessionDeath();
+      await session.flush();
+      await session.close();
+    } catch (e) {
+      logger.debug("[gemini]: Error closing session", e);
+    }
+    await client.disconnect();
+    chellServer.stop();
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
+    }
+    if (hasTTY) {
+      try {
+        process.stdin.pause();
+      } catch {
+      }
+    }
+    clearInterval(keepAliveInterval);
+    if (inkInstance) {
+      inkInstance.unmount();
+    }
+    messageBuffer.clear();
+    logger.debug("[gemini]: Final cleanup completed");
+  }
+}
+
+export { emitReadyIfIdle, runGemini };