@bytespell/amux 0.0.4 → 0.0.7

package/dist/chunk-HJCRMFTD.js

@@ -0,0 +1,771 @@
+import {
+  debug,
+  warn
+} from "./chunk-5IPYOXBE.js";
+import {
+  parseMessageToContentBlocks
+} from "./chunk-C73RKCTS.js";
+
+// src/streams/backends/acp.ts
+import { randomUUID } from "crypto";
+import { spawn as nodeSpawn } from "child_process";
+import { Readable, Writable } from "stream";
+import * as fs from "fs/promises";
+import * as fsSync from "fs";
+import * as path from "path";
+import {
+  ClientSideConnection,
+  ndJsonStream
+} from "@agentclientprotocol/sdk";
+
+// src/streams/process.ts
+import { execa } from "execa";
+import treeKill from "tree-kill";
+function spawn(options) {
+  const { command, args = [], cwd, env, timeoutMs } = options;
+  const subprocess = execa(command, args, {
+    cwd,
+    env: { ...process.env, ...env },
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+    timeout: timeoutMs,
+    cleanup: true,
+    // Kill on parent exit
+    windowsHide: true
+    // Hide console window on Windows
+  });
+  const pid = subprocess.pid;
+  if (!pid) {
+    throw new Error(`Failed to spawn process: ${command}`);
+  }
+  return {
+    pid,
+    stdin: subprocess.stdin,
+    stdout: subprocess.stdout,
+    stderr: subprocess.stderr,
+    kill: (signal = "SIGTERM") => killTree(pid, signal),
+    wait: async () => {
+      try {
+        const result = await subprocess;
+        return { exitCode: result.exitCode };
+      } catch (err) {
+        return { exitCode: err.exitCode ?? 1 };
+      }
+    }
+  };
+}
+function killTree(pid, signal) {
+  return new Promise((resolve) => {
+    treeKill(pid, signal, (err) => {
+      if (err && !err.message.includes("No such process")) {
+        console.error(`[process] kill error pid=${pid}:`, err.message);
+      }
+      resolve();
+    });
+  });
+}
+
+// src/streams/backends/acp.ts
+var INIT_TIMEOUT_MS = 9e4;
+function normalizeSessionUpdate(update) {
+  if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") {
+    return update;
+  }
+  const content = update.content;
+  if (!content || !Array.isArray(content)) {
+    return update;
+  }
+  const normalizedContent = content.map((item) => {
+    if (item.type !== "diff") return item;
+    if (typeof item.content === "string") return item;
+    const newText = item.newText;
+    const oldText = item.oldText;
+    const path3 = item.path;
+    if (newText === void 0) return item;
+    const filePath = path3 ?? "file";
+    const oldLines = oldText ? oldText.split("\n") : [];
+    const newLines = newText.split("\n");
+    let unifiedDiff = `Index: ${filePath}
+`;
+    unifiedDiff += "===================================================================\n";
+    unifiedDiff += `--- ${filePath}
+`;
+    unifiedDiff += `+++ ${filePath}
+`;
+    unifiedDiff += `@@ -${oldLines.length > 0 ? 1 : 0},${oldLines.length} +1,${newLines.length} @@
+`;
+    for (const line of oldLines) {
+      unifiedDiff += `-${line}
+`;
+    }
+    for (const line of newLines) {
+      unifiedDiff += `+${line}
+`;
+    }
+    return {
+      type: "diff",
+      content: unifiedDiff
+    };
+  });
+  return {
+    ...update,
+    content: normalizedContent
+  };
+}
+function withTimeout(promise, ms, operation) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms)
+    )
+  ]);
+}
+var AcpDriver = class {
+  type = "acp";
+  streamType = "acp";
+  instances = /* @__PURE__ */ new Map();
+  getHistoryPath(storageDir) {
+    return path.join(storageDir, "history.json");
+  }
+  storeEvent(storageDir, update) {
+    const isSessionUpdate = typeof update === "object" && update !== null && "sessionUpdate" in update;
+    const isAmuxEvent = typeof update === "object" && update !== null && "amuxEvent" in update;
+    const isTurnMarker = isAmuxEvent && (update.amuxEvent === "turn_start" || update.amuxEvent === "turn_end");
+    if (!isSessionUpdate && !isTurnMarker) {
+      return;
+    }
+    if (!fsSync.existsSync(storageDir)) {
+      fsSync.mkdirSync(storageDir, { recursive: true });
+    }
+    const historyPath = this.getHistoryPath(storageDir);
+    let events = [];
+    try {
+      if (fsSync.existsSync(historyPath)) {
+        const data = fsSync.readFileSync(historyPath, "utf-8");
+        events = JSON.parse(data);
+      }
+    } catch {
+      events = [];
+    }
+    events.push(update);
+    fsSync.writeFileSync(historyPath, JSON.stringify(events));
+  }
+  async start(streamId, config, cwd, backendState, emit, storageDir) {
+    const existingState = backendState;
+    const existingAcpSessionId = existingState?.acpSessionId ?? null;
+    if (this.instances.has(streamId)) {
+      await this.stop(streamId);
+    }
+    const args = config.args ?? [];
+    const env = config.env ?? {};
+    debug("acp", ` Spawning: ${config.command} ${args.join(" ")} in ${cwd}`);
+    const proc = spawn({
+      command: config.command,
+      args,
+      cwd,
+      env
+    });
+    proc.stderr.on("data", (data) => {
+      debug("acp", `[stderr] ${data.toString().trim()}`);
+    });
+    const storingEmit = (update) => {
+      this.storeEvent(storageDir, update);
+      emit(update);
+    };
+    const instance = {
+      process: proc,
+      connection: null,
+      acpSessionId: "",
+      pendingPermission: null,
+      permissionCallbacks: /* @__PURE__ */ new Map(),
+      emit: storingEmit,
+      terminals: /* @__PURE__ */ new Map(),
+      storageDir
+    };
+    proc.wait().then(({ exitCode }) => {
+      if (this.instances.has(streamId)) {
+        emit({ amuxEvent: "error", message: `Agent process exited with code ${exitCode}` });
+        this.instances.delete(streamId);
+      }
+    });
+    try {
+      const input = Writable.toWeb(proc.stdin);
+      const output = Readable.toWeb(proc.stdout);
+      const stream = ndJsonStream(input, output);
+      const client = this.createClient(streamId, instance);
+      instance.connection = new ClientSideConnection(() => client, stream);
+      const initResult = await withTimeout(
+        instance.connection.initialize({
+          protocolVersion: 1,
+          clientCapabilities: {
+            fs: { readTextFile: true, writeTextFile: true },
+            terminal: true
+          }
+        }),
+        INIT_TIMEOUT_MS,
+        "Agent initialization"
+      );
+      debug("acp", ` Initialized agent: ${initResult.agentInfo?.name} v${initResult.agentInfo?.version}`);
+      const canResume = initResult.agentCapabilities?.sessionCapabilities?.resume !== void 0;
+      let acpSessionId;
+      let sessionResult;
+      if (existingAcpSessionId && canResume) {
+        let resumeSucceeded = false;
+        try {
+          debug("acp", ` Resuming ACP session ${existingAcpSessionId}...`);
+          sessionResult = await withTimeout(
+            instance.connection.unstable_resumeSession({
+              sessionId: existingAcpSessionId,
+              cwd,
+              mcpServers: []
+            }),
+            INIT_TIMEOUT_MS,
+            "Session resume"
+          );
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          acpSessionId = existingAcpSessionId;
+          debug("acp", ` ACP session resumed successfully`);
+          resumeSucceeded = true;
+        } catch (resumeErr) {
+          debug("acp", ` Resume failed, creating new session: ${resumeErr}`);
+        }
+        if (!resumeSucceeded) {
+          sessionResult = await withTimeout(
+            instance.connection.newSession({ cwd, mcpServers: [] }),
+            INIT_TIMEOUT_MS,
+            "New session creation"
+          );
+          acpSessionId = sessionResult.sessionId;
+          debug("acp", ` New ACP session created: ${acpSessionId}`);
+        }
+      } else {
+        debug("acp", ` Creating new ACP session in ${cwd}...`);
+        sessionResult = await withTimeout(
+          instance.connection.newSession({ cwd, mcpServers: [] }),
+          INIT_TIMEOUT_MS,
+          "New session creation"
+        );
+        acpSessionId = sessionResult.sessionId;
+        debug("acp", ` ACP session created: ${acpSessionId}`);
+      }
+      instance.acpSessionId = acpSessionId;
+      this.instances.set(streamId, instance);
+      const models = sessionResult?.models?.availableModels;
+      const modes = sessionResult?.modes?.availableModes;
+      if (sessionResult?.modes) {
+        emit({
+          sessionUpdate: "current_mode_update",
+          currentModeId: sessionResult.modes.currentModeId
+        });
+      }
+      return {
+        acpSessionId,
+        models,
+        modes
+      };
+    } catch (err) {
+      console.error(`[acp] Error starting agent for stream ${streamId}:`, err);
+      await proc.kill();
+      throw err;
+    }
+  }
+  createClient(_streamId, instance) {
+    return {
+      async requestPermission(params) {
+        const requestId = randomUUID();
+        const permission = {
+          requestId,
+          toolCallId: params.toolCall.toolCallId,
+          title: params.toolCall.title ?? "Permission Required",
+          options: params.options.map((o) => ({
+            optionId: o.optionId,
+            name: o.name,
+            kind: o.kind
+          }))
+        };
+        instance.pendingPermission = permission;
+        instance.emit({ amuxEvent: "permission_request", permission });
+        return new Promise((resolve, reject) => {
+          instance.permissionCallbacks.set(requestId, {
+            resolve: (optionId) => {
+              instance.pendingPermission = null;
+              instance.emit({ amuxEvent: "permission_cleared" });
+              resolve({ outcome: { outcome: "selected", optionId } });
+            },
+            reject
+          });
+        });
+      },
+      async sessionUpdate(params) {
+        debug("acp", ` sessionUpdate received: ${JSON.stringify(params)}`);
+        const normalized = normalizeSessionUpdate(params.update);
+        instance.emit(normalized);
+      },
+      async readTextFile(params) {
+        const content = await fs.readFile(params.path, "utf-8");
+        return { content };
+      },
+      async writeTextFile(params) {
+        await fs.writeFile(params.path, params.content);
+        return {};
+      },
+      async createTerminal(params) {
+        debug("acp", ` createTerminal request: ${JSON.stringify(params)}`);
+        const terminalId = randomUUID();
+        const outputByteLimit = params.outputByteLimit ?? 1024 * 1024;
+        const termProc = nodeSpawn(params.command, params.args ?? [], {
+          cwd: params.cwd ?? void 0,
+          env: params.env ? { ...process.env, ...Object.fromEntries(params.env.map((e) => [e.name, e.value])) } : process.env,
+          shell: true,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        const terminal = {
+          process: termProc,
+          output: "",
+          exitCode: null,
+          signal: null,
+          truncated: false,
+          outputByteLimit
+        };
+        const appendOutput = (data) => {
+          terminal.output += data.toString();
+          if (terminal.output.length > terminal.outputByteLimit) {
+            terminal.output = terminal.output.slice(-terminal.outputByteLimit);
+            terminal.truncated = true;
+          }
+        };
+        termProc.stdout?.on("data", appendOutput);
+        termProc.stderr?.on("data", appendOutput);
+        termProc.on("exit", (code, signal) => {
+          debug("acp", ` Terminal ${terminalId} exited with code ${code}, signal ${signal}`);
+          terminal.exitCode = code ?? null;
+          terminal.signal = signal ?? null;
+        });
+        termProc.on("error", (err) => {
+          console.error(`[acp] Terminal ${terminalId} error:`, err.message);
+          terminal.output += `
+Error: ${err.message}`;
+          terminal.exitCode = -1;
+        });
+        instance.terminals.set(terminalId, terminal);
+        debug("acp", ` Created terminal ${terminalId} for command: ${params.command}`);
+        return { terminalId };
+      },
+      async terminalOutput(params) {
+        debug("acp", ` terminalOutput request for terminal ${params.terminalId}`);
+        const terminal = instance.terminals.get(params.terminalId);
+        if (!terminal) {
+          throw new Error(`Terminal ${params.terminalId} not found`);
+        }
+        return {
+          output: terminal.output,
+          truncated: terminal.truncated,
+          exitStatus: terminal.exitCode !== null || terminal.signal !== null ? {
+            exitCode: terminal.exitCode,
+            signal: terminal.signal
+          } : void 0
+        };
+      },
+      async waitForTerminalExit(params) {
+        debug("acp", ` waitForTerminalExit request for terminal ${params.terminalId}`);
+        const terminal = instance.terminals.get(params.terminalId);
+        if (!terminal) {
+          throw new Error(`Terminal ${params.terminalId} not found`);
+        }
+        if (terminal.exitCode !== null || terminal.signal !== null) {
+          return {
+            exitCode: terminal.exitCode,
+            signal: terminal.signal
+          };
+        }
+        return new Promise((resolve) => {
+          terminal.process.on("exit", (code, signal) => {
+            resolve({
+              exitCode: code ?? null,
+              signal: signal ?? null
+            });
+          });
+        });
+      },
+      // Note: killTerminalCommand not in SDK Client interface yet, but we implement handlers
+      // for completeness when the SDK adds support
+      async killTerminal(params) {
+        debug("acp", ` killTerminal request for terminal ${params.terminalId}`);
+        const terminal = instance.terminals.get(params.terminalId);
+        if (!terminal) {
+          throw new Error(`Terminal ${params.terminalId} not found`);
+        }
+        terminal.process.kill("SIGTERM");
+        return {};
+      },
+      async releaseTerminal(params) {
+        debug("acp", ` releaseTerminal request for terminal ${params.terminalId}`);
+        const terminal = instance.terminals.get(params.terminalId);
+        if (terminal) {
+          if (terminal.exitCode === null) {
+            terminal.process.kill("SIGKILL");
+          }
+          instance.terminals.delete(params.terminalId);
+        }
+        return {};
+      }
+    };
+  }
+  async input(streamId, raw, cwd, _emit) {
+    const instance = this.instances.get(streamId);
+    if (!instance) throw new Error(`No ACP instance for stream ${streamId}`);
+    this.storeEvent(instance.storageDir, {
+      sessionUpdate: "user_message_chunk",
+      content: { type: "text", text: raw }
+    });
+    const content = parseMessageToContentBlocks(raw, cwd);
+    debug("acp", ` Sending input to session ${instance.acpSessionId} with ${content.length} content block(s)...`);
+    const result = await instance.connection.prompt({
+      sessionId: instance.acpSessionId,
+      prompt: content
+    });
+    debug("acp", ` Input complete, stopReason: ${result.stopReason}`);
+  }
+  async stop(streamId) {
+    const instance = this.instances.get(streamId);
+    if (!instance) return;
+    for (const [, callback] of instance.permissionCallbacks) {
+      callback.reject(new Error("Agent stopped"));
+    }
+    instance.permissionCallbacks.clear();
+    instance.pendingPermission = null;
+    this.instances.delete(streamId);
+    await instance.process.kill();
+  }
+  async stopAll() {
+    const streamIds = [...this.instances.keys()];
+    await Promise.all(streamIds.map((id) => this.stop(id)));
+  }
+  isRunning(streamId) {
+    return this.instances.has(streamId);
+  }
+  /** Get backend state for persistence (ACP session ID for resumption) */
+  getState(streamId) {
+    const instance = this.instances.get(streamId);
+    if (!instance) return void 0;
+    return { acpSessionId: instance.acpSessionId };
+  }
+  /** Get stored events for replay on reconnect */
+  getReplayData(streamId) {
+    const instance = this.instances.get(streamId);
+    if (!instance) return void 0;
+    const historyPath = this.getHistoryPath(instance.storageDir);
+    try {
+      if (fsSync.existsSync(historyPath)) {
+        const data = fsSync.readFileSync(historyPath, "utf-8");
+        return JSON.parse(data);
+      }
+    } catch {
+    }
+    return [];
+  }
+  /** Clear stored events for a stream */
+  clearHistory(streamId) {
+    const instance = this.instances.get(streamId);
+    if (!instance) return;
+    const historyPath = this.getHistoryPath(instance.storageDir);
+    try {
+      if (fsSync.existsSync(historyPath)) {
+        fsSync.unlinkSync(historyPath);
+      }
+    } catch {
+    }
+  }
+  respondToPermission(streamId, requestId, optionId) {
+    const instance = this.instances.get(streamId);
+    const callback = instance?.permissionCallbacks.get(requestId);
+    if (!callback) {
+      throw new Error(`No pending permission request ${requestId}`);
+    }
+    callback.resolve(optionId);
+    instance.permissionCallbacks.delete(requestId);
+  }
+  getPendingPermission(streamId) {
+    const instance = this.instances.get(streamId);
+    return instance?.pendingPermission ?? null;
+  }
+  async cancel(streamId) {
+    const instance = this.instances.get(streamId);
+    if (!instance) return;
+    await instance.connection.cancel({ sessionId: instance.acpSessionId });
+  }
+  async setMode(streamId, modeId) {
+    const instance = this.instances.get(streamId);
+    if (!instance) throw new Error(`No ACP instance for stream ${streamId}`);
+    await instance.connection.setSessionMode({
+      sessionId: instance.acpSessionId,
+      modeId
+    });
+  }
+  async setModel(streamId, modelId) {
+    const instance = this.instances.get(streamId);
+    if (!instance) throw new Error(`No ACP instance for stream ${streamId}`);
+    await instance.connection.unstable_setSessionModel({
+      sessionId: instance.acpSessionId,
+      modelId
+    });
+  }
+};
+
+// src/streams/backends/mock.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var MockDriver = class {
+  type = "mock";
+  streamType = "acp";
+  running = /* @__PURE__ */ new Set();
+  async start(streamId, _config, _cwd, _backendState, emit, _storageDir) {
+    debug("mock", ` Starting mock agent for stream ${streamId}`);
+    emit({
+      sessionUpdate: "current_mode_update",
+      currentModeId: "mock"
+    });
+    debug("mock", ` Mock agent ready for stream ${streamId}`);
+    this.running.add(streamId);
+    return {
+      acpSessionId: randomUUID2(),
+      models: [{ modelId: "mock-model", name: "Mock Model" }],
+      modes: [{ id: "mock", name: "Mock Mode" }]
+    };
+  }
+  async input(streamId, raw, _cwd, emit) {
+    debug("mock", ` Mock input for stream ${streamId}: "${raw.slice(0, 50)}..."`);
+    const words = [
+      "This",
+      "is",
+      "a",
+      "mock",
+      "response",
+      "from",
+      "the",
+      "mock",
+      "agent.",
+      "It",
+      "simulates",
+      "streaming",
+      "text",
+      "chunks",
+      "for",
+      "performance",
+      "testing.",
+      "The",
+      "response",
+      "arrives",
+      "in",
+      "small",
+      "pieces",
+      "to",
+      "test",
+      "UI",
+      "rendering."
+    ];
+    for (let i = 0; i < words.length; i += 3) {
+      const chunk = words.slice(i, i + 3).join(" ") + " ";
+      emit({
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: chunk }
+      });
+      await delay(50);
+    }
+  }
+  async stop(streamId) {
+    debug("mock", ` Stopping mock agent for stream ${streamId}`);
+    this.running.delete(streamId);
+  }
+  async stopAll() {
+    const streamIds = [...this.running];
+    await Promise.all(streamIds.map((id) => this.stop(id)));
+  }
+  isRunning(streamId) {
+    return this.running.has(streamId);
+  }
+};
+
+// src/streams/backends/shell.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var pty = null;
+async function getPty() {
+  if (!pty) {
+    pty = await import("node-pty");
+  }
+  return pty;
+}
+var MAX_SCROLLBACK = 1e5;
+var SAVE_DEBOUNCE_MS = 1e3;
+var PtyDriver = class {
+  type = "pty";
+  streamType = "pty";
+  isInteractive = true;
+  instances = /* @__PURE__ */ new Map();
+  getScrollbackPath(storageDir) {
+    return path2.join(storageDir, "scrollback.txt");
+  }
+  saveScrollback(instance) {
+    if (!fs2.existsSync(instance.storageDir)) {
+      fs2.mkdirSync(instance.storageDir, { recursive: true });
+    }
+    fs2.writeFileSync(this.getScrollbackPath(instance.storageDir), instance.scrollback);
+  }
+  loadScrollback(storageDir) {
+    const scrollbackPath = this.getScrollbackPath(storageDir);
+    try {
+      if (fs2.existsSync(scrollbackPath)) {
+        return fs2.readFileSync(scrollbackPath, "utf-8");
+      }
+    } catch {
+    }
+    return "";
+  }
+  debouncedSave(instance) {
+    if (instance.saveTimeout) {
+      clearTimeout(instance.saveTimeout);
+    }
+    instance.saveTimeout = setTimeout(() => {
+      this.saveScrollback(instance);
+      instance.saveTimeout = null;
+    }, SAVE_DEBOUNCE_MS);
+  }
+  async start(streamId, _config, cwd, _backendState, emit, storageDir) {
+    const existing = this.instances.get(streamId);
+    if (existing) {
+      debug("shell", `Stream ${streamId} already running, reusing`);
+      existing.emit = emit;
+      return {};
+    }
+    const restoredScrollback = this.loadScrollback(storageDir);
+    if (restoredScrollback) {
+      debug("shell", `Restored ${restoredScrollback.length} bytes of scrollback for ${streamId}`);
+    }
+    const nodePty = await getPty();
+    const shell = process.env.SHELL || "/bin/bash";
+    debug("shell", `Spawning ${shell} in ${cwd}`);
+    let p;
+    try {
+      p = nodePty.spawn(shell, [], {
+        name: "xterm-256color",
+        cols: 80,
+        rows: 24,
+        cwd,
+        env: process.env
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("posix_spawnp failed") && process.platform === "darwin") {
+        throw new Error(
+          `Failed to spawn shell on macOS: ${message}. This may be caused by macOS quarantine. Try: 1) Install globally: npm install -g @bytespell/shella && shella, or 2) Clear quarantine: xattr -dr com.apple.quarantine ~/.npm/_npx`
+        );
+      }
+      throw error;
+    }
+    const instance = {
+      pty: p,
+      scrollback: restoredScrollback,
+      cwd,
+      emit,
+      storageDir,
+      saveTimeout: null
+    };
+    p.onData((data) => {
+      instance.scrollback += data;
+      if (instance.scrollback.length > MAX_SCROLLBACK) {
+        instance.scrollback = instance.scrollback.slice(-MAX_SCROLLBACK);
+      }
+      this.debouncedSave(instance);
+      instance.emit({ amuxEvent: "terminal_output", data });
+    });
+    p.onExit(({ exitCode, signal }) => {
+      debug("shell", `PTY exited: code=${exitCode}, signal=${signal}`);
+      if (instance.saveTimeout) {
+        clearTimeout(instance.saveTimeout);
+      }
+      this.saveScrollback(instance);
+      instance.emit({
+        amuxEvent: "terminal_exit",
+        exitCode: exitCode ?? null,
+        signal: signal !== void 0 ? String(signal) : null
+      });
+      this.instances.delete(streamId);
+    });
+    this.instances.set(streamId, instance);
+    debug("shell", `Stream ${streamId} started`);
+    return {};
+  }
+  /**
+   * Get accumulated scrollback for replay on reconnect.
+   */
+  getScrollback(streamId) {
+    return this.instances.get(streamId)?.scrollback;
+  }
+  /**
+   * Get replay data (scrollback) for reconnecting clients.
+   */
+  getReplayData(streamId) {
+    return this.getScrollback(streamId);
+  }
+  /**
+   * Write raw input to terminal (keystrokes from client).
+   */
+  terminalWrite(streamId, data) {
+    const instance = this.instances.get(streamId);
+    if (!instance) {
+      warn("shell", `terminalWrite: stream ${streamId} not found`);
+      return;
+    }
+    instance.pty.write(data);
+  }
+  /**
+   * Resize terminal dimensions.
+   */
+  terminalResize(streamId, cols, rows) {
+    const instance = this.instances.get(streamId);
+    if (!instance) {
+      warn("shell", `terminalResize: stream ${streamId} not found`);
+      return;
+    }
+    instance.pty.resize(cols, rows);
+  }
+  /**
+   * Handle user input - writes raw text to terminal.
+   */
+  async input(streamId, raw, _cwd, _emit) {
+    if (raw) {
+      this.terminalWrite(streamId, raw);
+    }
+  }
+  async stop(streamId) {
+    const instance = this.instances.get(streamId);
+    if (!instance) return;
+    debug("shell", `Stopping stream ${streamId}`);
+    if (instance.saveTimeout) {
+      clearTimeout(instance.saveTimeout);
+    }
+    this.saveScrollback(instance);
+    instance.pty.kill();
+    this.instances.delete(streamId);
+  }
+  async stopAll() {
+    debug("shell", `Stopping all streams (${this.instances.size})`);
+    for (const streamId of this.instances.keys()) {
+      await this.stop(streamId);
+    }
+  }
+  isRunning(streamId) {
+    return this.instances.has(streamId);
+  }
+};
+
+export {
+  AcpDriver,
+  MockDriver,
+  PtyDriver
+};
+//# sourceMappingURL=chunk-HJCRMFTD.js.map