@webmux/agent 0.1.4 → 0.2.0

package/dist/cli.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs2 from "fs";
-import os2 from "os";
-import path2 from "path";
-import { execSync as execSync2 } from "child_process";
+import os3 from "os";
+import { execFileSync as execFileSync2 } from "child_process";
 import { Command } from "commander";
 
 // src/credentials.ts
@@ -43,6 +41,258 @@ 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";
@@ -197,19 +447,6 @@ function isTmuxEmptyStateMessage(message) {
   return TMUX_EMPTY_STATE_MARKERS.some((marker) => message.includes(marker));
 }
 
-// src/connection.ts
-import { execSync } from "child_process";
-import WebSocket from "ws";
-
-// src/terminal.ts
-import { spawn } from "node-pty";
-
-// ../shared/src/contracts.ts
-var DEFAULT_TERMINAL_SIZE = {
-  cols: 120,
-  rows: 36
-};
-
 // src/terminal.ts
 async function createTerminalBridge(options) {
   const {
@@ -253,29 +490,265 @@ async function createTerminalBridge(options) {
   };
 }
 
+// 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 AGENT_VERSION = "0.1.4";
 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) {
+  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;
@@ -290,6 +763,7 @@ var AgentConnection = class {
     this.stopHeartbeat();
     this.stopSessionSync();
     this.disposeAllBridges();
+    this.disposeAllRuns();
     if (this.ws) {
       this.ws.close(1e3, "agent shutting down");
       this.ws = null;
@@ -303,7 +777,12 @@ var AgentConnection = class {
     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: AGENT_VERSION });
+      this.sendMessage({
+        type: "auth",
+        agentId: this.agentId,
+        agentSecret: this.agentSecret,
+        version: this.runtime.version
+      });
     });
     ws.on("message", (raw) => {
       let msg;
@@ -327,9 +806,7 @@ var AgentConnection = class {
     switch (msg.type) {
       case "auth-ok":
         console.log("[agent] Authenticated successfully");
-        if (msg.latestVersion && msg.latestVersion !== AGENT_VERSION) {
-          console.log(`[agent] Update available: ${AGENT_VERSION} \u2192 ${msg.latestVersion}`);
-          this.selfUpdate(msg.latestVersion);
+        if (this.applyRecommendedUpgrade(msg.upgradePolicy)) {
           return;
         }
         this.startHeartbeat();
@@ -343,7 +820,7 @@ var AgentConnection = class {
           this.ws.close();
           this.ws = null;
         }
-        process.exit(1);
+        this.runtime.exit(1);
         break;
       case "sessions-list":
         this.syncSessions();
@@ -366,6 +843,21 @@ var AgentConnection = class {
       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);
     }
@@ -457,26 +949,47 @@ var AgentConnection = class {
       this.sendMessage({ type: "command-result", requestId, ok: false, error: message });
     }
   }
-  selfUpdate(targetVersion) {
-    console.log(`[agent] Installing @webmux/agent@${targetVersion}...`);
+  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 {
-      execSync(`npm install -g @webmux/agent@${targetVersion}`, { stdio: "inherit" });
-      console.log("[agent] Update installed. Restarting...");
+      this.runtime.applyServiceUpgrade({
+        packageName: upgradePolicy.packageName || AGENT_PACKAGE_NAME,
+        targetVersion
+      });
+      console.log(`[agent] Managed service switched to ${targetVersion}. Restarting...`);
     } catch (err) {
-      console.error("[agent] Update failed:", err instanceof Error ? err.message : 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");
-      this.startHeartbeat();
-      this.startSessionSync();
-      this.syncSessions();
-      return;
+      return false;
     }
     this.stop();
-    process.exit(0);
-  }
-  sendMessage(msg) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
+    this.runtime.exit(0);
+    return true;
   }
   startHeartbeat() {
     this.stopHeartbeat();
@@ -508,6 +1021,76 @@ var AgentConnection = class {
       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}`);
+    }
+  }
   onDisconnect() {
     this.stopHeartbeat();
     this.stopSessionSync();
@@ -531,12 +1114,11 @@ function buildWsUrl(serverUrl) {
 }
 
 // src/cli.ts
-var SERVICE_NAME = "webmux-agent";
 var program = new Command();
-program.name("webmux-agent").description("Webmux agent \u2014 connects your machine to the webmux server").version("0.0.0");
+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();
+  const agentName = opts.name ?? os3.hostname();
   console.log(`[agent] Registering with server ${serverUrl}...`);
   console.log(`[agent] Agent name: ${agentName}`);
   const body = {
@@ -578,8 +1160,8 @@ program.command("register").description("Register this agent with a webmux serve
   console.log(`[agent] Credentials saved to ${credentialsPath()}`);
   console.log(``);
   console.log(`Next steps:`);
-  console.log(`  npx @webmux/agent start              # run once`);
-  console.log(`  npx @webmux/agent service install     # install as systemd service`);
+  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();
@@ -594,7 +1176,7 @@ program.command("start").description("Start the agent and connect to the server"
   console.log(`[agent] Agent ID: ${creds.agentId}`);
   const tmux = new TmuxClient({
     socketName: "webmux",
-    workspaceRoot: os2.homedir()
+    workspaceRoot: os3.homedir()
   });
   const connection = new AgentConnection(
     creds.serverUrl,
@@ -618,119 +1200,88 @@ program.command("status").description("Show agent status and credentials info").
     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 = execSync2(`systemctl --user is-active ${SERVICE_NAME} 2>/dev/null`, { encoding: "utf-8" }).trim();
+    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 systemd user service").action(() => {
+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);
   }
-  const npxPath = findBinary("npx");
-  if (!npxPath) {
-    console.error(`[agent] Cannot find npx. Make sure Node.js is installed.`);
-    process.exit(1);
-  }
-  const serviceDir = path2.join(os2.homedir(), ".config", "systemd", "user");
-  const servicePath = path2.join(serviceDir, `${SERVICE_NAME}.service`);
-  const npmPath = findBinary("npm") ?? "npm";
-  const unit = `[Unit]
-Description=Webmux Agent (${creds.name})
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStartPre=${npmPath} install -g @webmux/agent@latest
-ExecStart=${findBinary("webmux-agent") ?? `${npxPath} -y @webmux/agent`} start
-Restart=always
-RestartSec=10
-Environment=HOME=${os2.homedir()}
-Environment=PATH=${process.env.PATH}
-WorkingDirectory=${os2.homedir()}
-
-[Install]
-WantedBy=default.target
-`;
-  fs2.mkdirSync(serviceDir, { recursive: true });
-  fs2.writeFileSync(servicePath, unit);
-  console.log(`[agent] Service file created: ${servicePath}`);
   try {
-    execSync2("systemctl --user daemon-reload", { stdio: "inherit" });
-    execSync2(`systemctl --user enable ${SERVICE_NAME}`, { stdio: "inherit" });
-    execSync2(`systemctl --user start ${SERVICE_NAME}`, { stdio: "inherit" });
-    execSync2(`loginctl enable-linger ${os2.userInfo().username}`, { stdio: "inherit" });
+    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(`  npx @webmux/agent service uninstall`);
+    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 enable service: ${message}`);
-    console.error(`[agent] Service file was written to ${servicePath}`);
-    console.error(`[agent] You can try manually: systemctl --user enable --now ${SERVICE_NAME}`);
+    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(() => {
-  const servicePath = path2.join(os2.homedir(), ".config", "systemd", "user", `${SERVICE_NAME}.service`);
   try {
-    execSync2(`systemctl --user stop ${SERVICE_NAME} 2>/dev/null`, { stdio: "inherit" });
-    execSync2(`systemctl --user disable ${SERVICE_NAME} 2>/dev/null`, { stdio: "inherit" });
-  } catch {
-  }
-  if (fs2.existsSync(servicePath)) {
-    fs2.unlinkSync(servicePath);
-    console.log(`[agent] Service file removed: ${servicePath}`);
-  }
-  try {
-    execSync2("systemctl --user daemon-reload", { stdio: "inherit" });
-  } catch {
+    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);
   }
-  console.log(`[agent] Service uninstalled.`);
 });
 service.command("status").description("Show systemd service status").action(() => {
   try {
-    execSync2(`systemctl --user status ${SERVICE_NAME}`, { stdio: "inherit" });
+    execFileSync2("systemctl", ["--user", "status", SERVICE_NAME], { stdio: "inherit" });
   } catch {
     console.log(`[agent] Service is not installed or not running.`);
   }
 });
-service.command("upgrade").description("Upgrade agent to latest version and restart service").action(() => {
-  console.log("[agent] Upgrading @webmux/agent to latest...");
-  try {
-    execSync2("npm install -g @webmux/agent@latest", { stdio: "inherit" });
-  } catch {
-    console.error("[agent] Failed to upgrade. Try manually: npm install -g @webmux/agent@latest");
+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] Restarting service...");
+  console.log(`[agent] Switching managed service to ${opts.to}...`);
   try {
-    execSync2(`systemctl --user restart ${SERVICE_NAME}`, { stdio: "inherit" });
-    console.log("[agent] Upgrade complete!");
-  } catch {
-    console.log("[agent] Package upgraded. Service not installed or restart failed.");
-    console.log("[agent] If running manually, restart with: npx @webmux/agent@latest start");
+    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);
   }
 });
-function findBinary(name) {
-  try {
-    return execSync2(`which ${name} 2>/dev/null`, { encoding: "utf-8" }).trim();
-  } catch {
-    return null;
-  }
-}
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webmux/agent",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "type": "module",
   "bin": {
     "webmux-agent": "./dist/cli.js"