@bytespell/amux 0.0.1 → 0.0.2

package/dist/chunk-RSLSN7F2.js

@@ -0,0 +1,1591 @@
+import {
+  endTurn,
+  getEventsForSession,
+  startTurn,
+  storeEvent
+} from "./chunk-SX7NC3ZM.js";
+import {
+  isSessionUpdate
+} from "./chunk-226DBKL3.js";
+import {
+  debug,
+  warn
+} from "./chunk-5IPYOXBE.js";
+import {
+  agentConfigs,
+  db,
+  sessions
+} from "./chunk-OQ5K5ON2.js";
+
+// src/agents/manager.ts
+import { EventEmitter } from "events";
+import { eq } from "drizzle-orm";
+
+// src/agents/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 {
+  ClientSideConnection,
+  ndJsonStream
+} from "@agentclientprotocol/sdk";
+
+// src/agents/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/agents/backends/acp.ts
+var INIT_TIMEOUT_MS = 3e4;
+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 path2 = item.path;
+    if (newText === void 0) return item;
+    const filePath = path2 ?? "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 AcpBackend = class {
+  type = "acp";
+  instances = /* @__PURE__ */ new Map();
+  onSessionIdChanged;
+  matches(config2) {
+    return config2.command !== "__mock__" && config2.command !== "__stress__" && config2.command !== "__shell__";
+  }
+  async start(sessionId, config2, cwd, existingAcpSessionId, emit) {
+    if (this.instances.has(sessionId)) {
+      await this.stop(sessionId);
+    }
+    const args = config2.args ?? [];
+    const env = config2.env ?? {};
+    debug("acp", ` Spawning: ${config2.command} ${args.join(" ")} in ${cwd}`);
+    const proc = spawn({
+      command: config2.command,
+      args,
+      cwd,
+      env
+    });
+    const instance = {
+      process: proc,
+      connection: null,
+      sessionId: "",
+      pendingPermission: null,
+      permissionCallbacks: /* @__PURE__ */ new Map(),
+      emit,
+      terminals: /* @__PURE__ */ new Map()
+    };
+    proc.wait().then(({ exitCode }) => {
+      if (this.instances.has(sessionId)) {
+        emit({ amuxEvent: "error", message: `Agent process exited with code ${exitCode}` });
+        this.instances.delete(sessionId);
+      }
+    });
+    try {
+      const input = Writable.toWeb(proc.stdin);
+      const output = Readable.toWeb(proc.stdout);
+      const stream = ndJsonStream(input, output);
+      const client = this.createClient(sessionId, 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}`);
+          this.onSessionIdChanged?.(sessionId, 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}`);
+        this.onSessionIdChanged?.(sessionId, acpSessionId);
+      }
+      instance.sessionId = acpSessionId;
+      this.instances.set(sessionId, instance);
+      const models = sessionResult?.models?.availableModels;
+      const modes = sessionResult?.modes?.availableModes;
+      if (sessionResult?.modes) {
+        emit({
+          sessionUpdate: "current_mode_update",
+          currentModeId: sessionResult.modes.currentModeId
+        });
+      }
+      return {
+        sessionId: acpSessionId,
+        models,
+        modes
+      };
+    } catch (err) {
+      console.error(`[acp] Error starting agent for session ${sessionId}:`, err);
+      await proc.kill();
+      throw err;
+    }
+  }
+  createClient(_sessionId, 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 prompt(sessionId, content, _emit) {
+    const instance = this.instances.get(sessionId);
+    if (!instance) throw new Error(`No ACP instance for window ${sessionId}`);
+    debug("acp", ` Sending prompt to session ${instance.sessionId} with ${content.length} content block(s)...`);
+    const result = await instance.connection.prompt({
+      sessionId: instance.sessionId,
+      prompt: content
+    });
+    debug("acp", ` Prompt complete, stopReason: ${result.stopReason}`);
+  }
+  async stop(sessionId) {
+    const instance = this.instances.get(sessionId);
+    if (!instance) return;
+    for (const [, callback] of instance.permissionCallbacks) {
+      callback.reject(new Error("Agent stopped"));
+    }
+    instance.permissionCallbacks.clear();
+    instance.pendingPermission = null;
+    this.instances.delete(sessionId);
+    await instance.process.kill();
+  }
+  async stopAll() {
+    const sessionIds = [...this.instances.keys()];
+    await Promise.all(sessionIds.map((id) => this.stop(id)));
+  }
+  isRunning(sessionId) {
+    return this.instances.has(sessionId);
+  }
+  respondToPermission(sessionId, requestId, optionId) {
+    const instance = this.instances.get(sessionId);
+    const callback = instance?.permissionCallbacks.get(requestId);
+    if (!callback) {
+      throw new Error(`No pending permission request ${requestId}`);
+    }
+    callback.resolve(optionId);
+    instance.permissionCallbacks.delete(requestId);
+  }
+  getPendingPermission(sessionId) {
+    const instance = this.instances.get(sessionId);
+    return instance?.pendingPermission ?? null;
+  }
+  async cancel(sessionId) {
+    const instance = this.instances.get(sessionId);
+    if (!instance) return;
+    await instance.connection.cancel({ sessionId: instance.sessionId });
+  }
+  async setMode(sessionId, modeId) {
+    const instance = this.instances.get(sessionId);
+    if (!instance) throw new Error(`No ACP instance for window ${sessionId}`);
+    await instance.connection.setSessionMode({
+      sessionId: instance.sessionId,
+      modeId
+    });
+  }
+  async setModel(sessionId, modelId) {
+    const instance = this.instances.get(sessionId);
+    if (!instance) throw new Error(`No ACP instance for window ${sessionId}`);
+    await instance.connection.unstable_setSessionModel({
+      sessionId: instance.sessionId,
+      modelId
+    });
+  }
+};
+
+// src/agents/backends/mock.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var MockBackend = class {
+  type = "mock";
+  running = /* @__PURE__ */ new Set();
+  matches(config2) {
+    return config2.command === "__mock__";
+  }
+  async start(sessionId, _config, _cwd, _existingAcpSessionId, emit) {
+    debug("mock", ` Starting mock agent for session ${sessionId}`);
+    emit({
+      sessionUpdate: "current_mode_update",
+      currentModeId: "mock"
+    });
+    debug("mock", ` Mock agent ready for session ${sessionId}`);
+    this.running.add(sessionId);
+    return {
+      sessionId: randomUUID2(),
+      models: [{ modelId: "mock-model", name: "Mock Model" }],
+      modes: [{ id: "mock", name: "Mock Mode" }]
+    };
+  }
+  async prompt(sessionId, content, emit) {
+    const text = content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    debug("mock", ` Mock prompt for session ${sessionId}: "${text.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(sessionId) {
+    debug("mock", ` Stopping mock agent for session ${sessionId}`);
+    this.running.delete(sessionId);
+  }
+  async stopAll() {
+    const sessionIds = [...this.running];
+    await Promise.all(sessionIds.map((id) => this.stop(id)));
+  }
+  isRunning(sessionId) {
+    return this.running.has(sessionId);
+  }
+};
+
+// src/agents/backends/stress.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/stress/generators.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var DEFAULT_STRESS_CONFIG = {
+  eventsPerTurn: 50,
+  toolCallProbability: 0.4,
+  thoughtProbability: 0.6,
+  planProbability: 0.3,
+  chunkSize: 50,
+  delayMs: 0
+};
+var MARKDOWN_SAMPLES = [
+  // Sample 1: Code block with TypeScript
+  `Here's a React component that handles user authentication:
+
+\`\`\`typescript
+import { useState, useEffect } from 'react';
+import { useAuth } from '@/hooks/useAuth';
+
+interface AuthProviderProps {
+  children: React.ReactNode;
+}
+
+export function AuthProvider({ children }: AuthProviderProps) {
+  const [isLoading, setIsLoading] = useState(true);
+  const { user, login, logout } = useAuth();
+
+  useEffect(() => {
+    // Check for existing session
+    const checkSession = async () => {
+      try {
+        await validateToken();
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    checkSession();
+  }, []);
+
+  if (isLoading) {
+    return <LoadingSpinner />;
+  }
+
+  return (
+    <AuthContext.Provider value={{ user, login, logout }}>
+      {children}
+    </AuthContext.Provider>
+  );
+}
+\`\`\`
+
+This component wraps your app and provides authentication context.`,
+  // Sample 2: Multiple code blocks
+  `Let me show you how to set up the API client:
+
+First, install the dependencies:
+
+\`\`\`bash
+npm install @tanstack/react-query axios
+\`\`\`
+
+Then create the client:
+
+\`\`\`typescript
+// src/lib/api.ts
+import axios from 'axios';
+
+export const apiClient = axios.create({
+  baseURL: process.env.NEXT_PUBLIC_API_URL,
+  timeout: 10000,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+// Add auth interceptor
+apiClient.interceptors.request.use((config) => {
+  const token = localStorage.getItem('auth_token');
+  if (token) {
+    config.headers.Authorization = \`Bearer \${token}\`;
+  }
+  return config;
+});
+\`\`\`
+
+And set up React Query:
+
+\`\`\`typescript
+// src/providers/QueryProvider.tsx
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 5 * 60 * 1000,
+      retry: 1,
+    },
+  },
+});
+
+export function QueryProvider({ children }: { children: React.ReactNode }) {
+  return (
+    <QueryClientProvider client={queryClient}>
+      {children}
+    </QueryClientProvider>
+  );
+}
+\`\`\``,
+  // Sample 3: Lists and inline code
+  `Here's what I found in the codebase:
+
+1. **Components** - Located in \`src/components/\`
+   - \`Button.tsx\` - Primary button component
+   - \`Input.tsx\` - Form input with validation
+   - \`Modal.tsx\` - Accessible modal dialog
+
+2. **Hooks** - Custom React hooks in \`src/hooks/\`
+   - \`useDebounce\` - Debounces rapidly changing values
+   - \`useLocalStorage\` - Syncs state with localStorage
+   - \`useMediaQuery\` - Responsive breakpoint detection
+
+3. **Utils** - Helper functions in \`src/lib/\`
+   - \`cn()\` - Class name merger (tailwind-merge + clsx)
+   - \`formatDate()\` - Date formatting with Intl API
+   - \`validateEmail()\` - Email validation regex
+
+The main entry point is \`src/App.tsx\` which sets up routing and providers.`,
+  // Sample 4: Table and code
+  `Here's a comparison of the state management options:
+
+| Feature | Zustand | Redux | Jotai |
+|---------|---------|-------|-------|
+| Bundle size | 1.5kb | 7kb | 2kb |
+| Boilerplate | Low | High | Low |
+| DevTools | Yes | Yes | Yes |
+| TypeScript | Excellent | Good | Excellent |
+
+Based on your requirements, I recommend Zustand:
+
+\`\`\`typescript
+import { create } from 'zustand';
+
+interface AppState {
+  count: number;
+  increment: () => void;
+  decrement: () => void;
+}
+
+export const useAppStore = create<AppState>((set) => ({
+  count: 0,
+  increment: () => set((state) => ({ count: state.count + 1 })),
+  decrement: () => set((state) => ({ count: state.count - 1 })),
+}));
+\`\`\``,
+  // Sample 5: Error explanation with code
+  `I found the issue! The error occurs because of a race condition:
+
+\`\`\`typescript
+// \u274C Bug: Race condition
+useEffect(() => {
+  fetchData().then(setData);
+}, [id]);
+
+// \u2705 Fix: Cleanup function prevents stale updates
+useEffect(() => {
+  let cancelled = false;
+
+  fetchData().then((result) => {
+    if (!cancelled) {
+      setData(result);
+    }
+  });
+
+  return () => {
+    cancelled = true;
+  };
+}, [id]);
+\`\`\`
+
+The fix adds a cleanup function that sets a \`cancelled\` flag when the effect re-runs or the component unmounts.`
+];
+var THOUGHT_PREFIXES = [
+  "Let me analyze",
+  "I should check",
+  "Looking at",
+  "Considering",
+  "The approach here is",
+  "Based on the code",
+  "I need to",
+  "First",
+  "Next",
+  "This suggests",
+  "The pattern shows",
+  "Examining"
+];
+var LOREM_WORDS = [
+  "Lorem",
+  "ipsum",
+  "dolor",
+  "sit",
+  "amet",
+  "consectetur",
+  "adipiscing",
+  "elit",
+  "sed",
+  "do",
+  "eiusmod",
+  "tempor",
+  "incididunt",
+  "ut",
+  "labore",
+  "et",
+  "dolore",
+  "magna",
+  "aliqua",
+  "Ut",
+  "enim",
+  "ad",
+  "minim",
+  "veniam",
+  "quis",
+  "nostrud"
+];
+var PLAN_TASKS = [
+  "Analyze the current implementation",
+  "Identify areas for improvement",
+  "Refactor the component structure",
+  "Update the test suite",
+  "Fix type errors",
+  "Add documentation",
+  "Optimize performance",
+  "Review dependencies"
+];
+var RICH_TOOL_CALLS = [
+  // Bash tool with command and output
+  {
+    toolName: "Bash",
+    kind: "execute",
+    title: "List files in src directory",
+    input: {
+      command: "ls -la src/",
+      description: "List files in src directory"
+    },
+    output: `total 48
+drwxr-xr-x  8 user user 4096 Jan 10 14:30 .
+drwxr-xr-x 12 user user 4096 Jan 10 14:25 ..
+drwxr-xr-x  4 user user 4096 Jan 10 14:30 components
+drwxr-xr-x  2 user user 4096 Jan 10 14:28 hooks
+drwxr-xr-x  2 user user 4096 Jan 10 14:27 lib
+-rw-r--r--  1 user user 1245 Jan 10 14:30 App.tsx
+-rw-r--r--  1 user user  892 Jan 10 14:25 main.tsx
+-rw-r--r--  1 user user 2341 Jan 10 14:29 index.css`
+  },
+  // Read tool with file contents
+  {
+    toolName: "Read",
+    kind: "read",
+    title: "Read ~/repos/project/src/utils.ts",
+    input: {
+      file_path: "/home/user/repos/project/src/utils.ts"
+    },
+    output: `export function cn(...classes: string[]): string {
+  return classes.filter(Boolean).join(' ');
+}
+
+export function formatDate(date: Date): string {
+  return new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+  }).format(date);
+}
+
+export function debounce<T extends (...args: unknown[]) => void>(
+  fn: T,
+  delay: number
+): T {
+  let timeoutId: NodeJS.Timeout;
+  return ((...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn(...args), delay);
+  }) as T;
+}`
+  },
+  // Edit tool with diff
+  {
+    toolName: "Edit",
+    kind: "edit",
+    title: "Edit ~/repos/project/src/config.ts",
+    input: {
+      file_path: "/home/user/repos/project/src/config.ts",
+      old_string: "timeout: 5000",
+      new_string: "timeout: 10000"
+    },
+    diff: `--- a/src/config.ts
++++ b/src/config.ts
+@@ -5,7 +5,7 @@ export const config = {
+   apiUrl: process.env.API_URL,
+   environment: process.env.NODE_ENV,
+   features: {
+-    timeout: 5000,
++    timeout: 10000,
+     retries: 3,
+     cacheEnabled: true,
+   },`
+  },
+  // Glob tool
+  {
+    toolName: "Glob",
+    kind: "search",
+    title: 'Glob "**/*.test.ts"',
+    input: {
+      pattern: "**/*.test.ts",
+      path: "/home/user/repos/project"
+    },
+    output: `src/components/Button.test.ts
+src/components/Input.test.ts
+src/hooks/useAuth.test.ts
+src/lib/utils.test.ts
+src/lib/api.test.ts`
+  },
+  // Grep tool
+  {
+    toolName: "Grep",
+    kind: "search",
+    title: 'Grep "useState" in src/',
+    input: {
+      pattern: "useState",
+      path: "/home/user/repos/project/src"
+    },
+    output: `src/components/Counter.tsx:3:import { useState } from 'react';
+src/components/Form.tsx:1:import { useState, useCallback } from 'react';
+src/hooks/useToggle.ts:1:import { useState } from 'react';
+src/App.tsx:2:import { useState, useEffect } from 'react';`
+  },
+  // Task/subagent tool
+  {
+    toolName: "Task",
+    kind: "think",
+    title: "Explore Task",
+    input: {
+      subagent_type: "Explore",
+      description: "Find authentication implementation",
+      prompt: "Search for authentication-related files and understand the auth flow"
+    },
+    output: `Found 3 relevant files:
+- src/hooks/useAuth.ts (main auth hook)
+- src/context/AuthContext.tsx (auth provider)
+- src/lib/auth.ts (token management)
+
+The app uses JWT tokens stored in localStorage with automatic refresh.`
+  },
+  // Write tool
+  {
+    toolName: "Write",
+    kind: "edit",
+    title: "Write ~/repos/project/src/newFile.ts",
+    input: {
+      file_path: "/home/user/repos/project/src/newFile.ts",
+      content: 'export const VERSION = "1.0.0";'
+    },
+    output: "File created successfully"
+  },
+  // WebFetch tool
+  {
+    toolName: "WebFetch",
+    kind: "fetch",
+    title: "Fetch https://api.example.com/docs",
+    input: {
+      url: "https://api.example.com/docs",
+      prompt: "Get the API documentation"
+    },
+    output: `# API Documentation
+
+## Authentication
+All requests require a Bearer token in the Authorization header.
+
+## Endpoints
+- GET /users - List all users
+- POST /users - Create a user
+- GET /users/:id - Get user by ID`
+  }
+];
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomChoice(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function generateText(length) {
+  const words = [];
+  while (words.join(" ").length < length) {
+    words.push(randomChoice(LOREM_WORDS));
+  }
+  return words.join(" ").slice(0, length);
+}
+function generateMessageChunks(totalLength, chunkSize, kind = "agent_message_chunk") {
+  const text = generateText(totalLength);
+  const chunks = [];
+  for (let i = 0; i < text.length; i += chunkSize) {
+    const chunk = text.slice(i, i + chunkSize);
+    chunks.push({
+      sessionUpdate: kind,
+      content: { type: "text", text: chunk }
+    });
+  }
+  return chunks;
+}
+function generateMarkdownChunks(chunkSize = 50) {
+  const markdown = randomChoice(MARKDOWN_SAMPLES);
+  const chunks = [];
+  for (let i = 0; i < markdown.length; i += chunkSize) {
+    const chunk = markdown.slice(i, i + chunkSize);
+    chunks.push({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: chunk }
+    });
+  }
+  return chunks;
+}
+function generateThoughtChunks(totalLength) {
+  const prefix = randomChoice(THOUGHT_PREFIXES);
+  const rest = generateText(totalLength - prefix.length);
+  const text = `${prefix} ${rest}`;
+  const chunkSize = randomInt(30, 60);
+  const chunks = [];
+  for (let i = 0; i < text.length; i += chunkSize) {
+    const chunk = text.slice(i, i + chunkSize);
+    chunks.push({
+      sessionUpdate: "agent_thought_chunk",
+      content: { type: "text", text: chunk }
+    });
+  }
+  return chunks;
+}
+function generateRichToolCall(config2) {
+  const toolCallId = randomUUID3();
+  const toolConfig = config2 ?? randomChoice(RICH_TOOL_CALLS);
+  const call = {
+    sessionUpdate: "tool_call",
+    toolCallId,
+    title: toolConfig.title,
+    status: "in_progress",
+    kind: toolConfig.kind,
+    rawInput: toolConfig.input,
+    _meta: {
+      claudeCode: {
+        toolName: toolConfig.toolName
+      }
+    }
+  };
+  const toolResponse = [];
+  if (toolConfig.output) {
+    toolResponse.push({ type: "text", text: toolConfig.output });
+  }
+  const content = [];
+  if (toolConfig.diff) {
+    content.push({ type: "diff", content: toolConfig.diff });
+  }
+  const update = {
+    sessionUpdate: "tool_call_update",
+    toolCallId,
+    status: "completed",
+    // Title update (sometimes tools update their title)
+    title: toolConfig.title.replace("...", ""),
+    _meta: {
+      claudeCode: {
+        toolName: toolConfig.toolName,
+        toolResponse: toolResponse.length > 0 ? toolResponse : void 0
+      }
+    },
+    ...content.length > 0 && { content }
+  };
+  return { call, update, toolCallId };
+}
+function generatePlan(entryCount) {
+  const entries = [];
+  const completedCount = randomInt(0, Math.floor(entryCount / 2));
+  for (let i = 0; i < entryCount; i++) {
+    const status = i < completedCount ? "completed" : i === completedCount ? "in_progress" : "pending";
+    entries.push({
+      content: randomChoice(PLAN_TASKS),
+      priority: randomChoice(["high", "medium", "low"]),
+      status
+    });
+  }
+  return {
+    sessionUpdate: "plan",
+    entries
+  };
+}
+function generateRealisticTurn(config2 = DEFAULT_STRESS_CONFIG) {
+  const events = [];
+  if (Math.random() < config2.thoughtProbability) {
+    const thoughtLength = randomInt(100, 300);
+    events.push(...generateThoughtChunks(thoughtLength));
+  }
+  if (Math.random() < config2.planProbability) {
+    events.push(generatePlan(randomInt(3, 6)));
+  }
+  if (Math.random() < config2.toolCallProbability) {
+    const toolCount = randomInt(1, 3);
+    for (let i = 0; i < toolCount; i++) {
+      const { call, update } = generateRichToolCall();
+      events.push(call);
+      if (Math.random() < 0.3) {
+        events.push(...generateThoughtChunks(randomInt(50, 100)));
+      }
+      events.push(update);
+    }
+  }
+  if (Math.random() < 0.7) {
+    events.push(...generateMarkdownChunks(config2.chunkSize));
+  } else {
+    const responseLength = randomInt(100, config2.eventsPerTurn * config2.chunkSize);
+    events.push(...generateMessageChunks(responseLength, config2.chunkSize));
+  }
+  return events;
+}
+
+// src/stress/config.ts
+var config = {
+  turnDelay: 5,
+  eventsPerTurn: 50,
+  eventDelay: 30,
+  // 30ms between events for visible streaming
+  chunkSize: 20
+  // smaller chunks look more like streaming
+};
+function getStressRuntimeConfig() {
+  return { ...config };
+}
+function setStressRuntimeConfig(updates) {
+  if (updates.turnDelay !== void 0) {
+    config.turnDelay = Math.max(0, Math.min(60, updates.turnDelay));
+  }
+  if (updates.eventsPerTurn !== void 0) {
+    config.eventsPerTurn = Math.max(10, Math.min(500, updates.eventsPerTurn));
+  }
+  if (updates.eventDelay !== void 0) {
+    config.eventDelay = Math.max(0, Math.min(200, updates.eventDelay));
+  }
+  if (updates.chunkSize !== void 0) {
+    config.chunkSize = Math.max(5, Math.min(100, updates.chunkSize));
+  }
+}
+
+// src/agents/backends/stress.ts
+function delay2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var StressBackend = class {
+  type = "stress";
+  running = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  getConfig() {
+    const runtime = getStressRuntimeConfig();
+    return {
+      eventsPerTurn: runtime.eventsPerTurn,
+      toolCallProbability: 0.4,
+      thoughtProbability: 0.6,
+      planProbability: 0.3,
+      chunkSize: runtime.chunkSize,
+      delayMs: runtime.eventDelay
+    };
+  }
+  matches(config2) {
+    return config2.command === "__stress__";
+  }
+  async start(sessionId, _config, _cwd, _existingAcpSessionId, emit) {
+    debug("stress", ` Starting stress agent for session ${sessionId}`);
+    emit({
+      sessionUpdate: "current_mode_update",
+      currentModeId: "stress"
+    });
+    const agent = { emit, stopped: false };
+    this.running.set(sessionId, agent);
+    this.runEventLoop(sessionId, agent);
+    debug("stress", ` Stress agent ready for session ${sessionId}`);
+    return {
+      sessionId: randomUUID4(),
+      models: [{ modelId: "stress-model", name: "Stress Model" }],
+      modes: [{ id: "stress", name: "Stress Mode" }]
+    };
+  }
+  getTurnDelayMs() {
+    const { turnDelay } = getStressRuntimeConfig();
+    if (turnDelay === 0) {
+      return 0;
+    }
+    const variance = turnDelay * 0.5;
+    return (turnDelay - variance + Math.random() * variance * 2) * 1e3;
+  }
+  async runEventLoop(sessionId, agent) {
+    await delay2(1e3);
+    let turnCount = 0;
+    while (!agent.stopped) {
+      turnCount++;
+      agent.emit({ amuxEvent: "turn_start" });
+      agent.emit({
+        sessionUpdate: "user_message_chunk",
+        content: { type: "text", text: `[Stress test turn ${turnCount}]` }
+      });
+      const config2 = this.getConfig();
+      const events = generateRealisticTurn(config2);
+      for (const event of events) {
+        if (agent.stopped) break;
+        agent.emit(event);
+        if (config2.delayMs > 0) {
+          await delay2(config2.delayMs);
+        }
+      }
+      if (!agent.stopped) {
+        agent.emit({ amuxEvent: "turn_end" });
+      }
+      const turnDelay = this.getTurnDelayMs();
+      await delay2(turnDelay);
+    }
+    debug("stress", ` Event loop stopped for session ${sessionId}`);
+  }
+  async prompt(sessionId, content, emit) {
+    const text = content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    debug("stress", ` Prompt for session ${sessionId}: "${text.slice(0, 50)}..."`);
+    const config2 = this.getConfig();
+    const events = generateRealisticTurn(config2);
+    for (const event of events) {
+      emit(event);
+      if (config2.delayMs > 0) {
+        await delay2(config2.delayMs);
+      }
+    }
+  }
+  async stop(sessionId) {
+    debug("stress", ` Stopping stress agent for session ${sessionId}`);
+    const agent = this.running.get(sessionId);
+    if (agent) {
+      agent.stopped = true;
+      this.running.delete(sessionId);
+    }
+  }
+  async stopAll() {
+    const sessionIds = [...this.running.keys()];
+    await Promise.all(sessionIds.map((id) => this.stop(id)));
+  }
+  isRunning(sessionId) {
+    return this.running.has(sessionId);
+  }
+};
+
+// src/agents/backends/shell.ts
+var pty = null;
+async function getPty() {
+  if (!pty) {
+    pty = await import("node-pty");
+  }
+  return pty;
+}
+var MAX_SCROLLBACK = 1e5;
+var ShellBackend = class {
+  type = "shell";
+  isInteractive = true;
+  sessions = /* @__PURE__ */ new Map();
+  matches(config2) {
+    return config2.command === "__shell__";
+  }
+  async start(sessionId, _config, cwd, _existingAcpSessionId, emit) {
+    const existing = this.sessions.get(sessionId);
+    if (existing) {
+      debug("shell", `Session ${sessionId} already running, reusing`);
+      existing.emit = emit;
+      return { sessionId };
+    }
+    const nodePty = await getPty();
+    const shell = process.env.SHELL || "/bin/bash";
+    debug("shell", `Spawning ${shell} in ${cwd}`);
+    const p = nodePty.spawn(shell, [], {
+      name: "xterm-256color",
+      cols: 80,
+      rows: 24,
+      cwd,
+      env: process.env
+    });
+    const session = {
+      pty: p,
+      scrollback: "",
+      cwd,
+      emit
+    };
+    p.onData((data) => {
+      session.scrollback += data;
+      if (session.scrollback.length > MAX_SCROLLBACK) {
+        session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK);
+      }
+      session.emit({ amuxEvent: "terminal_output", data });
+    });
+    p.onExit(({ exitCode, signal }) => {
+      debug("shell", `PTY exited: code=${exitCode}, signal=${signal}`);
+      session.emit({
+        amuxEvent: "terminal_exit",
+        exitCode: exitCode ?? null,
+        signal: signal !== void 0 ? String(signal) : null
+      });
+      this.sessions.delete(sessionId);
+    });
+    this.sessions.set(sessionId, session);
+    debug("shell", `Session ${sessionId} started`);
+    return { sessionId };
+  }
+  /**
+   * Get accumulated scrollback for replay on reconnect.
+   */
+  getScrollback(sessionId) {
+    return this.sessions.get(sessionId)?.scrollback;
+  }
+  /**
+   * Write raw input to terminal (keystrokes from client).
+   */
+  terminalWrite(sessionId, data) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      warn("shell", `terminalWrite: session ${sessionId} not found`);
+      return;
+    }
+    session.pty.write(data);
+  }
+  /**
+   * Resize terminal dimensions.
+   */
+  terminalResize(sessionId, cols, rows) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      warn("shell", `terminalResize: session ${sessionId} not found`);
+      return;
+    }
+    session.pty.resize(cols, rows);
+  }
+  /**
+   * Shell does not support conversational prompts.
+   */
+  async prompt() {
+    throw new Error("Shell backend does not support prompt(). Use terminalWrite() instead.");
+  }
+  async stop(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    debug("shell", `Stopping session ${sessionId}`);
+    session.pty.kill();
+    this.sessions.delete(sessionId);
+  }
+  async stopAll() {
+    debug("shell", `Stopping all sessions (${this.sessions.size})`);
+    for (const sessionId of this.sessions.keys()) {
+      await this.stop(sessionId);
+    }
+  }
+  isRunning(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+};
+
+// src/lib/mentions.ts
+import path from "path";
+function parseMessageToContentBlocks(message, workingDir) {
+  const blocks = [];
+  const mentionRegex = /@(\.{0,2}[\w\/\.\-]+)/g;
+  let lastIndex = 0;
+  for (const match of message.matchAll(mentionRegex)) {
+    if (match.index > lastIndex) {
+      const text = message.slice(lastIndex, match.index);
+      if (text.trim()) {
+        blocks.push({ type: "text", text });
+      }
+    }
+    const relativePath = match[1];
+    const absolutePath = path.resolve(workingDir, relativePath);
+    blocks.push({
+      type: "resource_link",
+      uri: `file://${absolutePath}`,
+      name: relativePath
+      // Required per ACP spec - use the path the user typed
+    });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < message.length) {
+    const text = message.slice(lastIndex);
+    if (text.trim()) {
+      blocks.push({ type: "text", text });
+    }
+  }
+  return blocks.length > 0 ? blocks : [{ type: "text", text: message }];
+}
+
+// src/agents/manager.ts
+function generateTitleFromMessage(message) {
+  const cleaned = message.replace(/@[\w./~-]+/g, "").replace(/\s+/g, " ").trim();
+  const firstLine = cleaned.split("\n")[0] || cleaned;
+  if (firstLine.length <= 50) return firstLine;
+  const truncated = firstLine.slice(0, 50);
+  const lastSpace = truncated.lastIndexOf(" ");
+  return lastSpace > 20 ? truncated.slice(0, lastSpace) + "..." : truncated + "...";
+}
+var AgentManager = class extends EventEmitter {
+  backends;
+  agents = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+    const acpBackend = new AcpBackend();
+    acpBackend.onSessionIdChanged = (sessionId, acpSessionId) => {
+      db.update(sessions).set({ acpSessionId }).where(eq(sessions.id, sessionId)).run();
+    };
+    this.backends = [acpBackend, new ShellBackend(), new MockBackend(), new StressBackend()];
+  }
+  getBackendForConfig(config2) {
+    const backend = this.backends.find((b) => b.matches(config2));
+    if (!backend) {
+      throw new Error(`No backend for agent config: ${config2.command}`);
+    }
+    return backend;
+  }
+  emitUpdate(sessionId, update) {
+    storeEvent(sessionId, update);
+    if (isSessionUpdate(update) && update.sessionUpdate === "session_info_update") {
+      const title = update.title;
+      if (title !== void 0) {
+        db.update(sessions).set({ title }).where(eq(sessions.id, sessionId)).run();
+      }
+    }
+    this.emit("update", { sessionId, update });
+  }
+  async startForSession(sessionId) {
+    const existing = this.agents.get(sessionId);
+    if (existing?.status === "ready") {
+      const replayEvents2 = getEventsForSession(sessionId);
+      const scrollback = this.getTerminalScrollback(sessionId);
+      debug("agents", `startForSession ${sessionId} - existing ready, scrollback: ${scrollback?.length ?? 0} bytes`);
+      return {
+        acpSessionId: existing.session.sessionId,
+        replayEvents: replayEvents2,
+        scrollback,
+        models: existing.session.models,
+        modes: existing.session.modes
+      };
+    }
+    if (existing?.status === "starting") {
+      return new Promise((resolve, reject) => {
+        const checkReady = () => {
+          const agent = this.agents.get(sessionId);
+          if (agent?.status === "ready") {
+            const replayEvents2 = getEventsForSession(sessionId);
+            const scrollback = this.getTerminalScrollback(sessionId);
+            resolve({
+              acpSessionId: agent.session.sessionId,
+              replayEvents: replayEvents2,
+              scrollback,
+              models: agent.session.models,
+              modes: agent.session.modes
+            });
+          } else if (agent?.status === "dead") {
+            reject(new Error("Agent failed to start"));
+          } else {
+            setTimeout(checkReady, 100);
+          }
+        };
+        checkReady();
+      });
+    }
+    const session = db.select().from(sessions).where(eq(sessions.id, sessionId)).get();
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    const dbConfig = db.select().from(agentConfigs).where(eq(agentConfigs.id, session.agentConfigId)).get();
+    if (!dbConfig) throw new Error(`Agent config ${session.agentConfigId} not found`);
+    const config2 = {
+      id: dbConfig.id,
+      name: dbConfig.name,
+      command: dbConfig.command,
+      args: dbConfig.args ?? [],
+      env: dbConfig.env ?? {}
+    };
+    const backend = this.getBackendForConfig(config2);
+    const emit = (update) => this.emitUpdate(sessionId, update);
+    this.agents.set(sessionId, {
+      backend,
+      session: { sessionId: "" },
+      status: "starting"
+    });
+    const replayEvents = getEventsForSession(sessionId);
+    try {
+      const agentSession = await backend.start(sessionId, config2, session.directory, session.acpSessionId ?? null, emit);
+      this.agents.set(sessionId, {
+        backend,
+        session: agentSession,
+        status: "ready"
+      });
+      debug("agents", `Agent ready for session ${sessionId}`);
+      const scrollback = this.getTerminalScrollback(sessionId);
+      return {
+        acpSessionId: agentSession.sessionId,
+        replayEvents,
+        scrollback,
+        models: agentSession.models,
+        modes: agentSession.modes
+      };
+    } catch (err) {
+      this.agents.set(sessionId, {
+        backend,
+        session: { sessionId: "" },
+        status: "dead"
+      });
+      throw err;
+    }
+  }
+  // Legacy alias for compatibility during migration
+  /** @deprecated Use startForSession instead */
+  startForWindow = this.startForSession.bind(this);
+  async prompt(sessionId, message) {
+    debug("agents", `prompt() called for session ${sessionId}: "${message.slice(0, 50)}..."`);
+    const agent = this.agents.get(sessionId);
+    if (!agent || agent.status !== "ready") {
+      throw new Error(`Agent not ready for session ${sessionId}`);
+    }
+    const session = db.select().from(sessions).where(eq(sessions.id, sessionId)).get();
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    if (!session.title) {
+      const title = generateTitleFromMessage(message);
+      if (title) {
+        db.update(sessions).set({ title }).where(eq(sessions.id, sessionId)).run();
+        this.emitUpdate(sessionId, {
+          sessionUpdate: "session_info_update",
+          title
+        });
+      }
+    }
+    startTurn(sessionId);
+    this.emitUpdate(sessionId, { amuxEvent: "turn_start" });
+    this.emitUpdate(sessionId, {
+      sessionUpdate: "user_message_chunk",
+      content: { type: "text", text: message }
+    });
+    const content = parseMessageToContentBlocks(message, session.directory);
+    const emit = (update) => this.emitUpdate(sessionId, update);
+    try {
+      await agent.backend.prompt(sessionId, content, emit);
+    } finally {
+      endTurn(sessionId);
+      this.emitUpdate(sessionId, { amuxEvent: "turn_end" });
+    }
+  }
+  async setMode(sessionId, modeId) {
+    const agent = this.agents.get(sessionId);
+    if (!agent || agent.status !== "ready") {
+      throw new Error(`Agent not ready for session ${sessionId}`);
+    }
+    if (!agent.backend.setMode) {
+      throw new Error(`Backend ${agent.backend.type} does not support setMode`);
+    }
+    await agent.backend.setMode(sessionId, modeId);
+  }
+  async setModel(sessionId, modelId) {
+    const agent = this.agents.get(sessionId);
+    if (!agent || agent.status !== "ready") {
+      throw new Error(`Agent not ready for session ${sessionId}`);
+    }
+    if (!agent.backend.setModel) {
+      throw new Error(`Backend ${agent.backend.type} does not support setModel`);
+    }
+    await agent.backend.setModel(sessionId, modelId);
+  }
+  async cancel(sessionId) {
+    const agent = this.agents.get(sessionId);
+    if (!agent?.backend.cancel) return;
+    await agent.backend.cancel(sessionId);
+  }
+  // Terminal-specific methods (for ShellBackend)
+  terminalWrite(sessionId, data) {
+    const agent = this.agents.get(sessionId);
+    if (!agent) {
+      throw new Error(`No agent running for session ${sessionId}`);
+    }
+    if (!agent.backend.terminalWrite) {
+      throw new Error(`Backend ${agent.backend.type} does not support terminal input`);
+    }
+    agent.backend.terminalWrite(sessionId, data);
+  }
+  terminalResize(sessionId, cols, rows) {
+    const agent = this.agents.get(sessionId);
+    if (!agent) {
+      throw new Error(`No agent running for session ${sessionId}`);
+    }
+    if (!agent.backend.terminalResize) {
+      throw new Error(`Backend ${agent.backend.type} does not support terminal resize`);
+    }
+    agent.backend.terminalResize(sessionId, cols, rows);
+  }
+  getTerminalScrollback(sessionId) {
+    const agent = this.agents.get(sessionId);
+    if (!agent?.backend.getScrollback) return void 0;
+    return agent.backend.getScrollback(sessionId);
+  }
+  isTerminalSession(sessionId) {
+    const agent = this.agents.get(sessionId);
+    return agent?.backend.isInteractive ?? false;
+  }
+  respondPermission(sessionId, requestId, optionId) {
+    const agent = this.agents.get(sessionId);
+    if (!agent) {
+      console.warn(`[AgentManager] No agent running for session ${sessionId}, ignoring permission response`);
+      return;
+    }
+    if (!agent.backend.respondToPermission) {
+      throw new Error(`Backend ${agent.backend.type} does not support permissions`);
+    }
+    agent.backend.respondToPermission(sessionId, requestId, optionId);
+  }
+  async stopForSession(sessionId) {
+    const agent = this.agents.get(sessionId);
+    if (agent) {
+      await agent.backend.stop(sessionId);
+    }
+    this.agents.delete(sessionId);
+  }
+  // Legacy alias for compatibility during migration
+  /** @deprecated Use stopForSession instead */
+  stopForWindow = this.stopForSession.bind(this);
+  async stopAll() {
+    const sessionIds = Array.from(this.agents.keys());
+    await Promise.all(sessionIds.map((id) => this.stopForSession(id)));
+  }
+  getForSession(sessionId) {
+    return this.agents.get(sessionId);
+  }
+  getPendingPermission(sessionId) {
+    const agent = this.agents.get(sessionId);
+    if (!agent?.backend.getPendingPermission) return null;
+    return agent.backend.getPendingPermission(sessionId);
+  }
+  // Legacy alias for compatibility during migration
+  /** @deprecated Use getForSession instead */
+  getForWindow = this.getForSession.bind(this);
+  registerBackend(backend) {
+    this.backends.unshift(backend);
+  }
+};
+var agentManager = new AgentManager();
+
+export {
+  getStressRuntimeConfig,
+  setStressRuntimeConfig,
+  agentManager
+};
+//# sourceMappingURL=chunk-RSLSN7F2.js.map