@webmux/agent 0.2.0 → 0.2.1

package/dist/connection-RJY775NL.js

@@ -0,0 +1,1046 @@
+#!/usr/bin/env node
+import {
+  AGENT_PACKAGE_NAME,
+  AGENT_VERSION,
+  upgradeService
+} from "./chunk-INUNCXBM.js";
+import {
+  assertValidSessionName
+} from "./chunk-EWE7ZUYJ.js";
+
+// src/connection.ts
+import WebSocket from "ws";
+
+// ../shared/src/contracts.ts
+var DEFAULT_TERMINAL_SIZE = {
+  cols: 120,
+  rows: 36
+};
+
+// ../shared/src/version.ts
+var SEMVER_PATTERN = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseSemanticVersion(version) {
+  const match = version.trim().match(SEMVER_PATTERN);
+  if (!match) {
+    return null;
+  }
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10),
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function compareSemanticVersions(left, right) {
+  const parsedLeft = parseSemanticVersion(left);
+  const parsedRight = parseSemanticVersion(right);
+  if (!parsedLeft || !parsedRight) {
+    throw new Error(`Invalid semantic version comparison: "${left}" vs "${right}"`);
+  }
+  if (parsedLeft.major !== parsedRight.major) {
+    return parsedLeft.major - parsedRight.major;
+  }
+  if (parsedLeft.minor !== parsedRight.minor) {
+    return parsedLeft.minor - parsedRight.minor;
+  }
+  if (parsedLeft.patch !== parsedRight.patch) {
+    return parsedLeft.patch - parsedRight.patch;
+  }
+  return comparePrerelease(parsedLeft.prerelease, parsedRight.prerelease);
+}
+function comparePrerelease(left, right) {
+  if (left.length === 0 && right.length === 0) {
+    return 0;
+  }
+  if (left.length === 0) {
+    return 1;
+  }
+  if (right.length === 0) {
+    return -1;
+  }
+  const maxLength = Math.max(left.length, right.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    const leftIdentifier = left[index];
+    const rightIdentifier = right[index];
+    if (leftIdentifier === void 0) {
+      return -1;
+    }
+    if (rightIdentifier === void 0) {
+      return 1;
+    }
+    const numericLeft = Number.parseInt(leftIdentifier, 10);
+    const numericRight = Number.parseInt(rightIdentifier, 10);
+    const leftIsNumber = String(numericLeft) === leftIdentifier;
+    const rightIsNumber = String(numericRight) === rightIdentifier;
+    if (leftIsNumber && rightIsNumber && numericLeft !== numericRight) {
+      return numericLeft - numericRight;
+    }
+    if (leftIsNumber !== rightIsNumber) {
+      return leftIsNumber ? -1 : 1;
+    }
+    if (leftIdentifier !== rightIdentifier) {
+      return leftIdentifier < rightIdentifier ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+// src/terminal.ts
+import { spawn } from "node-pty";
+async function createTerminalBridge(options) {
+  const {
+    tmux,
+    sessionName,
+    cols = DEFAULT_TERMINAL_SIZE.cols,
+    rows = DEFAULT_TERMINAL_SIZE.rows,
+    onData,
+    onExit
+  } = options;
+  assertValidSessionName(sessionName);
+  await tmux.createSession(sessionName);
+  const ptyProcess = spawn(
+    "tmux",
+    ["-L", tmux.socketName, "attach-session", "-t", sessionName],
+    {
+      cols,
+      rows,
+      cwd: tmux.workspaceRoot,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color"
+      },
+      name: "xterm-256color"
+    }
+  );
+  ptyProcess.onData(onData);
+  ptyProcess.onExit(({ exitCode }) => {
+    onExit(exitCode);
+  });
+  return {
+    write(data) {
+      ptyProcess.write(data);
+    },
+    resize(nextCols, nextRows) {
+      ptyProcess.resize(nextCols, nextRows);
+    },
+    dispose() {
+      ptyProcess.kill();
+    }
+  };
+}
+
+// src/run-wrapper.ts
+import { spawn as spawn2 } from "node-pty";
+
+// src/plain-output.ts
+function joinOutputParts(parts) {
+  const output = parts.filter(Boolean).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+  return output;
+}
+function parseCount(paramText, fallback) {
+  const value = Number.parseInt(paramText, 10);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+var TerminalOutputSanitizer = class {
+  currentLine = "";
+  cursor = 0;
+  clearOnWrite = false;
+  completedLines = [];
+  push(rawText) {
+    for (let index = 0; index < rawText.length; index += 1) {
+      const char = rawText[index];
+      if (char === "\x1B" || char === "\x9B") {
+        index = this.handleEscapeSequence(rawText, index);
+        continue;
+      }
+      if (char === "\r") {
+        this.cursor = 0;
+        this.clearOnWrite = true;
+        continue;
+      }
+      if (char === "\n") {
+        this.commitLine();
+        continue;
+      }
+      if (char === "\b") {
+        this.cursor = Math.max(0, this.cursor - 1);
+        continue;
+      }
+      if (char === "	") {
+        this.writeChar(" ");
+        continue;
+      }
+      const code = char.charCodeAt(0);
+      if (code >= 0 && code <= 8 || code >= 11 && code <= 31 || code === 127) {
+        continue;
+      }
+      this.writeChar(char);
+    }
+    const lines = this.completedLines;
+    this.completedLines = [];
+    return joinOutputParts(lines);
+  }
+  flush() {
+    const line = this.normalizeLine(this.currentLine);
+    this.currentLine = "";
+    this.cursor = 0;
+    this.clearOnWrite = false;
+    return line;
+  }
+  handleEscapeSequence(text, startIndex) {
+    if (text[startIndex] === "\x9B") {
+      return this.handleCsiSequence(text, startIndex + 1);
+    }
+    const nextChar = text[startIndex + 1];
+    if (!nextChar) {
+      return startIndex;
+    }
+    if (nextChar === "[") {
+      return this.handleCsiSequence(text, startIndex + 2);
+    }
+    if (nextChar === "]") {
+      for (let index = startIndex + 2; index < text.length; index += 1) {
+        if (text[index] === "\x07") {
+          return index;
+        }
+        if (text[index] === "\x1B" && text[index + 1] === "\\") {
+          return index + 1;
+        }
+      }
+      return text.length - 1;
+    }
+    if (nextChar === "(" || nextChar === ")" || nextChar === "#") {
+      return Math.min(startIndex + 2, text.length - 1);
+    }
+    return startIndex + 1;
+  }
+  handleCsiSequence(text, cursorIndex) {
+    let paramText = "";
+    let index = cursorIndex;
+    while (index < text.length) {
+      const char = text[index];
+      const code = char.charCodeAt(0);
+      if (code >= 64 && code <= 126) {
+        this.applyCsiSequence(paramText, char);
+        return index;
+      }
+      paramText += char;
+      index += 1;
+    }
+    return text.length - 1;
+  }
+  applyCsiSequence(paramText, command) {
+    const normalizedParams = paramText.replace(/^\?/, "");
+    const parts = normalizedParams.length > 0 ? normalizedParams.split(";") : [];
+    switch (command) {
+      case "m":
+        return;
+      case "J":
+        if (parseCount(parts[0] ?? "", 0) === 2) {
+          this.currentLine = "";
+          this.cursor = 0;
+          this.clearOnWrite = false;
+        }
+        return;
+      case "K": {
+        const mode = parseCount(parts[0] ?? "", 0);
+        if (mode === 2) {
+          this.currentLine = "";
+          this.cursor = 0;
+        } else if (mode === 1) {
+          this.currentLine = this.currentLine.slice(this.cursor);
+          this.cursor = 0;
+        } else {
+          this.currentLine = this.currentLine.slice(0, this.cursor);
+        }
+        this.clearOnWrite = false;
+        return;
+      }
+      case "H":
+      case "f":
+        if (this.normalizeLine(this.currentLine)) {
+          this.commitLine();
+        } else {
+          this.currentLine = "";
+          this.cursor = 0;
+          this.clearOnWrite = false;
+        }
+        return;
+      case "G":
+        this.cursor = Math.max(0, parseCount(parts[0] ?? "", 1) - 1);
+        this.clearOnWrite = false;
+        return;
+      case "C":
+        this.cursor += parseCount(parts[0] ?? "", 1);
+        this.clearOnWrite = false;
+        return;
+      case "D":
+        this.cursor = Math.max(0, this.cursor - parseCount(parts[0] ?? "", 1));
+        this.clearOnWrite = false;
+        return;
+      case "P": {
+        const count = parseCount(parts[0] ?? "", 1);
+        this.currentLine = this.currentLine.slice(0, this.cursor) + this.currentLine.slice(this.cursor + count);
+        this.clearOnWrite = false;
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  writeChar(char) {
+    if (this.clearOnWrite && this.cursor === 0) {
+      this.currentLine = "";
+    }
+    this.clearOnWrite = false;
+    if (this.cursor > this.currentLine.length) {
+      this.currentLine += " ".repeat(this.cursor - this.currentLine.length);
+    }
+    if (this.cursor === this.currentLine.length) {
+      this.currentLine += char;
+    } else {
+      this.currentLine = this.currentLine.slice(0, this.cursor) + char + this.currentLine.slice(this.cursor + 1);
+    }
+    this.cursor += 1;
+  }
+  commitLine() {
+    const line = this.normalizeLine(this.currentLine);
+    if (line) {
+      this.completedLines.push(line);
+    }
+    this.currentLine = "";
+    this.cursor = 0;
+    this.clearOnWrite = false;
+  }
+  normalizeLine(line) {
+    return line.replace(/[ \t]+$/g, "").trim();
+  }
+};
+
+// src/run-wrapper.ts
+var STATUS_DEBOUNCE_MS = 300;
+var OUTPUT_BUFFER_MAX_LINES = 20;
+var CLAUDE_APPROVAL_PATTERNS = [
+  /do you want to/i,
+  /\ballow\b/i,
+  /\bdeny\b/i,
+  /\bpermission\b/i,
+  /proceed\?/i
+];
+var CLAUDE_INPUT_PATTERNS = [
+  /^>\s*$/m,
+  /❯/,
+  /\$ $/m
+];
+var CODEX_APPROVAL_PATTERNS = [
+  /apply changes/i,
+  /\[y\/n\]/i,
+  /\bapprove\b/i
+];
+var CODEX_INPUT_PATTERNS = [
+  /what would you like/i,
+  /❯/,
+  /^>\s*$/m
+];
+function matchesAny(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+var RunWrapper = class {
+  runId;
+  tool;
+  repoPath;
+  prompt;
+  tmux;
+  onEvent;
+  onFinish;
+  onOutput;
+  ptyProcess = null;
+  currentStatus = "starting";
+  outputBuffer = [];
+  debounceTimer = null;
+  disposed = false;
+  interrupted = false;
+  outputSanitizer = new TerminalOutputSanitizer();
+  sessionName;
+  constructor(options) {
+    this.runId = options.runId;
+    this.tool = options.tool;
+    this.repoPath = options.repoPath;
+    this.prompt = options.prompt;
+    this.tmux = options.tmux;
+    this.onEvent = options.onEvent;
+    this.onFinish = options.onFinish;
+    this.onOutput = options.onOutput;
+    const shortId = this.runId.slice(0, 8);
+    this.sessionName = `run-${shortId}`;
+  }
+  async start() {
+    if (this.disposed) {
+      return;
+    }
+    this.emitStatus("starting");
+    await this.tmux.createSession(this.sessionName);
+    const command = this.buildCommand();
+    const ptyProcess = spawn2(
+      "tmux",
+      ["-L", this.tmux.socketName, "attach-session", "-t", this.sessionName],
+      {
+        cols: 120,
+        rows: 36,
+        cwd: this.repoPath,
+        env: {
+          ...process.env,
+          TERM: "xterm-256color"
+        },
+        name: "xterm-256color"
+      }
+    );
+    this.ptyProcess = ptyProcess;
+    ptyProcess.onData((data) => {
+      if (this.disposed) {
+        return;
+      }
+      const plainOutput = this.outputSanitizer.push(data);
+      if (plainOutput) {
+        this.onOutput(plainOutput);
+      }
+      this.appendToBuffer(data);
+      this.scheduleStatusDetection();
+    });
+    ptyProcess.onExit(({ exitCode }) => {
+      if (this.disposed) {
+        return;
+      }
+      if (this.debounceTimer) {
+        clearTimeout(this.debounceTimer);
+        this.debounceTimer = null;
+      }
+      const finalStatus = this.interrupted ? "interrupted" : exitCode === 0 ? "success" : "failed";
+      if (finalStatus !== this.currentStatus) {
+        this.emitStatus(finalStatus);
+      }
+      const trailingOutput = this.outputSanitizer.flush();
+      if (trailingOutput) {
+        this.onOutput(trailingOutput);
+      }
+      this.onFinish(finalStatus);
+      this.ptyProcess = null;
+    });
+    setTimeout(() => {
+      if (this.ptyProcess && !this.disposed) {
+        this.ptyProcess.write(command + "\n");
+        this.emitStatus("running");
+      }
+    }, 500);
+  }
+  sendInput(input) {
+    if (this.ptyProcess && !this.disposed) {
+      this.ptyProcess.write(input);
+    }
+  }
+  interrupt() {
+    if (this.ptyProcess && !this.disposed) {
+      this.interrupted = true;
+      this.ptyProcess.write("");
+      this.emitStatus("interrupted");
+    }
+  }
+  approve() {
+    if (this.ptyProcess && !this.disposed) {
+      this.ptyProcess.write("y\n");
+    }
+  }
+  reject() {
+    if (this.ptyProcess && !this.disposed) {
+      this.ptyProcess.write("n\n");
+    }
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.ptyProcess) {
+      this.ptyProcess.kill();
+      this.ptyProcess = null;
+    }
+    this.tmux.killSession(this.sessionName).catch(() => {
+    });
+  }
+  buildCommand() {
+    const escapedPrompt = this.prompt.replace(/'/g, "'\\''");
+    switch (this.tool) {
+      case "claude":
+        return `cd '${this.repoPath.replace(/'/g, "'\\''")}' && claude '${escapedPrompt}'`;
+      case "codex":
+        return `cd '${this.repoPath.replace(/'/g, "'\\''")}' && codex '${escapedPrompt}'`;
+    }
+  }
+  appendToBuffer(data) {
+    const newLines = data.split("\n");
+    this.outputBuffer.push(...newLines);
+    if (this.outputBuffer.length > OUTPUT_BUFFER_MAX_LINES) {
+      this.outputBuffer = this.outputBuffer.slice(-OUTPUT_BUFFER_MAX_LINES);
+    }
+  }
+  scheduleStatusDetection() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      this.detectStatus();
+    }, STATUS_DEBOUNCE_MS);
+  }
+  detectStatus() {
+    if (this.disposed) {
+      return;
+    }
+    if (this.currentStatus === "success" || this.currentStatus === "failed" || this.currentStatus === "interrupted") {
+      return;
+    }
+    const recentText = this.outputBuffer.join("\n");
+    const detectedStatus = this.detectStatusFromText(recentText);
+    if (detectedStatus && detectedStatus !== this.currentStatus) {
+      this.emitStatus(detectedStatus);
+    }
+  }
+  detectStatusFromText(text) {
+    const approvalPatterns = this.tool === "claude" ? CLAUDE_APPROVAL_PATTERNS : CODEX_APPROVAL_PATTERNS;
+    if (matchesAny(text, approvalPatterns)) {
+      return "waiting_approval";
+    }
+    const inputPatterns = this.tool === "claude" ? CLAUDE_INPUT_PATTERNS : CODEX_INPUT_PATTERNS;
+    if (matchesAny(text, inputPatterns)) {
+      return "waiting_input";
+    }
+    if (text.trim().length > 0) {
+      return "running";
+    }
+    return null;
+  }
+  emitStatus(status, summary, hasDiff) {
+    this.currentStatus = status;
+    this.onEvent(status, summary, hasDiff);
+  }
+};
+
+// src/repositories.ts
+import { readdir, stat } from "fs/promises";
+import path from "path";
+async function browseRepositories(options) {
+  const rootPath = path.resolve(options.rootPath);
+  const currentPath = resolveRequestedPath(rootPath, options.requestedPath);
+  const dirents = await readdir(currentPath, { withFileTypes: true });
+  const entries = await Promise.all(
+    dirents.filter((dirent) => dirent.isDirectory()).map(async (dirent) => classifyEntry(currentPath, dirent.name))
+  );
+  return {
+    currentPath,
+    parentPath: currentPath === rootPath ? null : path.dirname(currentPath),
+    entries: entries.sort(compareRepositoryEntries)
+  };
+}
+async function classifyEntry(basePath, name) {
+  const entryPath = path.join(basePath, name);
+  const gitPath = path.join(entryPath, ".git");
+  try {
+    const gitStat = await stat(gitPath);
+    if (gitStat.isDirectory() || gitStat.isFile()) {
+      return {
+        kind: "repository",
+        name,
+        path: entryPath
+      };
+    }
+  } catch {
+    return {
+      kind: "directory",
+      name,
+      path: entryPath
+    };
+  }
+  return {
+    kind: "directory",
+    name,
+    path: entryPath
+  };
+}
+function resolveRequestedPath(rootPath, requestedPath) {
+  const candidatePath = path.resolve(requestedPath ?? rootPath);
+  const relativePath = path.relative(rootPath, candidatePath);
+  if (relativePath !== "" && (relativePath.startsWith("..") || path.isAbsolute(relativePath))) {
+    throw new Error("Requested path is outside the allowed root");
+  }
+  return candidatePath;
+}
+function compareRepositoryEntries(left, right) {
+  const kindOrder = repositoryKindOrder(left.kind) - repositoryKindOrder(right.kind);
+  if (kindOrder !== 0) {
+    return kindOrder;
+  }
+  const hiddenOrder = Number(left.name.startsWith(".")) - Number(right.name.startsWith("."));
+  if (hiddenOrder !== 0) {
+    return hiddenOrder;
+  }
+  return left.name.localeCompare(right.name);
+}
+function repositoryKindOrder(kind) {
+  return kind === "repository" ? 0 : 1;
+}
+
+// src/connection.ts
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var SESSION_SYNC_INTERVAL_MS = 15e3;
+var INITIAL_RECONNECT_DELAY_MS = 1e3;
+var MAX_RECONNECT_DELAY_MS = 3e4;
+var defaultAgentRuntime = {
+  version: AGENT_VERSION,
+  serviceMode: process.env.WEBMUX_AGENT_SERVICE === "1",
+  autoUpgrade: process.env.WEBMUX_AGENT_AUTO_UPGRADE !== "0",
+  applyServiceUpgrade: ({ packageName, targetVersion }) => {
+    upgradeService({
+      agentName: process.env.WEBMUX_AGENT_NAME ?? "webmux-agent",
+      packageName,
+      version: targetVersion
+    });
+  },
+  exit: (code) => {
+    process.exit(code);
+  }
+};
+var AgentConnection = class {
+  serverUrl;
+  agentId;
+  agentSecret;
+  tmux;
+  runtime;
+  ws = null;
+  heartbeatTimer = null;
+  sessionSyncTimer = null;
+  reconnectTimer = null;
+  reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+  bridges = /* @__PURE__ */ new Map();
+  runs = /* @__PURE__ */ new Map();
+  stopped = false;
+  constructor(serverUrl, agentId, agentSecret, tmux, runtime = defaultAgentRuntime) {
+    this.serverUrl = serverUrl;
+    this.agentId = agentId;
+    this.agentSecret = agentSecret;
+    this.tmux = tmux;
+    this.runtime = runtime;
+  }
+  start() {
+    this.stopped = false;
+    this.connect();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.stopHeartbeat();
+    this.stopSessionSync();
+    this.disposeAllBridges();
+    this.disposeAllRuns();
+    if (this.ws) {
+      this.ws.close(1e3, "agent shutting down");
+      this.ws = null;
+    }
+  }
+  connect() {
+    const wsUrl = buildWsUrl(this.serverUrl);
+    console.log(`[agent] Connecting to ${wsUrl}`);
+    const ws = new WebSocket(wsUrl);
+    this.ws = ws;
+    ws.on("open", () => {
+      console.log("[agent] WebSocket connected, authenticating...");
+      this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+      this.sendMessage({
+        type: "auth",
+        agentId: this.agentId,
+        agentSecret: this.agentSecret,
+        version: this.runtime.version
+      });
+    });
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(raw.toString());
+      } catch {
+        console.error("[agent] Failed to parse server message:", raw.toString());
+        return;
+      }
+      this.handleMessage(msg);
+    });
+    ws.on("close", (code, reason) => {
+      console.log(`[agent] WebSocket closed: code=${code} reason=${reason.toString()}`);
+      this.onDisconnect();
+    });
+    ws.on("error", (err) => {
+      console.error("[agent] WebSocket error:", err.message);
+    });
+  }
+  handleMessage(msg) {
+    switch (msg.type) {
+      case "auth-ok":
+        console.log("[agent] Authenticated successfully");
+        if (this.applyRecommendedUpgrade(msg.upgradePolicy)) {
+          return;
+        }
+        this.startHeartbeat();
+        this.startSessionSync();
+        this.syncSessions();
+        break;
+      case "auth-fail":
+        console.error(`[agent] Authentication failed: ${msg.message}`);
+        this.stopped = true;
+        if (this.ws) {
+          this.ws.close();
+          this.ws = null;
+        }
+        this.runtime.exit(1);
+        break;
+      case "sessions-list":
+        this.syncSessions();
+        break;
+      case "terminal-attach":
+        this.handleTerminalAttach(msg.browserId, msg.sessionName, msg.cols, msg.rows);
+        break;
+      case "terminal-detach":
+        this.handleTerminalDetach(msg.browserId);
+        break;
+      case "terminal-input":
+        this.handleTerminalInput(msg.browserId, msg.data);
+        break;
+      case "terminal-resize":
+        this.handleTerminalResize(msg.browserId, msg.cols, msg.rows);
+        break;
+      case "session-create":
+        this.handleSessionCreate(msg.requestId, msg.name);
+        break;
+      case "session-kill":
+        this.handleSessionKill(msg.requestId, msg.name);
+        break;
+      case "repository-browse":
+        this.handleRepositoryBrowse(msg.requestId, msg.path);
+        break;
+      case "run-start":
+        this.handleRunStart(msg.runId, msg.tool, msg.repoPath, msg.prompt);
+        break;
+      case "run-input":
+        this.handleRunInput(msg.runId, msg.input);
+        break;
+      case "run-interrupt":
+        this.handleRunInterrupt(msg.runId);
+        break;
+      case "run-kill":
+        this.handleRunKill(msg.runId);
+        break;
+      case "run-approve":
+        this.handleRunApprove(msg.runId);
+        break;
+      case "run-reject":
+        this.handleRunReject(msg.runId);
+        break;
+      default:
+        console.warn("[agent] Unknown message type:", msg.type);
+    }
+  }
+  async syncSessions() {
+    try {
+      const sessions = await this.tmux.listSessions();
+      this.sendMessage({ type: "sessions-sync", sessions });
+      return sessions;
+    } catch (err) {
+      console.error("[agent] Failed to list sessions:", err);
+      this.sendMessage({ type: "error", message: "Failed to list sessions" });
+      return [];
+    }
+  }
+  async handleTerminalAttach(browserId, sessionName, cols, rows) {
+    const existing = this.bridges.get(browserId);
+    if (existing) {
+      existing.dispose();
+      this.bridges.delete(browserId);
+    }
+    try {
+      const bridge = await createTerminalBridge({
+        tmux: this.tmux,
+        sessionName,
+        cols,
+        rows,
+        onData: (data) => {
+          this.sendMessage({ type: "terminal-output", browserId, data });
+        },
+        onExit: (exitCode) => {
+          this.bridges.delete(browserId);
+          this.sendMessage({ type: "terminal-exit", browserId, exitCode });
+          void this.syncSessions();
+        }
+      });
+      this.bridges.set(browserId, bridge);
+      this.sendMessage({ type: "terminal-ready", browserId, sessionName });
+      await this.syncSessions();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[agent] Failed to attach terminal for browser ${browserId}:`, message);
+      this.sendMessage({ type: "error", browserId, message: `Failed to attach: ${message}` });
+    }
+  }
+  handleTerminalDetach(browserId) {
+    const bridge = this.bridges.get(browserId);
+    if (bridge) {
+      bridge.dispose();
+      this.bridges.delete(browserId);
+      void this.syncSessions();
+    }
+  }
+  handleTerminalInput(browserId, data) {
+    const bridge = this.bridges.get(browserId);
+    if (bridge) {
+      bridge.write(data);
+    }
+  }
+  handleTerminalResize(browserId, cols, rows) {
+    const bridge = this.bridges.get(browserId);
+    if (bridge) {
+      bridge.resize(cols, rows);
+    }
+  }
+  async handleSessionCreate(requestId, name) {
+    try {
+      await this.tmux.createSession(name);
+      const sessions = await this.syncSessions();
+      const session = sessions.find((item) => item.name === name);
+      if (!session) {
+        throw new Error("Created session was not returned by tmux");
+      }
+      this.sendMessage({ type: "command-result", requestId, ok: true, session });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[agent] Failed to create session "${name}":`, message);
+      this.sendMessage({ type: "command-result", requestId, ok: false, error: message });
+    }
+  }
+  async handleSessionKill(requestId, name) {
+    try {
+      await this.tmux.killSession(name);
+      await this.syncSessions();
+      this.sendMessage({ type: "command-result", requestId, ok: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[agent] Failed to kill session "${name}":`, message);
+      this.sendMessage({ type: "command-result", requestId, ok: false, error: message });
+    }
+  }
+  async handleRepositoryBrowse(requestId, requestedPath) {
+    try {
+      const result = await browseRepositories({
+        rootPath: this.tmux.workspaceRoot,
+        requestedPath
+      });
+      this.sendMessage({
+        type: "repository-browse-result",
+        requestId,
+        ok: true,
+        currentPath: result.currentPath,
+        parentPath: result.parentPath,
+        entries: result.entries
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error("[agent] Failed to browse repositories:", message);
+      this.sendMessage({ type: "repository-browse-result", requestId, ok: false, error: message });
+    }
+  }
+  sendMessage(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  applyRecommendedUpgrade(upgradePolicy) {
+    const targetVersion = upgradePolicy?.targetVersion;
+    if (!targetVersion) {
+      return false;
+    }
+    let comparison;
+    try {
+      comparison = compareSemanticVersions(this.runtime.version, targetVersion);
+    } catch {
+      console.warn("[agent] Skipping automatic upgrade because version parsing failed");
+      return false;
+    }
+    if (comparison >= 0) {
+      return false;
+    }
+    console.log(`[agent] Update available: ${this.runtime.version} \u2192 ${targetVersion}`);
+    if (!this.runtime.serviceMode || !this.runtime.autoUpgrade) {
+      console.log("[agent] Automatic upgrades are only applied for the managed systemd service");
+      console.log(`[agent] To upgrade manually, run: pnpm dlx @webmux/agent service upgrade --to ${targetVersion}`);
+      return false;
+    }
+    try {
+      this.runtime.applyServiceUpgrade({
+        packageName: upgradePolicy.packageName || AGENT_PACKAGE_NAME,
+        targetVersion
+      });
+      console.log(`[agent] Managed service switched to ${targetVersion}. Restarting...`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[agent] Failed to apply managed upgrade: ${message}`);
+      console.log("[agent] Continuing with current version");
+      return false;
+    }
+    this.stop();
+    this.runtime.exit(0);
+    return true;
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.sendMessage({ type: "heartbeat" });
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  startSessionSync() {
+    this.stopSessionSync();
+    this.sessionSyncTimer = setInterval(() => {
+      void this.syncSessions();
+    }, SESSION_SYNC_INTERVAL_MS);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  stopSessionSync() {
+    if (this.sessionSyncTimer) {
+      clearInterval(this.sessionSyncTimer);
+      this.sessionSyncTimer = null;
+    }
+  }
+  disposeAllBridges() {
+    for (const [browserId, bridge] of this.bridges) {
+      bridge.dispose();
+      this.bridges.delete(browserId);
+    }
+  }
+  disposeAllRuns() {
+    for (const [runId, run] of this.runs) {
+      run.dispose();
+      this.runs.delete(runId);
+    }
+  }
+  handleRunStart(runId, tool, repoPath, prompt) {
+    const existing = this.runs.get(runId);
+    if (existing) {
+      existing.dispose();
+      this.runs.delete(runId);
+    }
+    const run = new RunWrapper({
+      runId,
+      tool,
+      repoPath,
+      prompt,
+      tmux: this.tmux,
+      onEvent: (status, summary, hasDiff) => {
+        this.sendMessage({ type: "run-event", runId, status, summary, hasDiff });
+      },
+      onFinish: () => {
+        this.runs.delete(runId);
+      },
+      onOutput: (data) => {
+        this.sendMessage({ type: "run-output", runId, data });
+      }
+    });
+    this.runs.set(runId, run);
+    run.start().catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[agent] Failed to start run ${runId}:`, message);
+      this.sendMessage({
+        type: "run-event",
+        runId,
+        status: "failed",
+        summary: `Failed to start: ${message}`
+      });
+      this.runs.delete(runId);
+    });
+  }
+  handleRunInput(runId, input) {
+    const run = this.runs.get(runId);
+    if (run) {
+      run.sendInput(input);
+    } else {
+      console.warn(`[agent] run-input: no run found for ${runId}`);
+    }
+  }
+  handleRunInterrupt(runId) {
+    const run = this.runs.get(runId);
+    if (run) {
+      run.interrupt();
+    } else {
+      console.warn(`[agent] run-interrupt: no run found for ${runId}`);
+    }
+  }
+  handleRunKill(runId) {
+    const run = this.runs.get(runId);
+    if (run) {
+      run.dispose();
+      this.runs.delete(runId);
+    } else {
+      void this.tmux.killSession(getRunSessionName(runId)).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        console.warn(`[agent] run-kill: failed to clean session for ${runId}: ${message}`);
+      });
+    }
+  }
+  handleRunApprove(runId) {
+    const run = this.runs.get(runId);
+    if (run) {
+      run.approve();
+    } else {
+      console.warn(`[agent] run-approve: no run found for ${runId}`);
+    }
+  }
+  handleRunReject(runId) {
+    const run = this.runs.get(runId);
+    if (run) {
+      run.reject();
+    } else {
+      console.warn(`[agent] run-reject: no run found for ${runId}`);
+    }
+  }
+  onDisconnect() {
+    this.stopHeartbeat();
+    this.stopSessionSync();
+    this.disposeAllBridges();
+    this.disposeAllRuns();
+    this.ws = null;
+    if (this.stopped) {
+      return;
+    }
+    console.log(`[agent] Reconnecting in ${this.reconnectDelay}ms...`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, this.reconnectDelay);
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+  }
+};
+function buildWsUrl(serverUrl) {
+  const url = new URL("/ws/agent", serverUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return url.toString();
+}
+function getRunSessionName(runId) {
+  return `run-${runId.slice(0, 8)}`;
+}
+export {
+  AgentConnection
+};