@webmux/agent 0.2.0 → 0.2.1

package/dist/cli.js

@@ -1,8 +1,19 @@
 #!/usr/bin/env node
+import {
+  AGENT_PACKAGE_NAME,
+  AGENT_VERSION,
+  SERVICE_NAME,
+  installService,
+  readInstalledServiceConfig,
+  servicePath,
+  uninstallService,
+  upgradeService
+} from "./chunk-INUNCXBM.js";
 
 // src/cli.ts
-import os3 from "os";
-import { execFileSync as execFileSync2 } from "child_process";
+import os2 from "os";
+import { execFileSync } from "child_process";
+import { pathToFileURL } from "url";
 import { Command } from "commander";
 
 // src/credentials.ts
@@ -41,1247 +52,202 @@ function saveCredentials(creds) {
   });
 }
 
-// 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/service.ts
-import fs2 from "fs";
-import os2 from "os";
-import path2 from "path";
-import { execFileSync } from "child_process";
-var SERVICE_NAME = "webmux-agent";
-function renderServiceUnit(options) {
-  return `[Unit]
-Description=Webmux Agent (${options.agentName})
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${options.nodePath} ${options.cliPath} start
-Restart=always
-RestartSec=10
-Environment=WEBMUX_AGENT_SERVICE=1
-Environment=WEBMUX_AGENT_AUTO_UPGRADE=${options.autoUpgrade ? "1" : "0"}
-Environment=WEBMUX_AGENT_NAME=${options.agentName}
-Environment=HOME=${options.homeDir}
-Environment=PATH=${options.pathEnv}
-WorkingDirectory=${options.homeDir}
-
-[Install]
-WantedBy=default.target
-`;
-}
-function installService(options) {
-  const homeDir = options.homeDir ?? os2.homedir();
-  const autoUpgrade = options.autoUpgrade;
-  const release = installManagedRelease({
-    packageName: options.packageName,
-    version: options.version,
-    homeDir
-  });
-  writeServiceUnit({
-    agentName: options.agentName,
-    autoUpgrade,
-    cliPath: release.cliPath,
-    homeDir
-  });
-  runSystemctl(["--user", "daemon-reload"]);
-  runSystemctl(["--user", "enable", SERVICE_NAME]);
-  runSystemctl(["--user", "restart", SERVICE_NAME]);
-  runCommand("loginctl", ["enable-linger", os2.userInfo().username]);
-}
-function upgradeService(options) {
-  const homeDir = options.homeDir ?? os2.homedir();
-  const installedConfig = readInstalledServiceConfig(homeDir);
-  const autoUpgrade = options.autoUpgrade ?? installedConfig?.autoUpgrade ?? true;
-  const release = installManagedRelease({
-    packageName: options.packageName,
-    version: options.version,
-    homeDir
-  });
-  writeServiceUnit({
-    agentName: options.agentName,
-    autoUpgrade,
-    cliPath: release.cliPath,
-    homeDir
-  });
-  runSystemctl(["--user", "daemon-reload"]);
-  runSystemctl(["--user", "restart", SERVICE_NAME]);
-}
-function uninstallService(homeDir = os2.homedir()) {
-  const unitPath = servicePath(homeDir);
-  try {
-    runSystemctl(["--user", "stop", SERVICE_NAME]);
-  } catch {
-  }
-  try {
-    runSystemctl(["--user", "disable", SERVICE_NAME]);
-  } catch {
-  }
-  if (fs2.existsSync(unitPath)) {
-    fs2.unlinkSync(unitPath);
-  }
-  try {
-    runSystemctl(["--user", "daemon-reload"]);
-  } catch {
-  }
-}
-function readInstalledServiceConfig(homeDir = os2.homedir()) {
-  const unitPath = servicePath(homeDir);
-  if (!fs2.existsSync(unitPath)) {
-    return null;
-  }
-  const unit = fs2.readFileSync(unitPath, "utf-8");
-  const autoUpgradeMatch = unit.match(/^Environment=WEBMUX_AGENT_AUTO_UPGRADE=(\d)$/m);
-  const versionMatch = unit.match(/\/releases\/([^/\s]+)\/node_modules\//);
-  return {
-    autoUpgrade: autoUpgradeMatch?.[1] !== "0",
-    version: versionMatch?.[1] ?? null
-  };
-}
-function servicePath(homeDir = os2.homedir()) {
-  return path2.join(homeDir, ".config", "systemd", "user", `${SERVICE_NAME}.service`);
-}
-function writeServiceUnit(options) {
-  const serviceDir = path2.dirname(servicePath(options.homeDir));
-  fs2.mkdirSync(serviceDir, { recursive: true });
-  fs2.writeFileSync(
-    servicePath(options.homeDir),
-    renderServiceUnit({
-      agentName: options.agentName,
-      autoUpgrade: options.autoUpgrade,
-      cliPath: options.cliPath,
-      homeDir: options.homeDir,
-      nodePath: findBinary("node") ?? process.execPath,
-      pathEnv: process.env.PATH ?? ""
-    })
-  );
-}
-function installManagedRelease(options) {
-  const releaseDir = path2.join(options.homeDir, ".webmux", "releases", options.version);
-  const cliPath = path2.join(
-    releaseDir,
-    "node_modules",
-    ...options.packageName.split("/"),
-    "dist",
-    "cli.js"
-  );
-  if (fs2.existsSync(cliPath)) {
-    return { cliPath, releaseDir };
-  }
-  fs2.mkdirSync(releaseDir, { recursive: true });
-  ensureRuntimePackageJson(releaseDir);
-  const packageManager = findBinary("pnpm") ? "pnpm" : "npm";
-  if (packageManager === "pnpm") {
-    runCommand("pnpm", ["add", "--dir", releaseDir, `${options.packageName}@${options.version}`]);
-  } else {
-    if (!findBinary("npm")) {
-      throw new Error("Cannot find pnpm or npm. Install one package manager before installing the service.");
-    }
-    runCommand("npm", ["install", "--omit=dev", `${options.packageName}@${options.version}`], releaseDir);
-  }
-  if (!fs2.existsSync(cliPath)) {
-    throw new Error(`Managed release did not produce a CLI at ${cliPath}`);
-  }
-  return { cliPath, releaseDir };
-}
-function ensureRuntimePackageJson(releaseDir) {
-  const packageJsonPath = path2.join(releaseDir, "package.json");
-  if (fs2.existsSync(packageJsonPath)) {
-    return;
-  }
-  fs2.writeFileSync(
-    packageJsonPath,
-    JSON.stringify({
-      name: "webmux-agent-runtime",
-      private: true
-    }, null, 2) + "\n"
-  );
-}
-function runSystemctl(args) {
-  runCommand("systemctl", args);
-}
-function runCommand(command, args, cwd) {
-  execFileSync(command, args, {
-    cwd,
-    stdio: "inherit"
-  });
-}
-function findBinary(name) {
-  try {
-    return execFileSync("which", [name], { encoding: "utf-8" }).trim();
-  } catch {
-    return null;
-  }
-}
-
-// src/terminal.ts
-import { spawn } from "node-pty";
-
-// src/tmux.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var FIELD_SEPARATOR = "";
-var SESSION_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,31}$/;
-var TMUX_EMPTY_STATE_MARKERS = [
-  "error connecting to",
-  "failed to connect to server",
-  "no server running",
-  "no sessions"
-];
-var TmuxClient = class {
-  socketName;
-  workspaceRoot;
-  constructor(options) {
-    this.socketName = options.socketName;
-    this.workspaceRoot = options.workspaceRoot;
-  }
-  async listSessions() {
-    const stdout = await this.run(
-      [
-        "list-sessions",
-        "-F",
-        [
-          "#{session_name}",
-          "#{session_windows}",
-          "#{session_attached}",
-          "#{session_created}",
-          "#{session_activity}",
-          "#{session_path}",
-          "#{pane_current_command}"
-        ].join(FIELD_SEPARATOR)
-      ],
-      { allowEmptyState: true }
-    );
-    const sessions = parseSessionList(stdout);
-    const enriched = await Promise.all(
-      sessions.map(async (session) => ({
-        ...session,
-        preview: await this.getPreview(session.name)
-      }))
-    );
-    return enriched.sort((left, right) => {
-      if (left.lastActivityAt !== right.lastActivityAt) {
-        return right.lastActivityAt - left.lastActivityAt;
-      }
-      return left.name.localeCompare(right.name);
-    });
-  }
-  async createSession(name) {
-    assertValidSessionName(name);
-    if (await this.hasSession(name)) {
-      return;
-    }
-    await this.run(["new-session", "-d", "-s", name, "-c", this.workspaceRoot]);
-  }
-  async killSession(name) {
-    assertValidSessionName(name);
-    await this.run(["kill-session", "-t", name]);
-  }
-  async readSession(name) {
-    const sessions = await this.listSessions();
-    return sessions.find((session) => session.name === name) ?? null;
-  }
-  async hasSession(name) {
-    try {
-      await this.run(["has-session", "-t", name]);
-      return true;
-    } catch (error) {
-      const message = String(
-        error.stderr ?? error.message
-      );
-      if (isTmuxEmptyStateMessage(message)) {
-        return false;
-      }
-      return false;
-    }
-  }
-  async getPreview(name) {
-    try {
-      const stdout = await this.run(
-        ["capture-pane", "-p", "-J", "-S", "-18", "-E", "-", "-t", `${name}:`],
-        { allowEmptyState: true }
-      );
-      return formatPreview(stdout);
-    } catch {
-      return ["Session available. Tap to attach."];
-    }
-  }
-  async run(args, options = {}) {
+// src/cli.ts
+async function loadAgentRuntime() {
+  const [{ AgentConnection }, { TmuxClient }] = await Promise.all([
+    import("./connection-RJY775NL.js"),
+    import("./tmux-QIB4H3UA.js")
+  ]);
+  return { AgentConnection, TmuxClient };
+}
+function createProgram() {
+  const program = new Command();
+  program.name("webmux-agent").description("Webmux agent \u2014 connects your machine to the webmux server").version(AGENT_VERSION);
+  program.command("register").description("Register this agent with a webmux server").requiredOption("--server <url>", "Server URL (e.g. https://webmux.example.com)").requiredOption("--token <token>", "One-time registration token from the server").option("--name <name>", "Display name for this agent (defaults to hostname)").action(async (opts) => {
+    const serverUrl = opts.server.replace(/\/+$/, "");
+    const agentName = opts.name ?? os2.hostname();
+    console.log(`[agent] Registering with server ${serverUrl}...`);
+    console.log(`[agent] Agent name: ${agentName}`);
+    const body = {
+      token: opts.token,
+      name: agentName
+    };
+    let response;
     try {
-      const { stdout } = await execFileAsync(
-        "tmux",
-        ["-L", this.socketName, ...args],
-        {
-          cwd: this.workspaceRoot,
-          env: {
-            ...process.env,
-            TERM: "xterm-256color"
-          }
-        }
-      );
-      return stdout;
-    } catch (error) {
-      const message = String(
-        error.stderr ?? error.message
-      );
-      if (options.allowEmptyState && TMUX_EMPTY_STATE_MARKERS.some((marker) => message.includes(marker))) {
-        return "";
-      }
-      throw error;
-    }
-  }
-};
-function assertValidSessionName(name) {
-  if (!SESSION_NAME_PATTERN.test(name)) {
-    throw new Error(
-      "Invalid session name. Use up to 32 letters, numbers, dot, dash, or underscore."
-    );
-  }
-}
-function parseSessionList(stdout) {
-  return stdout.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
-    const parts = line.split(FIELD_SEPARATOR);
-    const [name, windows, attachedClients, createdAt, lastActivityAt, path3] = parts;
-    const currentCommand = parts[6] ?? "";
-    if (!name || !windows || !attachedClients || !createdAt || !lastActivityAt || !path3) {
-      return [];
-    }
-    return [
-      {
-        name,
-        windows: Number(windows),
-        attachedClients: Number(attachedClients),
-        createdAt: Number(createdAt),
-        lastActivityAt: Number(lastActivityAt),
-        path: path3,
-        currentCommand
-      }
-    ];
-  });
-}
-function formatPreview(stdout) {
-  const lines = stdout.replaceAll("\r", "").split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0).slice(-3);
-  if (lines.length > 0) {
-    return lines;
-  }
-  return ["Fresh session. Nothing has run yet."];
-}
-function isTmuxEmptyStateMessage(message) {
-  return TMUX_EMPTY_STATE_MARKERS.some((marker) => message.includes(marker));
-}
-
-// src/terminal.ts
-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";
-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;
-  onOutput;
-  ptyProcess = null;
-  currentStatus = "starting";
-  outputBuffer = [];
-  debounceTimer = null;
-  disposed = false;
-  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.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;
-      }
-      this.onOutput(data);
-      this.appendToBuffer(data);
-      this.scheduleStatusDetection();
-    });
-    ptyProcess.onExit(({ exitCode }) => {
-      if (this.disposed) {
-        return;
-      }
-      if (this.debounceTimer) {
-        clearTimeout(this.debounceTimer);
-        this.debounceTimer = null;
-      }
-      if (exitCode === 0) {
-        this.emitStatus("success");
-      } else {
-        this.emitStatus("failed");
-      }
-      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.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/version.ts
-import fs3 from "fs";
-var packageMetadata = readAgentPackageMetadata();
-var AGENT_PACKAGE_NAME = packageMetadata.name;
-var AGENT_VERSION = packageMetadata.version;
-function readAgentPackageMetadata() {
-  const packageJsonPath = new URL("../package.json", import.meta.url);
-  const raw = fs3.readFileSync(packageJsonPath, "utf-8");
-  const parsed = JSON.parse(raw);
-  if (!parsed.name || !parsed.version) {
-    throw new Error("Agent package metadata is missing name or version");
-  }
-  return {
-    name: parsed.name,
-    version: parsed.version
-  };
-}
-
-// 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
+      response = await fetch(`${serverUrl}/api/agents/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
       });
-    });
-    ws.on("message", (raw) => {
-      let msg;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[agent] Failed to connect to server: ${message}`);
+      process.exit(1);
+    }
+    if (!response.ok) {
+      let errorMessage;
       try {
-        msg = JSON.parse(raw.toString());
+        const errorBody = await response.json();
+        errorMessage = errorBody.error ?? response.statusText;
       } catch {
-        console.error("[agent] Failed to parse server message:", raw.toString());
-        return;
+        errorMessage = response.statusText;
       }
-      this.handleMessage(msg);
+      console.error(`[agent] Registration failed: ${errorMessage}`);
+      process.exit(1);
+    }
+    const result = await response.json();
+    saveCredentials({
+      serverUrl,
+      agentId: result.agentId,
+      agentSecret: result.agentSecret,
+      name: agentName
     });
-    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);
+    console.log(`[agent] Registration successful!`);
+    console.log(`[agent] Agent ID: ${result.agentId}`);
+    console.log(`[agent] Credentials saved to ${credentialsPath()}`);
+    console.log(``);
+    console.log(`Next steps:`);
+    console.log(`  pnpm dlx @webmux/agent start         # run once`);
+    console.log(`  pnpm dlx @webmux/agent service install    # install as managed systemd service`);
+  });
+  program.command("start").description("Start the agent and connect to the server").action(async () => {
+    const creds = loadCredentials();
+    if (!creds) {
+      console.error(
+        `[agent] No credentials found at ${credentialsPath()}. Run "npx @webmux/agent register" first.`
+      );
+      process.exit(1);
+    }
+    const { AgentConnection, TmuxClient } = await loadAgentRuntime();
+    console.log(`[agent] Starting agent "${creds.name}"...`);
+    console.log(`[agent] Server: ${creds.serverUrl}`);
+    console.log(`[agent] Agent ID: ${creds.agentId}`);
+    const tmux = new TmuxClient({
+      socketName: "webmux",
+      workspaceRoot: os2.homedir()
     });
-  }
-  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 "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-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);
-    }
+    const connection = new AgentConnection(
+      creds.serverUrl,
+      creds.agentId,
+      creds.agentSecret,
+      tmux
+    );
+    const shutdown = () => {
+      console.log("\n[agent] Shutting down...");
+      connection.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    connection.start();
+  });
+  program.command("status").description("Show agent status and credentials info").action(() => {
+    const creds = loadCredentials();
+    if (!creds) {
+      console.log(`[agent] Not registered. No credentials found at ${credentialsPath()}.`);
+      process.exit(0);
+    }
+    console.log(`Agent Name:       ${creds.name}`);
+    console.log(`Agent Version:    ${AGENT_VERSION}`);
+    console.log(`Server URL:       ${creds.serverUrl}`);
+    console.log(`Agent ID:         ${creds.agentId}`);
+    console.log(`Credentials File: ${credentialsPath()}`);
+    const installedService = readInstalledServiceConfig();
     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}` });
+      const result = execFileSync("systemctl", ["--user", "is-active", SERVICE_NAME], { encoding: "utf-8" }).trim();
+      console.log(`Service:          ${result}`);
+    } catch {
+      console.log(`Service:          not installed`);
     }
-  }
-  handleTerminalDetach(browserId) {
-    const bridge = this.bridges.get(browserId);
-    if (bridge) {
-      bridge.dispose();
-      this.bridges.delete(browserId);
-      void this.syncSessions();
+    if (installedService?.version) {
+      console.log(`Service Version:  ${installedService.version}`);
     }
-  }
-  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);
+  });
+  const service = program.command("service").description("Manage the systemd service");
+  service.command("install").description("Install and start the agent as a managed systemd user service").option("--no-auto-upgrade", "Disable automatic upgrades for the managed service").action((opts) => {
+    const creds = loadCredentials();
+    if (!creds) {
+      console.error(`[agent] Not registered. Run "npx @webmux/agent register" first.`);
+      process.exit(1);
     }
-  }
-  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 });
+      installService({
+        agentName: creds.name,
+        packageName: AGENT_PACKAGE_NAME,
+        version: AGENT_VERSION,
+        autoUpgrade: opts.autoUpgrade
+      });
+      console.log(``);
+      console.log(`[agent] Service installed and started!`);
+      console.log(`[agent] Managed version: ${AGENT_VERSION}`);
+      console.log(`[agent] It will auto-start on boot.`);
+      console.log(``);
+      console.log(`Useful commands:`);
+      console.log(`  systemctl --user status ${SERVICE_NAME}`);
+      console.log(`  journalctl --user -u ${SERVICE_NAME} -f`);
+      console.log(`  pnpm dlx @webmux/agent service upgrade --to <version>`);
+      console.log(`  pnpm dlx @webmux/agent service uninstall`);
     } 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 });
+      console.error(`[agent] Failed to install managed service: ${message}`);
+      console.error(`[agent] Service file path: ${servicePath()}`);
+      process.exit(1);
     }
-  }
-  async handleSessionKill(requestId, name) {
+  });
+  service.command("uninstall").description("Stop and remove the systemd user service").action(() => {
     try {
-      await this.tmux.killSession(name);
-      await this.syncSessions();
-      this.sendMessage({ type: "command-result", requestId, ok: true });
+      uninstallService();
+      console.log(`[agent] Service file removed: ${servicePath()}`);
+      console.log(`[agent] Service uninstalled.`);
     } 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 });
-    }
-  }
-  sendMessage(msg) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
+      console.error(`[agent] Failed to uninstall service: ${message}`);
+      process.exit(1);
     }
-  }
-  applyRecommendedUpgrade(upgradePolicy) {
-    const targetVersion = upgradePolicy?.targetVersion;
-    if (!targetVersion) {
-      return false;
-    }
-    let comparison;
+  });
+  service.command("status").description("Show systemd service status").action(() => {
     try {
-      comparison = compareSemanticVersions(this.runtime.version, targetVersion);
+      execFileSync("systemctl", ["--user", "status", SERVICE_NAME], { stdio: "inherit" });
     } catch {
-      console.warn("[agent] Skipping automatic upgrade because version parsing failed");
-      return false;
-    }
-    if (comparison >= 0) {
-      return false;
+      console.log(`[agent] Service is not installed or not running.`);
     }
-    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;
+  });
+  service.command("upgrade").description("Switch the managed service to a specific agent version and restart it").requiredOption("--to <version>", "Target agent version (for example 0.1.5)").action((opts) => {
+    const creds = loadCredentials();
+    if (!creds) {
+      console.error(`[agent] Not registered. Run "npx @webmux/agent register" first.`);
+      process.exit(1);
     }
+    console.log(`[agent] Switching managed service to ${opts.to}...`);
     try {
-      this.runtime.applyServiceUpgrade({
-        packageName: upgradePolicy.packageName || AGENT_PACKAGE_NAME,
-        targetVersion
+      upgradeService({
+        agentName: creds.name,
+        packageName: AGENT_PACKAGE_NAME,
+        version: opts.to
       });
-      console.log(`[agent] Managed service switched to ${targetVersion}. Restarting...`);
+      console.log("[agent] Managed service updated successfully.");
     } 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 });
-      },
-      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}`);
-    }
-  }
-  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}`);
+      console.error(`[agent] Failed to upgrade managed service: ${message}`);
+      process.exit(1);
     }
-  }
-  onDisconnect() {
-    this.stopHeartbeat();
-    this.stopSessionSync();
-    this.disposeAllBridges();
-    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();
-}
-
-// src/cli.ts
-var program = new Command();
-program.name("webmux-agent").description("Webmux agent \u2014 connects your machine to the webmux server").version(AGENT_VERSION);
-program.command("register").description("Register this agent with a webmux server").requiredOption("--server <url>", "Server URL (e.g. https://webmux.example.com)").requiredOption("--token <token>", "One-time registration token from the server").option("--name <name>", "Display name for this agent (defaults to hostname)").action(async (opts) => {
-  const serverUrl = opts.server.replace(/\/+$/, "");
-  const agentName = opts.name ?? os3.hostname();
-  console.log(`[agent] Registering with server ${serverUrl}...`);
-  console.log(`[agent] Agent name: ${agentName}`);
-  const body = {
-    token: opts.token,
-    name: agentName
-  };
-  let response;
-  try {
-    response = await fetch(`${serverUrl}/api/agents/register`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[agent] Failed to connect to server: ${message}`);
-    process.exit(1);
-  }
-  if (!response.ok) {
-    let errorMessage;
-    try {
-      const errorBody = await response.json();
-      errorMessage = errorBody.error ?? response.statusText;
-    } catch {
-      errorMessage = response.statusText;
-    }
-    console.error(`[agent] Registration failed: ${errorMessage}`);
-    process.exit(1);
-  }
-  const result = await response.json();
-  saveCredentials({
-    serverUrl,
-    agentId: result.agentId,
-    agentSecret: result.agentSecret,
-    name: agentName
-  });
-  console.log(`[agent] Registration successful!`);
-  console.log(`[agent] Agent ID: ${result.agentId}`);
-  console.log(`[agent] Credentials saved to ${credentialsPath()}`);
-  console.log(``);
-  console.log(`Next steps:`);
-  console.log(`  pnpm dlx @webmux/agent start         # run once`);
-  console.log(`  pnpm dlx @webmux/agent service install    # install as managed systemd service`);
-});
-program.command("start").description("Start the agent and connect to the server").action(() => {
-  const creds = loadCredentials();
-  if (!creds) {
-    console.error(
-      `[agent] No credentials found at ${credentialsPath()}. Run "npx @webmux/agent register" first.`
-    );
-    process.exit(1);
-  }
-  console.log(`[agent] Starting agent "${creds.name}"...`);
-  console.log(`[agent] Server: ${creds.serverUrl}`);
-  console.log(`[agent] Agent ID: ${creds.agentId}`);
-  const tmux = new TmuxClient({
-    socketName: "webmux",
-    workspaceRoot: os3.homedir()
   });
-  const connection = new AgentConnection(
-    creds.serverUrl,
-    creds.agentId,
-    creds.agentSecret,
-    tmux
-  );
-  const shutdown = () => {
-    console.log("\n[agent] Shutting down...");
-    connection.stop();
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  connection.start();
-});
-program.command("status").description("Show agent status and credentials info").action(() => {
-  const creds = loadCredentials();
-  if (!creds) {
-    console.log(`[agent] Not registered. No credentials found at ${credentialsPath()}.`);
-    process.exit(0);
-  }
-  console.log(`Agent Name:       ${creds.name}`);
-  console.log(`Agent Version:    ${AGENT_VERSION}`);
-  console.log(`Server URL:       ${creds.serverUrl}`);
-  console.log(`Agent ID:         ${creds.agentId}`);
-  console.log(`Credentials File: ${credentialsPath()}`);
-  const installedService = readInstalledServiceConfig();
-  try {
-    const result = execFileSync2("systemctl", ["--user", "is-active", SERVICE_NAME], { encoding: "utf-8" }).trim();
-    console.log(`Service:          ${result}`);
-  } catch {
-    console.log(`Service:          not installed`);
-  }
-  if (installedService?.version) {
-    console.log(`Service Version:  ${installedService.version}`);
-  }
-});
-var service = program.command("service").description("Manage the systemd service");
-service.command("install").description("Install and start the agent as a managed systemd user service").option("--no-auto-upgrade", "Disable automatic upgrades for the managed service").action((opts) => {
-  const creds = loadCredentials();
-  if (!creds) {
-    console.error(`[agent] Not registered. Run "npx @webmux/agent register" first.`);
-    process.exit(1);
-  }
-  try {
-    installService({
-      agentName: creds.name,
-      packageName: AGENT_PACKAGE_NAME,
-      version: AGENT_VERSION,
-      autoUpgrade: opts.autoUpgrade
-    });
-    console.log(``);
-    console.log(`[agent] Service installed and started!`);
-    console.log(`[agent] Managed version: ${AGENT_VERSION}`);
-    console.log(`[agent] It will auto-start on boot.`);
-    console.log(``);
-    console.log(`Useful commands:`);
-    console.log(`  systemctl --user status ${SERVICE_NAME}`);
-    console.log(`  journalctl --user -u ${SERVICE_NAME} -f`);
-    console.log(`  pnpm dlx @webmux/agent service upgrade --to <version>`);
-    console.log(`  pnpm dlx @webmux/agent service uninstall`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[agent] Failed to install managed service: ${message}`);
-    console.error(`[agent] Service file path: ${servicePath()}`);
-    process.exit(1);
-  }
-});
-service.command("uninstall").description("Stop and remove the systemd user service").action(() => {
-  try {
-    uninstallService();
-    console.log(`[agent] Service file removed: ${servicePath()}`);
-    console.log(`[agent] Service uninstalled.`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[agent] Failed to uninstall service: ${message}`);
-    process.exit(1);
-  }
-});
-service.command("status").description("Show systemd service status").action(() => {
-  try {
-    execFileSync2("systemctl", ["--user", "status", SERVICE_NAME], { stdio: "inherit" });
-  } catch {
-    console.log(`[agent] Service is not installed or not running.`);
-  }
-});
-service.command("upgrade").description("Switch the managed service to a specific agent version and restart it").requiredOption("--to <version>", "Target agent version (for example 0.1.5)").action((opts) => {
-  const creds = loadCredentials();
-  if (!creds) {
-    console.error(`[agent] Not registered. Run "npx @webmux/agent register" first.`);
-    process.exit(1);
-  }
-  console.log(`[agent] Switching managed service to ${opts.to}...`);
-  try {
-    upgradeService({
-      agentName: creds.name,
-      packageName: AGENT_PACKAGE_NAME,
-      version: opts.to
-    });
-    console.log("[agent] Managed service updated successfully.");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[agent] Failed to upgrade managed service: ${message}`);
-    process.exit(1);
+  return program;
+}
+async function run(argv = process.argv) {
+  await createProgram().parseAsync(argv);
+}
+function isDirectExecution() {
+  const entryPath = process.argv[1];
+  if (!entryPath) {
+    return false;
   }
-});
-program.parse();
+  return import.meta.url === pathToFileURL(entryPath).href;
+}
+if (isDirectExecution()) {
+  void run();
+}
+export {
+  createProgram,
+  run
+};