opentmux 1.3.3

package/README.md

@@ -0,0 +1,131 @@
+# opentmux
+
+[![npm version](https://img.shields.io/npm/v/opentmux.svg)](https://www.npmjs.com/package/opentmux)
+[![npm downloads](https://img.shields.io/npm/dt/opentmux)](https://www.npmjs.com/package/opentmux)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+An [OpenCode](https://opencode.ai) plugin that provides **smart tmux integration** for viewing agent execution in real-time. Automatically spawns panes, streams output, and manages your terminal workspace.
+
+- **Agent-Agnostic**: Works with oh-my-opencode, omoc-slim, or vanilla OpenCode.
+- **Cross-Platform**: Full support for **macOS**, **Linux**, and **Windows** (via PowerShell or WSL).
+
+![Opencode Agent Tmux Demo](https://raw.githubusercontent.com/angansamadder/opentmux/main/assets/demo.png)
+*Note: The demo shows the "sisyphus" agent from [oh-my-opencode](https://github.com/code-yeongyu/oh-my-opencode), but this plugin supports ALL OpenCode subagents.*
+
+## Installation
+
+### 🤖 Let an LLM do it (Recommended)
+
+Paste this into any LLM agent (OpenCode, Claude Code, Cursor, etc.):
+
+```text
+Install the opentmux plugin by following: https://raw.githubusercontent.com/AnganSamadder/opentmux/main/README.md
+```
+
+<details>
+<summary><b>Instructions for LLM Agents</b></summary>
+
+To install this plugin, please perform the following steps for the user:
+
+1.  **Install the NPM package globally:**
+    ```bash
+    npm install -g opentmux
+    ```
+    *Note: This installer automatically configures the user's shell (Bash/Zsh/Fish/PowerShell) to use the smart wrapper.*
+
+2.  **Configure OpenCode:**
+    Add `"opentmux"` to the `plugin` array in the user's config file (usually `~/.config/opencode/opencode.json`).
+
+    ```json
+    {
+      "plugin": [
+        "opentmux"
+      ]
+    }
+    ```
+
+3.  **Verify & Finalize:**
+    *   Check if `tmux` is installed on the system. If not, advise the user to install it (e.g., `brew install tmux`, `sudo apt install tmux`, or `winget install tmux`).
+    *   Tell the user: **"Installation complete! Please restart your terminal and run `opencode` to see the tmux integration in action."**
+
+</details>
+
+### 👤 For Humans (Manual)
+
+1.  **Install via NPM:**
+    ```bash
+    npm install -g opentmux
+    ```
+    *The installer automatically configures your shell to use the smart wrapper.*
+
+2.  **Enable the Plugin:**
+    Add `"opentmux"` to your `~/.config/opencode/opencode.json`:
+    ```json
+    {
+      "plugin": [
+        "opentmux"
+      ]
+    }
+    ```
+
+3.  **Run OpenCode:**
+    Restart your terminal and type `opencode`. The plugin handles the rest!
+
+## 🛠️ Development
+
+For contributors working on this plugin locally, see [LOCAL_DEVELOPMENT.md](docs/LOCAL_DEVELOPMENT.md) for setup instructions.
+
+## ✨ Features
+
+- **Automatic Tmux Pane Spawning**: When any agent starts, automatically spawns a tmux pane
+- **Live Streaming**: Each pane runs `opencode attach` to show real-time agent output
+- **Auto-Cleanup**: Panes automatically close when agents complete
+- **Configurable Layout**: Support multiple tmux layouts (`main-vertical`, `tiled`, etc.)
+- **Multi-Port Support**: Automatically finds available ports (4096-4106) when running multiple instances
+- **Smart Wrapper**: Automatically detects if you are in tmux; if not, launches a session for you.
+
+## ⚙️ Configuration
+
+You can customize behavior by creating `~/.config/opencode/opentmux.json`:
+
+```json
+{
+  "enabled": true,
+  "port": 4096,
+  "layout": "main-vertical",
+  "main_pane_size": 60,
+  "auto_close": true
+}
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `enabled` | boolean | `true` | Enable/disable the plugin |
+| `port` | number | `4096` | OpenCode server port |
+| `layout` | string | `"main-vertical"` | Tmux layout: `main-horizontal`, `main-vertical`, `tiled`, etc. |
+| `main_pane_size` | number | `60` | Size of main pane (20-80%) |
+| `auto_close` | boolean | `true` | Auto-close panes when sessions complete |
+
+## ❓ Troubleshooting
+
+### Panes Not Spawning
+1. Verify you're inside tmux: `echo $TMUX`
+2. Check tmux is installed: `which tmux` (or `where tmux` on Windows)
+3. Check logs: `cat /tmp/opentmux.log`
+
+### Server Not Found
+Make sure OpenCode is started with the `--port` flag matching your config (the wrapper does this automatically).
+
+## 🗺️ Roadmap
+
+The following features are planned for future releases:
+- **Glow Integration**: Support for [Glow](https://github.com/charmbracelet/glow) to render markdown beautifully in spawned panes.
+- **Neovim Quick-Launch**: Direct integration to launch Neovim at the agent's current working directory.
+- **Enhanced Customization**: More options for pane positioning, colors, and persistent layouts.
+
+## 📄 License
+
+MIT
+
+## 🙏 Acknowledgements
+This project extracts and improves upon the tmux session management from [oh-my-opencode-slim](https://github.com/alvinunreal/oh-my-opencode-slim) by alvinunreal.

package/dist/bin/opentmux.js

@@ -0,0 +1,418 @@
+#!/usr/bin/env node
+
+// src/bin/opentmux.ts
+import { spawn, execSync } 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 { 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/opentmux.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");
+  if (!existsSync(updaterPath)) return;
+  try {
+    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 currentScript = argv[1];
+    for (const bin of output) {
+      const normalizedBin = bin.trim();
+      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"),
+    "/usr/local/bin/opencode",
+    "/usr/bin/opencode"
+  ];
+  for (const p of commonPaths) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+function checkPort(port) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.listen(port, "127.0.0.1");
+    server.on("listening", () => {
+      server.close();
+      resolve(true);
+    });
+    server.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+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("+");
+}
+function killZombieClients() {
+  if (platform === "win32") return;
+  log("Scanning for zombie opencode clients...");
+  const output = safeExec("ps -A -o pid,ppid,command");
+  if (!output) return;
+  const lines = output.split("\n").slice(1);
+  const currentPid = process.pid;
+  const parentPid = process.ppid;
+  const wrapperCount = lines.filter((line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return false;
+    const match = trimmed.match(/^(\d+)\s+(\d+)\s+(.+)$/);
+    if (!match) return false;
+    const command = match[3];
+    return (command.includes("opentmux.ts") || command.includes("bin/opentmux")) && !command.includes("ps ");
+  }).length;
+  if (wrapperCount > 1) {
+    log(`Active sessions detected (${wrapperCount} wrappers), skipping zombie cleanup.`);
+    return;
+  }
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^(\d+)\s+(\d+)\s+(.+)$/);
+    if (!match) continue;
+    const pid = parseInt(match[1], 10);
+    const ppid = parseInt(match[2], 10);
+    const command = match[3];
+    if (pid === currentPid || pid === parentPid) continue;
+    if (command.includes("opencode") && command.includes("attach") && command.includes("--session")) {
+      if (command.includes("opencode-agent-tmux") || command.includes("opentmux")) {
+        continue;
+      }
+      log(`Found zombie client: PID ${pid}, PPID ${ppid}, CMD: ${command}`);
+      log(`Sending SIGKILL to zombie PID ${pid}`);
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch (err) {
+        log(`Failed to kill PID ${pid}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+}
+async function tryReclaimPort(port, tmuxPanePids) {
+  if (platform === "win32") return false;
+  const healthy = await isOpencodeHealthy(port);
+  if (healthy) return false;
+  const pids = getListeningPids(port);
+  log(
+    "Port scan:",
+    port.toString(),
+    "healthy",
+    String(healthy),
+    "pids",
+    pids.length > 0 ? pids.join(",") : "none"
+  );
+  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);
+    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),
+      "command",
+      command ?? "unknown"
+    );
+    if (command && command.includes("opencode")) {
+      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 (isForegroundProcess(pid)) {
+        log("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());
+    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;
+}
+function hasTmux() {
+  try {
+    execSync("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]) || args.includes("--print-logs") || args.includes("--log-level"));
+  if (isCliCommand) {
+    const opencodeBin2 = findOpencodeBin();
+    if (!opencodeBin2) {
+      console.error(
+        'Error: Could not find "opencode" binary in PATH or common locations.'
+      );
+      exit(1);
+    }
+    const bypassArgs = [...args];
+    const hasPrintLogs = args.includes("--print-logs");
+    if (!hasPrintLogs && !args.some((arg) => arg.startsWith("--log-level"))) {
+      bypassArgs.push("--log-level", "ERROR");
+    }
+    const child = spawn(opencodeBin2, bypassArgs, {
+      stdio: ["inherit", "inherit", "pipe"],
+      env: process.env
+    });
+    child.stderr?.on("data", (data) => {
+      const lines = data.toString().split("\n");
+      const filtered = lines.filter(
+        (line) => !/^INFO\s+.*service=models\.dev.*refreshing/.test(line)
+      );
+      process.stderr.write(filtered.join("\n"));
+    });
+    child.on("close", (code) => {
+      exit(code ?? 0);
+    });
+    return;
+  }
+  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();
+  killZombieClients();
+  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();
+  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("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...");
+    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(" ")}; EXIT_CODE=$?; if [ $EXIT_CODE -ne 0 ] && [ $EXIT_CODE -ne 130 ] && [ $EXIT_CODE -ne 133 ] && [ $EXIT_CODE -ne 143 ]; then echo "Exit code: $EXIT_CODE"; echo "Press Enter to close..."; read; fi`;
+    log("Shell command for tmux:", shellCommand);
+    const tmuxArgs = [
+      "new-session",
+      "-c",
+      process.cwd(),
+      // Use current working directory
+      shellCommand
+    ];
+    log("Tmux args:", JSON.stringify(tmuxArgs));
+    const child = spawn("tmux", tmuxArgs, { stdio: "inherit", env: env2 });
+    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.d.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+
+interface PluginInput {
+    directory: string;
+    serverUrl?: URL | string;
+    client: {
+        session: {
+            status(): Promise<{
+                data?: Record<string, {
+                    type: string;
+                }>;
+            }>;
+            subscribe(callback: (event: {
+                type: string;
+                properties?: unknown;
+            }) => void): () => void;
+        };
+    };
+}
+interface PluginOutput {
+    name: string;
+    event?: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    tool?: Record<string, unknown>;
+    config?: unknown;
+}
+type Plugin = (ctx: PluginInput) => Promise<PluginOutput>;
+
+declare const TmuxLayoutSchema: z.ZodEnum<["main-horizontal", "main-vertical", "tiled", "even-horizontal", "even-vertical", "dynamic-vertical"]>;
+type TmuxLayout = z.infer<typeof TmuxLayoutSchema>;
+declare const TmuxConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    layout: z.ZodDefault<z.ZodEnum<["main-horizontal", "main-vertical", "tiled", "even-horizontal", "even-vertical", "dynamic-vertical"]>>;
+    main_pane_size: z.ZodDefault<z.ZodNumber>;
+    max_agents_per_column: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    layout: "main-horizontal" | "main-vertical" | "tiled" | "even-horizontal" | "even-vertical" | "dynamic-vertical";
+    main_pane_size: number;
+    max_agents_per_column: number;
+}, {
+    enabled?: boolean | undefined;
+    layout?: "main-horizontal" | "main-vertical" | "tiled" | "even-horizontal" | "even-vertical" | "dynamic-vertical" | undefined;
+    main_pane_size?: number | undefined;
+    max_agents_per_column?: number | undefined;
+}>;
+type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
+declare const PluginConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    port: z.ZodDefault<z.ZodNumber>;
+    layout: z.ZodDefault<z.ZodEnum<["main-horizontal", "main-vertical", "tiled", "even-horizontal", "even-vertical", "dynamic-vertical"]>>;
+    main_pane_size: z.ZodDefault<z.ZodNumber>;
+    max_agents_per_column: z.ZodDefault<z.ZodNumber>;
+    auto_close: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    port: number;
+    layout: "main-horizontal" | "main-vertical" | "tiled" | "even-horizontal" | "even-vertical" | "dynamic-vertical";
+    main_pane_size: number;
+    max_agents_per_column: number;
+    auto_close: boolean;
+}, {
+    enabled?: boolean | undefined;
+    port?: number | undefined;
+    layout?: "main-horizontal" | "main-vertical" | "tiled" | "even-horizontal" | "even-vertical" | "dynamic-vertical" | undefined;
+    main_pane_size?: number | undefined;
+    max_agents_per_column?: number | undefined;
+    auto_close?: boolean | undefined;
+}>;
+type PluginConfig = z.infer<typeof PluginConfigSchema>;
+
+declare const OpencodeTmux: Plugin;
+
+export { type PluginConfig, type TmuxConfig, type TmuxLayout, OpencodeTmux as default };