opencode-agent-tmux 1.2.0 → 1.2.2

package/dist/bin/opencode-tmux.js

@@ -4,14 +4,25 @@
 import { spawn, execSync } from "child_process";
 import { createServer } from "net";
 import { env, platform, exit, argv } from "process";
-import { existsSync } from "fs";
+import { existsSync, appendFileSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
 var OPENCODE_PORT_START = parseInt(env.OPENCODE_PORT || "4096", 10);
 var OPENCODE_PORT_MAX = OPENCODE_PORT_START + 10;
+var LOG_FILE = "/tmp/opencode-tmux.log";
+var HEALTH_TIMEOUT_MS = 1e3;
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
+function log(...args) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const message = `[${timestamp}] ${args.join(" ")}
+`;
+  try {
+    appendFileSync(LOG_FILE, message);
+  } catch {
+  }
+}
 function spawnPluginUpdater() {
   if (env.OPENCODE_TMUX_DISABLE_UPDATES === "1") return;
   const updaterPath = join(__dirname, "../scripts/update-plugins.js");
@@ -48,7 +59,6 @@ function findOpencodeBin() {
   const commonPaths = [
     join(homedir(), ".opencode", "bin", platform === "win32" ? "opencode.exe" : "opencode"),
     join(homedir(), "AppData", "Local", "opencode", "bin", "opencode.exe"),
-    // Common Windows location
     "/usr/local/bin/opencode",
     "/usr/bin/opencode"
   ];
@@ -70,9 +80,229 @@ function checkPort(port) {
     });
   });
 }
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function safeExec(command) {
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.trim();
+  } catch {
+    return null;
+  }
+}
+function getTmuxPanePids() {
+  if (!hasTmux()) return /* @__PURE__ */ new Set();
+  const output = safeExec("tmux list-panes -a -F '#{pane_pid}'");
+  if (!output) return /* @__PURE__ */ new Set();
+  const pids = output.split("\n").map((value) => Number.parseInt(value.trim(), 10)).filter((value) => Number.isFinite(value));
+  return new Set(pids);
+}
+async function isOpencodeHealthy(port) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+  const healthUrl = `http://127.0.0.1:${port}/health`;
+  try {
+    const response = await fetch(healthUrl, { signal: controller.signal }).catch(
+      () => null
+    );
+    return response?.ok ?? false;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function getListeningPids(port) {
+  if (platform === "win32") return [];
+  const output = safeExec(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`);
+  if (!output) return [];
+  return output.split("\n").map((value) => Number.parseInt(value.trim(), 10)).filter((value) => Number.isFinite(value));
+}
+function getProcessCommand(pid) {
+  const output = safeExec(`ps -p ${pid} -o command=`);
+  return output && output.length > 0 ? output : null;
+}
+function getProcessStat(pid) {
+  const output = safeExec(`ps -p ${pid} -o stat=`);
+  return output && output.length > 0 ? output.trim() : null;
+}
+function getProcessTty(pid) {
+  const output = safeExec(`ps -p ${pid} -o tty=`);
+  return output && output.length > 0 ? output.trim() : null;
+}
+function getTtyProcessIds(tty) {
+  const output = safeExec(`ps -t ${tty} -o pid=`);
+  if (!output) return [];
+  return output.split("\n").map((value) => Number.parseInt(value.trim(), 10)).filter((value) => Number.isFinite(value));
+}
+function hasOtherTtyProcesses(tty, pid) {
+  if (!tty || tty === "?" || tty === "??") return false;
+  const ttyPids = getTtyProcessIds(tty);
+  return ttyPids.some((ttyPid) => ttyPid !== pid);
+}
+function getParentPid(pid) {
+  const output = safeExec(`ps -p ${pid} -o ppid=`);
+  if (!output) return null;
+  const value = Number.parseInt(output.trim(), 10);
+  return Number.isFinite(value) ? value : null;
+}
+function isDescendantOf(pid, ancestors) {
+  let current = pid;
+  const visited = /* @__PURE__ */ new Set();
+  while (current > 1 && !visited.has(current)) {
+    if (ancestors.has(current)) return true;
+    visited.add(current);
+    const parent = getParentPid(current);
+    if (!parent || parent <= 1) return false;
+    current = parent;
+  }
+  return false;
+}
+function isForegroundProcess(pid) {
+  const stat = safeExec(`ps -p ${pid} -o stat=`);
+  if (!stat) return false;
+  return stat.includes("+");
+}
+async function getOpencodeSessionCount(port) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+  const statusUrl = `http://127.0.0.1:${port}/session/status`;
+  try {
+    const response = await fetch(statusUrl, { signal: controller.signal }).catch(
+      () => null
+    );
+    if (!response?.ok) return null;
+    const payload = await response.json().catch(() => null);
+    if (!payload || typeof payload !== "object") return null;
+    const maybeData = payload.data;
+    if (maybeData && typeof maybeData === "object" && !Array.isArray(maybeData)) {
+      return Object.keys(maybeData).length;
+    }
+    if (!Array.isArray(payload)) {
+      return Object.keys(payload).length;
+    }
+    return payload.length;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function tryReclaimPort(port, tmuxPanePids) {
+  if (platform === "win32") return false;
+  const healthy = await isOpencodeHealthy(port);
+  const pids = getListeningPids(port);
+  const sessionCount = healthy ? await getOpencodeSessionCount(port) : null;
+  const idleServer = healthy && sessionCount === 0;
+  log(
+    "Port scan:",
+    port.toString(),
+    "healthy",
+    String(healthy),
+    "sessions",
+    sessionCount === null ? "unknown" : sessionCount.toString(),
+    "idle",
+    String(idleServer),
+    "pids",
+    pids.length > 0 ? pids.join(",") : "none"
+  );
+  if (healthy && sessionCount !== null && sessionCount > 0) {
+    log("Port in use by active server:", port.toString());
+    return false;
+  }
+  if (pids.length === 0) {
+    return false;
+  }
+  let attemptedKill = false;
+  for (const pid of pids) {
+    const command = getProcessCommand(pid);
+    const tty = getProcessTty(pid);
+    const stat = getProcessStat(pid);
+    const hasTtyPeers = hasOtherTtyProcesses(tty, pid);
+    if (!command || !command.includes("opencode")) {
+      log("Port owned by non-opencode process, skipping:", port.toString());
+      continue;
+    }
+    const inTmux = tmuxPanePids.size > 0 && isDescendantOf(pid, tmuxPanePids);
+    log(
+      "Port process:",
+      port.toString(),
+      "pid",
+      pid.toString(),
+      "tty",
+      tty ?? "unknown",
+      "stat",
+      stat ?? "unknown",
+      "tmux",
+      String(inTmux),
+      "ttyPeers",
+      String(hasTtyPeers),
+      "idle",
+      String(idleServer),
+      "command",
+      command
+    );
+    if (!idleServer) {
+      if (inTmux) {
+        log("Port owned by tmux process, skipping:", port.toString(), pid.toString());
+        continue;
+      }
+      if (hasTtyPeers) {
+        log("Port owned by active tty process, skipping:", port.toString(), pid.toString());
+        continue;
+      }
+      if (healthy && sessionCount === null) {
+        log("Unable to read sessions, skipping:", port.toString(), pid.toString());
+        continue;
+      }
+      if (healthy && sessionCount !== null && sessionCount > 0) {
+        log("Port has active sessions, skipping:", port.toString(), pid.toString());
+        continue;
+      }
+      if (!healthy && !isForegroundProcess(pid)) {
+        log("Port owned by background opencode process, skipping:", port.toString(), pid.toString());
+        continue;
+      }
+    }
+    log("Attempting to stop stale opencode process:", port.toString(), pid.toString());
+    attemptedKill = true;
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  if (!attemptedKill) return false;
+  await new Promise((resolve) => setTimeout(resolve, 700));
+  for (const pid of pids) {
+    if (isProcessAlive(pid)) {
+      log("Process still alive, sending SIGKILL:", port.toString(), pid.toString());
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+  await new Promise((resolve) => setTimeout(resolve, 400));
+  return checkPort(port);
+}
 async function findAvailablePort() {
+  let tmuxPanePids = null;
   for (let port = OPENCODE_PORT_START; port <= OPENCODE_PORT_MAX; port++) {
     if (await checkPort(port)) return port;
+    if (!tmuxPanePids) {
+      tmuxPanePids = getTmuxPanePids();
+    }
+    const reclaimed = await tryReclaimPort(port, tmuxPanePids);
+    if (reclaimed && await checkPort(port)) return port;
   }
   return null;
 }
@@ -85,45 +315,75 @@ function hasTmux() {
   }
 }
 async function main() {
+  log("=== OpenCode Tmux Wrapper Started ===");
+  log("Process argv:", JSON.stringify(argv));
+  log("Current directory:", process.cwd());
   const opencodeBin = findOpencodeBin();
+  log("Found opencode binary:", opencodeBin);
   if (!opencodeBin) {
     console.error('Error: Could not find "opencode" binary in PATH or common locations.');
+    log("ERROR: opencode binary not found");
     exit(1);
   }
   spawnPluginUpdater();
   const port = await findAvailablePort();
+  log("Found available port:", port);
   if (!port) {
     console.error("Error: No available ports found in range 4096-4106.");
+    log("ERROR: No available ports");
     exit(1);
   }
   const env2 = { ...process.env };
   env2.OPENCODE_PORT = port.toString();
   const args = argv.slice(2);
+  log("User args:", JSON.stringify(args));
   const childArgs = ["--port", port.toString(), ...args];
+  log("Final childArgs:", JSON.stringify(childArgs));
   const inTmux = !!env2.TMUX;
   const tmuxAvailable = hasTmux();
+  log("In tmux?", inTmux);
+  log("Tmux available?", tmuxAvailable);
   if (inTmux || !tmuxAvailable) {
+    log("Running directly (in tmux or no tmux available)");
     const child = spawn(opencodeBin, childArgs, { stdio: "inherit", env: env2 });
-    child.on("close", (code) => exit(code ?? 0));
+    child.on("error", (err) => {
+      log("ERROR spawning child:", err.message);
+    });
+    child.on("close", (code) => {
+      log("Child exited with code:", code);
+      exit(code ?? 0);
+    });
     process.on("SIGINT", () => child.kill("SIGINT"));
     process.on("SIGTERM", () => child.kill("SIGTERM"));
   } else {
     console.log("\u{1F680} Launching tmux session...");
-    const safeCommand = [
-      `"${opencodeBin}"`,
-      `--port ${port}`,
-      ...args.map((a) => `"${a}"`)
-    ].join(" ");
-    const shellCommand = `${safeCommand} || { echo "Exit code: $?"; echo "Press Enter to close..."; read; }`;
+    log("Launching tmux session");
+    const escapedBin = opencodeBin.includes(" ") ? `'${opencodeBin}'` : opencodeBin;
+    const escapedArgs = childArgs.map((arg) => {
+      if (arg.includes(" ") || arg.includes('"') || arg.includes("'")) {
+        return `'${arg.replace(/'/g, "'\\''")}'`;
+      }
+      return arg;
+    });
+    const shellCommand = `${escapedBin} ${escapedArgs.join(" ")} || { echo "Exit code: $?"; echo "Press Enter to close..."; read; }`;
+    log("Shell command for tmux:", shellCommand);
     const tmuxArgs = [
       "new-session",
       shellCommand
     ];
+    log("Tmux args:", JSON.stringify(tmuxArgs));
     const child = spawn("tmux", tmuxArgs, { stdio: "inherit", env: env2 });
-    child.on("close", (code) => exit(code ?? 0));
+    child.on("error", (err) => {
+      log("ERROR spawning tmux:", err.message);
+    });
+    child.on("close", (code) => {
+      log("Tmux exited with code:", code);
+      exit(code ?? 0);
+    });
   }
 }
 main().catch((err) => {
+  log("FATAL ERROR:", err.message, err.stack);
   console.error(err);
   exit(1);
 });

package/dist/index.js

@@ -292,6 +292,7 @@ var TmuxSessionManager = class {
   sessions = /* @__PURE__ */ new Map();
   pollInterval;
   enabled = false;
+  shuttingDown = false;
   constructor(ctx, tmuxConfig, serverUrl) {
     this.client = ctx.client;
     this.tmuxConfig = tmuxConfig;
@@ -302,6 +303,9 @@ var TmuxSessionManager = class {
       tmuxConfig: this.tmuxConfig,
       serverUrl: this.serverUrl
     });
+    if (this.enabled) {
+      this.registerShutdownHandlers();
+    }
   }
   async onSessionCreated(event) {
     if (!this.enabled) return;
@@ -395,6 +399,41 @@ var TmuxSessionManager = class {
       }
     } catch (err) {
       log("[tmux-session-manager] poll error", { error: String(err) });
+      const serverAlive = await this.isServerAlive();
+      if (!serverAlive) {
+        await this.handleShutdown("server-unreachable");
+      }
+    }
+  }
+  registerShutdownHandlers() {
+    const handler = (reason) => {
+      void this.handleShutdown(reason);
+    };
+    process.once("SIGINT", () => handler("SIGINT"));
+    process.once("SIGTERM", () => handler("SIGTERM"));
+    process.once("SIGHUP", () => handler("SIGHUP"));
+    process.once("SIGQUIT", () => handler("SIGQUIT"));
+    process.once("beforeExit", () => handler("beforeExit"));
+  }
+  async handleShutdown(reason) {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    log("[tmux-session-manager] shutdown detected", { reason });
+    await this.cleanup();
+  }
+  async isServerAlive() {
+    const healthUrl = new URL("/health", this.serverUrl).toString();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1500);
+    try {
+      const response = await fetch(healthUrl, { signal: controller.signal }).catch(
+        () => null
+      );
+      return response?.ok ?? false;
+    } catch {
+      return false;
+    } finally {
+      clearTimeout(timeout);
     }
   }
   async closeSession(sessionId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-agent-tmux",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "OpenCode plugin that provides tmux integration for viewing agent execution in real-time",
   "type": "module",
   "main": "dist/index.js",