opentmux 1.3.11 → 1.5.3

package/dist/bin/opentmux.js

@@ -1,69 +1,618 @@
 #!/usr/bin/env node
 
 // src/bin/opentmux.ts
-import { spawn, execSync } from "child_process";
+import { spawn, execSync as execSync2 } from "child_process";
 import { createServer } from "net";
-import { env, platform, exit, argv } from "process";
-import { existsSync, appendFileSync } from "fs";
-import { join, dirname } from "path";
+import { env, platform as platform2, exit, argv } from "process";
+import { existsSync as existsSync2, appendFileSync as appendFileSync2 } from "fs";
+import { join as join3, 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;
+
+// src/utils/process.ts
+import { execSync } from "child_process";
+import { platform } from "os";
+function safeExec(command) {
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.trim();
+  } catch {
+    return null;
+  }
+}
+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 isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getProcessStartTime(pid) {
+  const output = safeExec(`ps -p ${pid} -o lstart=`);
+  if (!output) return null;
+  return Date.parse(output);
+}
+function getProcessCommand(pid) {
+  const output = safeExec(`ps -p ${pid} -o command=`);
+  return output && output.length > 0 ? output : null;
+}
+function safeKill(pid, signal = "SIGTERM") {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch (err) {
+    if (err.code === "ESRCH") return true;
+    return false;
+  }
+}
+async function waitForProcessExit(pid, timeoutMs = 2e3) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!isProcessAlive(pid)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return !isProcessAlive(pid);
+}
+function findProcessIds(pattern) {
+  if (platform() === "win32") return [];
+  const output = safeExec(`pgrep -f "${pattern}"`);
+  if (!output) return [];
+  return output.split("\n").map((value) => Number.parseInt(value.trim(), 10)).filter((value) => Number.isFinite(value));
+}
+
+// src/utils/logger.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var logFile = path.join(os.tmpdir(), "opencode-agent-tmux.log");
+function log(message, data) {
+  try {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
+`;
+    fs.appendFileSync(logFile, logEntry);
+  } catch {
+  }
+}
+
+// src/zombie-reaper.ts
+var OPENCODE_PORT_START = 4096;
+var ZombieReaper = class _ZombieReaper {
+  serverUrl;
+  options;
+  pollInterval;
+  candidates = /* @__PURE__ */ new Map();
+  isScanning = false;
+  lastActivityTime = Date.now();
+  constructor(serverUrl, options) {
+    this.serverUrl = serverUrl;
+    this.options = options;
+  }
+  /**
+   * Manual global reap command (for CLI).
+   * Scans ALL attach processes and checks them against their respective servers.
+   */
+  static async reapAll(options = {}) {
+    const opts = {
+      enabled: true,
+      intervalMs: 0,
+      minZombieChecks: 0,
+      // Instant kill for CLI (manual)
+      gracePeriodMs: 0,
+      // No grace for manual reap
+      ...options
+    };
+    log("[zombie-reaper] starting manual global reap");
+    const reaper = new _ZombieReaper("", opts);
+    const maxPorts = options.maxPorts || 10;
+    const endPort = OPENCODE_PORT_START + maxPorts;
+    const reapedServers = await _ZombieReaper.reapServers(OPENCODE_PORT_START, endPort);
+    if (reapedServers > 0) {
+      console.log(`Reaped ${reapedServers} inactive opencode servers.`);
+    }
+    const processes = await reaper.findAllAttachProcesses();
+    if (processes.length === 0) {
+      console.log("No opencode attach processes found.");
+      return;
+    }
+    console.log(`Found ${processes.length} attach processes. Checking statuses...`);
+    const byUrl = /* @__PURE__ */ new Map();
+    for (const p of processes) {
+      const url = p.targetUrl || "unknown";
+      const arr = byUrl.get(url) || [];
+      arr.push(p);
+      byUrl.set(url, arr);
+    }
+    let reapedCount = 0;
+    for (const [url, procs] of byUrl.entries()) {
+      if (url === "unknown") {
+        console.log(`\u26A0\uFE0F  Skipping ${procs.length} processes with unknown target URL`);
+        continue;
+      }
+      let activeSessions = null;
+      try {
+        activeSessions = await reaper.fetchActiveSessions(url);
+      } catch (err) {
+      }
+      if (activeSessions === null) {
+        console.warn(`\u26A0\uFE0F  Warning: Could not fetch active sessions from ${url}. Server likely stuck.`);
+        console.warn(`[zombie-reaper] Cleaning up ${procs.length} zombies attached to stuck server.`);
+        for (const p of procs) {
+          console.log(`\u{1F9DF} Zombie detected (Stuck Server): PID ${p.pid} (Session ${p.sessionId} on ${url})`);
+          await reaper.forceKill(p.pid);
+          reapedCount++;
+        }
+        continue;
+      }
+      for (const p of procs) {
+        if (!activeSessions.has(p.sessionId)) {
+          console.log(`\u{1F9DF} Zombie detected: PID ${p.pid} (Session ${p.sessionId} on ${url})`);
+          await reaper.forceKill(p.pid);
+          reapedCount++;
+        } else {
+        }
+      }
+    }
+    console.log(`Reap complete. Killed ${reapedCount} zombies.`);
+  }
+  async forceKill(pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  start() {
+    if (!this.options.enabled) return;
+    if (this.pollInterval) return;
+    log("[zombie-reaper] starting", this.options);
+    this.pollInterval = setInterval(() => this.scanOnce(), this.options.intervalMs);
+  }
+  stop() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = void 0;
+      log("[zombie-reaper] stopped");
+    }
+  }
+  async shutdown() {
+    this.stop();
+    log("[zombie-reaper] shutting down, running final scan");
+    await this.scanOnce();
+  }
+  async scanOnce() {
+    if (this.isScanning) return;
+    this.isScanning = true;
+    try {
+      const processes = await this.findAllAttachProcesses();
+      if (processes.length === 0) {
+        this.candidates.clear();
+        return;
+      }
+      const myProcesses = processes.filter((p) => this.areUrlsEqual(p.targetUrl, this.serverUrl));
+      if (myProcesses.length > 0) {
+        this.lastActivityTime = Date.now();
+      } else {
+        if (this.options.autoSelfDestruct && this.options.selfDestructTimeoutMs) {
+          const idleTime = Date.now() - this.lastActivityTime;
+          if (idleTime > this.options.selfDestructTimeoutMs) {
+            log("[zombie-reaper] Server abandoned (no clients). Self-destructing.", {
+              idleTimeMs: idleTime,
+              timeoutMs: this.options.selfDestructTimeoutMs
+            });
+            process.exit(0);
+          }
+        }
+      }
+      if (myProcesses.length === 0) {
+        this.pruneCandidates(/* @__PURE__ */ new Set());
+        return;
+      }
+      const activeSessions = await this.fetchActiveSessions(this.serverUrl);
+      if (activeSessions === null) {
+        log("[zombie-reaper] server unreachable, skipping scan");
+        return;
+      }
+      const currentPids = /* @__PURE__ */ new Set();
+      for (const proc of myProcesses) {
+        currentPids.add(proc.pid);
+        const isZombie = !activeSessions.has(proc.sessionId);
+        if (isZombie) {
+          this.markAsZombie(proc.pid);
+          if (this.shouldKill(proc.pid)) {
+            await this.reapProcess(proc);
+          }
+        } else {
+          if (this.candidates.has(proc.pid)) {
+            this.candidates.delete(proc.pid);
+          }
+        }
+      }
+      this.pruneCandidates(currentPids);
+    } catch (err) {
+      log("[zombie-reaper] scan error", { error: String(err) });
+    } finally {
+      this.isScanning = false;
+    }
+  }
+  pruneCandidates(currentPids) {
+    for (const pid of this.candidates.keys()) {
+      if (!currentPids.has(pid)) {
+        this.candidates.delete(pid);
+      }
+    }
+  }
+  areUrlsEqual(url1, url2) {
+    if (!url1) return false;
+    try {
+      const normalize = (u) => {
+        if (!u.match(/^https?:\/\//)) {
+          u = `http://${u}`;
+        }
+        const urlObj = new URL(u);
+        if (urlObj.hostname === "localhost") {
+          urlObj.hostname = "127.0.0.1";
+        }
+        return urlObj.origin;
+      };
+      return normalize(url1) === normalize(url2);
+    } catch {
+      return url1 === url2;
+    }
+  }
+  async findAllAttachProcesses() {
+    const pids = findProcessIds("opencode attach");
+    const results = [];
+    for (const pid of pids) {
+      const command = getProcessCommand(pid);
+      if (!command) continue;
+      const sessionMatch = command.match(/--session\s+([a-zA-Z0-9_-]+)/);
+      const urlMatch = command.match(/attach\s+([^\s]+)/);
+      if (sessionMatch && sessionMatch[1]) {
+        results.push({
+          pid,
+          sessionId: sessionMatch[1],
+          targetUrl: urlMatch ? urlMatch[1] : null,
+          command
+        });
+      }
+    }
+    return results;
+  }
+  // Exposed for testing
+  async classifyProcess(sessionId) {
+    const activeSessions = await this.fetchActiveSessions(this.serverUrl);
+    if (activeSessions === null) return "unknown";
+    return activeSessions.has(sessionId) ? "active" : "zombie";
+  }
+  async fetchActiveSessions(url) {
+    const statusUrl = new URL("/session/status", url).toString();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2e3);
+    try {
+      const response = await fetch(statusUrl, { signal: controller.signal }).catch((err) => {
+        if (process.env.DEBUG || process.env.VERBOSE) {
+          console.error(`[zombie-reaper] Fetch error for ${statusUrl}:`, err);
+        }
+        return null;
+      });
+      if (!response?.ok) {
+        if ((process.env.DEBUG || process.env.VERBOSE) && response) {
+          console.error(`[zombie-reaper] Server returned ${response.status} ${response.statusText} for ${statusUrl}`);
+        }
+        return null;
+      }
+      const payload = await response.json().catch(() => null);
+      if (!payload || typeof payload !== "object") return null;
+      const data = payload.data;
+      if (!data && typeof payload === "object" && !Array.isArray(payload)) {
+        const keys = Object.keys(payload);
+        if (keys.length > 0 && keys.every((k) => k.startsWith("ses_") || k.startsWith("session_"))) {
+          return new Set(keys);
+        }
+      }
+      if (!data || typeof data !== "object") {
+        if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+          const keys = Object.keys(payload);
+          if (keys.some((k) => k.startsWith("ses_"))) {
+            return new Set(keys);
+          }
+        }
+        return null;
+      }
+      if (Array.isArray(data)) {
+        const ids = data.map((item) => item?.id || item?.sessionId).filter(Boolean);
+        if (ids.length > 0) return new Set(ids);
+        if (data.length === 0) return /* @__PURE__ */ new Set();
+        return null;
+      }
+      return new Set(Object.keys(data));
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  markAsZombie(pid) {
+    const candidate = this.candidates.get(pid);
+    if (candidate) {
+      candidate.count++;
+    } else {
+      this.candidates.set(pid, {
+        count: 1,
+        firstDetectedAt: Date.now()
+      });
+    }
+  }
+  shouldKill(pid) {
+    const candidate = this.candidates.get(pid);
+    if (!candidate) return false;
+    const meetsCount = candidate.count >= this.options.minZombieChecks;
+    const meetsGrace = Date.now() - candidate.firstDetectedAt >= this.options.gracePeriodMs;
+    return meetsCount && meetsGrace;
+  }
+  async reapProcess(proc) {
+    log("[zombie-reaper] REAPING ZOMBIE", { pid: proc.pid, sessionId: proc.sessionId });
+    safeKill(proc.pid, "SIGTERM");
+    const exited = await waitForProcessExit(proc.pid, 2e3);
+    if (!exited) {
+      log("[zombie-reaper] force killing zombie", { pid: proc.pid });
+      safeKill(proc.pid, "SIGKILL");
+    }
+    this.candidates.delete(proc.pid);
+  }
+  static async reapServers(startPort, endPort) {
+    let reapedCount = 0;
+    console.log(`Scanning ports ${startPort}-${endPort} for inactive servers...`);
+    for (let port = startPort; port <= endPort; port++) {
+      const pids = getListeningPids(port);
+      if (pids.length === 0) continue;
+      for (const pid of pids) {
+        const cmd = getProcessCommand(pid) || "";
+        const isSuspicious = cmd.includes("opencode") || cmd.includes("node") || cmd.includes("bun");
+        if (!isSuspicious) continue;
+        const url = `http://127.0.0.1:${port}`;
+        const reaper = new _ZombieReaper(url, {
+          enabled: true,
+          intervalMs: 0,
+          minZombieChecks: 0,
+          gracePeriodMs: 0
+        });
+        try {
+          let sessions = null;
+          for (let i = 0; i < 3; i++) {
+            sessions = await reaper.fetchActiveSessions(url);
+            if (sessions !== null) break;
+            if (i < 2) await new Promise((r) => setTimeout(r, 1e3));
+          }
+          if (sessions === null) {
+            console.log(`[zombie-reaper] Server on port ${port} (PID ${pid}) is unreachable/stuck after 3 retries. Killing...`);
+            try {
+              safeKill(pid, "SIGTERM");
+              const exited = await waitForProcessExit(pid, 2e3);
+              if (!exited) {
+                console.log(`[zombie-reaper] Force killing server on port ${port} (PID ${pid})...`);
+                safeKill(pid, "SIGKILL");
+                await waitForProcessExit(pid, 1e3);
+                if (isProcessAlive(pid)) {
+                  console.error(`[zombie-reaper] CRITICAL: Failed to kill PID ${pid} on port ${port}`);
+                }
+              }
+            } catch (err) {
+              console.error(`[zombie-reaper] Error killing PID ${pid}:`, err);
+            }
+            reapedCount++;
+            continue;
+          }
+          if (sessions.size > 0) {
+            console.log(`[zombie-reaper] Skipping port ${port} (Has ${sessions.size} active session(s))`);
+            continue;
+          }
+          if (sessions.size === 0) {
+            console.log(`[zombie-reaper] Found inactive server on port ${port} (PID ${pid}). Killing...`);
+            try {
+              safeKill(pid, "SIGTERM");
+              const exited = await waitForProcessExit(pid, 2e3);
+              if (!exited) {
+                console.log(`[zombie-reaper] Force killing server on port ${port} (PID ${pid})...`);
+                safeKill(pid, "SIGKILL");
+                await waitForProcessExit(pid, 1e3);
+                if (isProcessAlive(pid)) {
+                  console.error(`[zombie-reaper] CRITICAL: Failed to kill PID ${pid} on port ${port}`);
+                }
+              }
+            } catch (err) {
+              console.error(`[zombie-reaper] Error killing PID ${pid}:`, err);
+            }
+            reapedCount++;
+          }
+        } catch (e) {
+          console.log(`[zombie-reaper] Server on port ${port} (PID ${pid}) error. Killing...`);
+          try {
+            safeKill(pid, "SIGTERM");
+            const exited = await waitForProcessExit(pid, 2e3);
+            if (!exited) {
+              console.log(`[zombie-reaper] Force killing server on port ${port} (PID ${pid})...`);
+              safeKill(pid, "SIGKILL");
+              await waitForProcessExit(pid, 1e3);
+              if (isProcessAlive(pid)) {
+                console.error(`[zombie-reaper] CRITICAL: Failed to kill PID ${pid} on port ${port}`);
+              }
+            }
+          } catch (err) {
+            console.error(`[zombie-reaper] Error killing PID ${pid}:`, err);
+          }
+          reapedCount++;
+        }
+      }
+    }
+    return reapedCount;
+  }
+};
+
+// src/utils/config-loader.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/config.ts
+import { z } from "zod";
+var TmuxLayoutSchema = z.enum([
+  "main-horizontal",
+  "main-vertical",
+  "tiled",
+  "even-horizontal",
+  "even-vertical"
+]);
+var TmuxConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  layout: TmuxLayoutSchema.default("main-vertical"),
+  main_pane_size: z.number().min(20).max(80).default(60),
+  spawn_delay_ms: z.number().min(50).max(2e3).default(300),
+  max_retry_attempts: z.number().min(0).max(5).default(2),
+  layout_debounce_ms: z.number().min(50).max(1e3).default(150),
+  max_agents_per_column: z.number().min(1).max(10).default(3),
+  // Reaper config
+  reaper_enabled: z.boolean().default(true),
+  reaper_interval_ms: z.number().default(3e4),
+  reaper_min_zombie_checks: z.number().default(3),
+  reaper_grace_period_ms: z.number().default(5e3),
+  // Auto self-destruct for abandoned servers
+  reaper_auto_self_destruct: z.boolean().default(true),
+  reaper_self_destruct_timeout_ms: z.number().default(60 * 60 * 1e3),
+  // 1 hour
+  // Port management
+  rotate_port: z.boolean().default(false),
+  max_ports: z.number().min(1).max(100).default(10)
+});
+var PluginConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  port: z.number().default(4096),
+  layout: TmuxLayoutSchema.default("main-vertical"),
+  main_pane_size: z.number().min(20).max(80).default(60),
+  auto_close: z.boolean().default(true),
+  spawn_delay_ms: z.number().min(50).max(2e3).default(300),
+  max_retry_attempts: z.number().min(0).max(5).default(2),
+  layout_debounce_ms: z.number().min(50).max(1e3).default(150),
+  max_agents_per_column: z.number().min(1).max(10).default(3),
+  // Reaper config
+  reaper_enabled: z.boolean().default(true),
+  reaper_interval_ms: z.number().default(3e4),
+  reaper_min_zombie_checks: z.number().default(3),
+  reaper_grace_period_ms: z.number().default(5e3),
+  // Auto self-destruct for abandoned servers
+  reaper_auto_self_destruct: z.boolean().default(true),
+  reaper_self_destruct_timeout_ms: z.number().default(60 * 60 * 1e3),
+  // 1 hour
+  // Port management
+  rotate_port: z.boolean().default(false),
+  max_ports: z.number().min(1).max(100).default(10)
+});
+var POLL_INTERVAL_MS = 2e3;
+var SESSION_TIMEOUT_MS = 10 * 60 * 1e3;
+var SESSION_MISSING_GRACE_MS = POLL_INTERVAL_MS * 3;
+
+// src/utils/config-loader.ts
+function loadConfig(directory) {
+  const configPaths = [];
+  if (directory) {
+    configPaths.push(
+      path2.join(directory, "opentmux.json"),
+      path2.join(directory, "opencode-agent-tmux.json")
+    );
+  }
+  configPaths.push(
+    path2.join(
+      process.env.HOME ?? "",
+      ".config",
+      "opencode",
+      "opentmux.json"
+    )
+  );
+  for (const configPath of configPaths) {
+    try {
+      if (fs2.existsSync(configPath)) {
+        const content = fs2.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(content);
+        const result = PluginConfigSchema.safeParse(parsed);
+        if (result.success) {
+          return result.data;
+        }
+      }
+    } catch (err) {
+    }
+  }
+  return PluginConfigSchema.parse({});
+}
+
+// src/bin/opentmux.ts
+var config = loadConfig();
+var OPENCODE_PORT_START2 = config.port || parseInt(env.OPENCODE_PORT || "4096", 10);
+var OPENCODE_PORT_MAX = OPENCODE_PORT_START2 + (config.max_ports || 10);
 var LOG_FILE = "/tmp/opentmux.log";
 var HEALTH_TIMEOUT_MS = 1e3;
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-function log(...args) {
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function log2(...args) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const message = `[${timestamp}] ${args.join(" ")}
 `;
   try {
-    appendFileSync(LOG_FILE, message);
+    appendFileSync2(LOG_FILE, message);
   } catch {
   }
 }
 function spawnPluginUpdater() {
   if (env.OPENCODE_TMUX_DISABLE_UPDATES === "1") return;
-  const updaterPath = join(__dirname, "../scripts/update-plugins.js");
-  if (!existsSync(updaterPath)) return;
+  const updaterPath = join3(__dirname2, "../scripts/update-plugins.js");
+  if (!existsSync2(updaterPath)) return;
   try {
-    const child = spawn(
-      process.execPath,
-      [updaterPath],
-      {
-        stdio: "ignore",
-        detached: true,
-        env: {
-          ...process.env,
-          OPENCODE_TMUX_UPDATE: "1"
-        }
+    const child = spawn(process.execPath, [updaterPath], {
+      stdio: "ignore",
+      detached: true,
+      env: {
+        ...process.env,
+        OPENCODE_TMUX_UPDATE: "1"
       }
-    );
+    });
     child.unref();
   } catch (error) {
   }
 }
 function findOpencodeBin() {
   try {
-    const cmd = platform === "win32" ? "where opencode" : "which -a opencode";
-    const output = execSync(cmd, { encoding: "utf-8" }).trim().split("\n");
+    const cmd = platform2 === "win32" ? "where opencode" : "which -a opencode";
+    const output = execSync2(cmd, { encoding: "utf-8" }).trim().split("\n");
     const currentScript = argv[1];
     for (const bin of output) {
       const normalizedBin = bin.trim();
-      if (normalizedBin.includes("opentmux") || normalizedBin === currentScript) continue;
+      if (normalizedBin.includes("opentmux") || normalizedBin === currentScript)
+        continue;
       if (normalizedBin) return normalizedBin;
     }
   } catch (e) {
   }
   const commonPaths = [
-    join(homedir(), ".opencode", "bin", platform === "win32" ? "opencode.exe" : "opencode"),
-    join(homedir(), "AppData", "Local", "opencode", "bin", "opencode.exe"),
+    join3(
+      homedir(),
+      ".opencode",
+      "bin",
+      platform2 === "win32" ? "opencode.exe" : "opencode"
+    ),
+    join3(homedir(), "AppData", "Local", "opencode", "bin", "opencode.exe"),
     "/usr/local/bin/opencode",
     "/usr/bin/opencode"
   ];
   for (const p of commonPaths) {
-    if (existsSync(p)) return p;
+    if (existsSync2(p)) return p;
   }
   return null;
 }
@@ -80,25 +629,6 @@ 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}'");
@@ -111,9 +641,9 @@ async function isOpencodeHealthy(port) {
   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
-    );
+    const response = await fetch(healthUrl, {
+      signal: controller.signal
+    }).catch(() => null);
     return response?.ok ?? false;
   } catch {
     return false;
@@ -121,16 +651,6 @@ async function isOpencodeHealthy(port) {
     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;
@@ -173,11 +693,11 @@ function isForegroundProcess(pid) {
   return stat.includes("+");
 }
 async function tryReclaimPort(port, tmuxPanePids) {
-  if (platform === "win32") return false;
+  if (platform2 === "win32") return false;
   const healthy = await isOpencodeHealthy(port);
   if (healthy) return false;
   const pids = getListeningPids(port);
-  log(
+  log2(
     "Port scan:",
     port.toString(),
     "healthy",
@@ -195,7 +715,7 @@ async function tryReclaimPort(port, tmuxPanePids) {
     const stat = getProcessStat(pid);
     const hasTtyPeers = hasOtherTtyProcesses(tty, pid);
     const inTmux = tmuxPanePids.size > 0 && isDescendantOf(pid, tmuxPanePids);
-    log(
+    log2(
       "Port process:",
       port.toString(),
       "pid",
@@ -213,19 +733,35 @@ async function tryReclaimPort(port, tmuxPanePids) {
     );
     if (command && command.includes("opencode")) {
       if (inTmux) {
-        log("Port owned by tmux process, skipping:", port.toString(), pid.toString());
+        log2(
+          "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());
+        log2(
+          "Port owned by active tty process, skipping:",
+          port.toString(),
+          pid.toString()
+        );
         continue;
       }
       if (isForegroundProcess(pid)) {
-        log("Port owned by potentially busy foreground process, skipping:", port.toString(), pid.toString());
+        log2(
+          "Port owned by potentially busy foreground process, skipping:",
+          port.toString(),
+          pid.toString()
+        );
         continue;
       }
     }
-    log("Attempting to stop stale or non-opencode process:", port.toString(), pid.toString());
+    log2(
+      "Attempting to stop stale or non-opencode process:",
+      port.toString(),
+      pid.toString()
+    );
     attemptedKill = true;
     try {
       process.kill(pid, "SIGTERM");
@@ -236,7 +772,11 @@ async function tryReclaimPort(port, tmuxPanePids) {
   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());
+      log2(
+        "Process still alive, sending SIGKILL:",
+        port.toString(),
+        pid.toString()
+      );
       try {
         process.kill(pid, "SIGKILL");
       } catch {
@@ -248,7 +788,7 @@ async function tryReclaimPort(port, tmuxPanePids) {
 }
 async function findAvailablePort() {
   let tmuxPanePids = null;
-  for (let port = OPENCODE_PORT_START; port <= OPENCODE_PORT_MAX; port++) {
+  for (let port = OPENCODE_PORT_START2; port <= OPENCODE_PORT_MAX; port++) {
     if (await checkPort(port)) return port;
     if (!tmuxPanePids) {
       tmuxPanePids = getTmuxPanePids();
@@ -260,16 +800,56 @@ async function findAvailablePort() {
 }
 function hasTmux() {
   try {
-    execSync("tmux -V", { stdio: "ignore" });
+    execSync2("tmux -V", { stdio: "ignore" });
     return true;
   } catch (e) {
     return false;
   }
 }
 async function main() {
-  const args = argv.slice(2);
-  const isCliCommand = args.length > 0 && (["auth", "config", "plugins", "update", "completion", "stats"].includes(args[0]) || ["--version", "-v", "--help", "-h"].includes(args[0]));
-  if (isCliCommand) {
+  const isRuntime = /\/?(node|bun)(\.exe)?$/i.test(argv[0]);
+  const args = isRuntime ? argv.slice(2) : argv.slice(1);
+  if (args.includes("--reap") || args.includes("-reap")) {
+    await ZombieReaper.reapAll();
+    exit(0);
+  }
+  const NON_TUI_COMMANDS = [
+    // Core CLI commands
+    "auth",
+    "config",
+    "plugins",
+    "update",
+    "upgrade",
+    "completion",
+    "stats",
+    "run",
+    "exec",
+    "doctor",
+    "debug",
+    "clean",
+    "uninstall",
+    // Agent/Session management
+    "agent",
+    "session",
+    "export",
+    "import",
+    "github",
+    "pr",
+    // Server commands (usually run in fg, don't need tmux wrapper)
+    "serve",
+    "web",
+    "acp",
+    "mcp",
+    "models",
+    // Flags
+    "--version",
+    "-v",
+    "--help",
+    "-h"
+  ];
+  const isCliCommand = args.length > 0 && NON_TUI_COMMANDS.includes(args[0]);
+  const isInteractiveMode = args.length === 0;
+  if (isCliCommand || isInteractiveMode) {
     const opencodeBin2 = findOpencodeBin();
     if (!opencodeBin2) {
       console.error(
@@ -298,48 +878,106 @@ async function main() {
     });
     return;
   }
-  log("=== OpenCode Tmux Wrapper Started ===");
-  log("Process argv:", JSON.stringify(argv));
-  log("Current directory:", process.cwd());
+  log2("=== OpenCode Tmux Wrapper Started ===");
+  log2("Process argv:", JSON.stringify(argv));
+  log2("Current directory:", process.cwd());
   const opencodeBin = findOpencodeBin();
-  log("Found opencode binary:", opencodeBin);
+  log2("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");
+    console.error(
+      'Error: Could not find "opencode" binary in PATH or common locations.'
+    );
+    log2("ERROR: opencode binary not found");
     exit(1);
   }
   spawnPluginUpdater();
-  const port = await findAvailablePort();
-  log("Found available port:", port);
+  let port = await findAvailablePort();
+  log2("Found available port:", port);
   if (!port) {
-    console.error("Error: No available ports found in range 4096-4106.");
-    log("ERROR: No available ports");
-    exit(1);
+    if (config.rotate_port) {
+      log2("Port rotation enabled. Finding oldest session to kill...");
+      let oldestPid = null;
+      let oldestTime = Date.now();
+      let targetPort = -1;
+      for (let p = OPENCODE_PORT_START2; p <= OPENCODE_PORT_MAX; p++) {
+        const pids = getListeningPids(p);
+        for (const pid of pids) {
+          const cmd = getProcessCommand(pid);
+          if (cmd && (cmd.includes("opencode") || cmd.includes("node") || cmd.includes("bun"))) {
+            const startTime = getProcessStartTime(pid);
+            if (startTime && startTime < oldestTime) {
+              oldestTime = startTime;
+              oldestPid = pid;
+              targetPort = p;
+            }
+          }
+        }
+      }
+      if (oldestPid && targetPort !== -1) {
+        log2("Rotating port:", targetPort, "Killing oldest PID:", oldestPid);
+        console.log(
+          `\u267B\uFE0F  Port rotation: Killing oldest session (PID ${oldestPid}) on port ${targetPort} to make room...`
+        );
+        safeKill(oldestPid, "SIGTERM");
+        await waitForProcessExit(oldestPid, 2e3);
+        if (isProcessAlive(oldestPid)) {
+          safeKill(oldestPid, "SIGKILL");
+          await waitForProcessExit(oldestPid, 1e3);
+        }
+        if (await checkPort(targetPort)) {
+          port = targetPort;
+          log2("Port reclaimed successfully:", port);
+        } else {
+          console.error(
+            `\u26A0\uFE0F  Failed to reclaim port ${targetPort} even after killing PID ${oldestPid}.`
+          );
+          exit(1);
+        }
+      } else {
+        console.error(
+          "Error: Could not find any valid OpenCode sessions to rotate."
+        );
+        exit(1);
+      }
+    } else {
+      console.error(
+        `Error: No available ports found in range ${OPENCODE_PORT_START2}-${OPENCODE_PORT_MAX}.`
+      );
+      console.error('Tip: Run "opentmux -reap" to clean up stuck sessions.');
+      console.error(
+        '     Or enable "rotate_port": true in config to automatically recycle oldest sessions.'
+      );
+      log2("ERROR: No available ports");
+      exit(1);
+    }
   }
   const env2 = { ...process.env };
   env2.OPENCODE_PORT = port.toString();
-  log("User args:", JSON.stringify(args));
+  log2("User args:", JSON.stringify(args));
   const childArgs = ["--port", port.toString(), ...args];
-  log("Final childArgs:", JSON.stringify(childArgs));
+  log2("Final childArgs:", JSON.stringify(childArgs));
   const inTmux = !!env2.TMUX;
   const tmuxAvailable = hasTmux();
-  log("In tmux?", inTmux);
-  log("Tmux available?", tmuxAvailable);
+  log2("In tmux?", inTmux);
+  log2("Tmux available?", tmuxAvailable);
   if (inTmux || !tmuxAvailable) {
-    log("Running directly (in tmux or no tmux available)");
-    const child = spawn(opencodeBin, childArgs, { stdio: "inherit", env: env2 });
+    log2("Running directly (in tmux or no tmux available)");
+    const child = spawn(opencodeBin, childArgs, {
+      stdio: "inherit",
+      env: env2
+    });
     child.on("error", (err) => {
-      log("ERROR spawning child:", err.message);
+      log2("ERROR spawning child:", err.message);
     });
     child.on("close", (code) => {
-      log("Child exited with code:", code);
+      log2("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...");
-    log("Launching tmux session");
+    log2("Launching tmux session");
     const escapedBin = opencodeBin.includes(" ") ? `'${opencodeBin}'` : opencodeBin;
     const escapedArgs = childArgs.map((arg) => {
       if (arg.includes(" ") || arg.includes('"') || arg.includes("'")) {
@@ -348,24 +986,24 @@ async function main() {
       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));
+    log2("Shell command for tmux:", shellCommand);
+    const tmuxArgs = ["new-session", shellCommand];
+    log2("Tmux args:", JSON.stringify(tmuxArgs));
     const child = spawn("tmux", tmuxArgs, { stdio: "inherit", env: env2 });
     child.on("error", (err) => {
-      log("ERROR spawning tmux:", err.message);
+      log2("ERROR spawning tmux:", err.message);
     });
     child.on("close", (code) => {
-      log("Tmux exited with code:", code);
+      log2("Tmux exited with code:", code);
       exit(code ?? 0);
     });
   }
 }
 main().catch((err) => {
-  log("FATAL ERROR:", err.message, err.stack);
+  if (err.name === "AbortError" || err.code === 20) {
+    exit(0);
+  }
+  log2("FATAL ERROR:", err.message, err.stack);
   console.error(err);
   exit(1);
 });