opentmux 1.3.3

package/dist/index.js

@@ -0,0 +1,841 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/logger.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path2 from "path";
+function getLogFile() {
+  if (fs.existsSync(NEW_LOG_FILE)) {
+    return NEW_LOG_FILE;
+  }
+  if (fs.existsSync(OLD_LOG_FILE)) {
+    console.warn(
+      "Deprecation: Using legacy opencode-agent-tmux log file. Please update to opentmux"
+    );
+    return OLD_LOG_FILE;
+  }
+  return NEW_LOG_FILE;
+}
+function log(message, data) {
+  try {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
+`;
+    fs.appendFileSync(logFile, logEntry);
+  } catch {
+  }
+}
+var NEW_LOG_FILE, OLD_LOG_FILE, logFile;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    NEW_LOG_FILE = path2.join(os.tmpdir(), "opentmux.log");
+    OLD_LOG_FILE = path2.join(os.tmpdir(), "opencode-agent-tmux.log");
+    logFile = getLogFile();
+  }
+});
+
+// src/utils/tmux.ts
+var tmux_exports = {};
+__export(tmux_exports, {
+  closeTmuxPane: () => closeTmuxPane,
+  getTmuxPath: () => getTmuxPath,
+  isInsideTmux: () => isInsideTmux,
+  killTmuxSession: () => killTmuxSession,
+  killTmuxSessionSync: () => killTmuxSessionSync,
+  resetServerCheck: () => resetServerCheck,
+  spawnAsync: () => spawnAsync,
+  spawnTmuxPane: () => spawnTmuxPane,
+  startTmuxCheck: () => startTmuxCheck
+});
+import { spawn, spawnSync, execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+async function spawnAsync(command, options) {
+  return new Promise((resolve) => {
+    const [cmd, ...args] = command;
+    const proc = spawn(cmd, args, {
+      stdio: "pipe",
+      env: options?.env ?? process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    if (!options?.ignoreOutput) {
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      resolve({
+        exitCode: code ?? 1,
+        stdout,
+        stderr
+      });
+    });
+    proc.on("error", () => {
+      resolve({
+        exitCode: 1,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+async function isServerRunning(serverUrl) {
+  if (serverCheckUrl === serverUrl && serverAvailable === true) {
+    return true;
+  }
+  const healthUrl = new URL("/health", serverUrl).toString();
+  const timeoutMs = 3e3;
+  const maxAttempts = 2;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let response = null;
+    try {
+      response = await fetch(healthUrl, { signal: controller.signal }).catch(
+        () => null
+      );
+    } finally {
+      clearTimeout(timeout);
+    }
+    const available = response?.ok ?? false;
+    if (available) {
+      serverCheckUrl = serverUrl;
+      serverAvailable = true;
+      log("[tmux] isServerRunning: checked", { serverUrl, available, attempt });
+      return true;
+    }
+    if (attempt < maxAttempts) {
+      await new Promise((r) => setTimeout(r, 250));
+    }
+  }
+  log("[tmux] isServerRunning: checked", { serverUrl, available: false });
+  return false;
+}
+function resetServerCheck() {
+  serverAvailable = null;
+  serverCheckUrl = null;
+}
+async function findTmuxPath() {
+  const isWindows = process.platform === "win32";
+  const cmd = isWindows ? "where" : "which";
+  try {
+    const result = await spawnAsync([cmd, "tmux"]);
+    if (result.exitCode !== 0) {
+      log("[tmux] findTmuxPath: 'which tmux' failed", {
+        exitCode: result.exitCode
+      });
+      return null;
+    }
+    const path4 = result.stdout.trim().split("\n")[0];
+    if (!path4) {
+      log("[tmux] findTmuxPath: no path in output");
+      return null;
+    }
+    const verifyResult = await spawnAsync([path4, "-V"]);
+    if (verifyResult.exitCode !== 0) {
+      log("[tmux] findTmuxPath: tmux -V failed", {
+        path: path4,
+        verifyExit: verifyResult.exitCode
+      });
+      return null;
+    }
+    log("[tmux] findTmuxPath: found tmux", { path: path4 });
+    return path4;
+  } catch (err) {
+    log("[tmux] findTmuxPath: exception", { error: String(err) });
+    return null;
+  }
+}
+async function getTmuxPath() {
+  if (tmuxChecked) {
+    return tmuxPath;
+  }
+  tmuxPath = await findTmuxPath();
+  tmuxChecked = true;
+  log("[tmux] getTmuxPath: initialized", { tmuxPath });
+  return tmuxPath;
+}
+function isInsideTmux() {
+  return !!process.env.TMUX;
+}
+async function applyLayout(tmux, layout, mainPaneSize) {
+  try {
+    if (layout === "dynamic-vertical") {
+      return;
+    }
+    await spawnAsync([tmux, "select-layout", layout]);
+    if (layout === "main-horizontal" || layout === "main-vertical") {
+      const sizeOption = layout === "main-horizontal" ? "main-pane-height" : "main-pane-width";
+      await spawnAsync([
+        tmux,
+        "set-window-option",
+        sizeOption,
+        `${mainPaneSize}%`
+      ]);
+      await spawnAsync([tmux, "select-layout", layout]);
+    }
+    log("[tmux] applyLayout: applied", { layout, mainPaneSize });
+  } catch (err) {
+    log("[tmux] applyLayout: exception", { error: String(err) });
+  }
+}
+async function spawnTmuxPane(sessionId, description, config, serverUrl) {
+  log("[tmux] spawnTmuxPane called", {
+    sessionId,
+    description,
+    config,
+    serverUrl
+  });
+  if (!config.enabled) {
+    log("[tmux] spawnTmuxPane: config.enabled is false, skipping");
+    return { success: false };
+  }
+  if (!isInsideTmux()) {
+    log("[tmux] spawnTmuxPane: not inside tmux, skipping");
+    return { success: false };
+  }
+  const serverRunning = await isServerRunning(serverUrl);
+  if (!serverRunning) {
+    const defaultPort = process.env.OPENCODE_PORT ?? "4096";
+    log("[tmux] spawnTmuxPane: OpenCode server not running, skipping", {
+      serverUrl,
+      hint: `Start opencode with --port ${defaultPort}`
+    });
+    return { success: false };
+  }
+  const tmux = await getTmuxPath();
+  if (!tmux) {
+    log("[tmux] spawnTmuxPane: tmux binary not found, skipping");
+    return { success: false };
+  }
+  storedConfig = config;
+  try {
+    const opencodeCmd = `opencode attach ${serverUrl} --session ${sessionId}`;
+    const args = [
+      "split-window",
+      "-h",
+      "-d",
+      "-P",
+      "-F",
+      "#{pane_id}",
+      opencodeCmd
+    ];
+    const env = {
+      ...process.env,
+      OPENCODE_HIDE_SUBAGENT_HEADER: "1"
+    };
+    log("[tmux] spawnTmuxPane: executing", { tmux, args, opencodeCmd, env });
+    const result = await spawnAsync([tmux, ...args], { env });
+    const paneId = result.stdout.trim();
+    log("[tmux] spawnTmuxPane: split result", {
+      exitCode: result.exitCode,
+      paneId,
+      stderr: result.stderr.trim()
+    });
+    if (result.exitCode === 0 && paneId) {
+      await spawnAsync(
+        [tmux, "select-pane", "-t", paneId, "-T", description.slice(0, 30)],
+        { ignoreOutput: true }
+      );
+      const layout = config.layout ?? "main-vertical";
+      const mainPaneSize = config.main_pane_size ?? 60;
+      await applyLayout(tmux, layout, mainPaneSize);
+      log("[tmux] spawnTmuxPane: SUCCESS, pane created and layout applied", {
+        paneId,
+        layout
+      });
+      return { success: true, paneId };
+    }
+    return { success: false };
+  } catch (err) {
+    log("[tmux] spawnTmuxPane: exception", { error: String(err) });
+    return { success: false };
+  }
+}
+async function closeTmuxPane(paneId) {
+  log("[tmux] closeTmuxPane called", { paneId });
+  if (!paneId) {
+    log("[tmux] closeTmuxPane: no paneId provided");
+    return false;
+  }
+  const tmux = await getTmuxPath();
+  if (!tmux) {
+    log("[tmux] closeTmuxPane: tmux binary not found");
+    return false;
+  }
+  try {
+    const result = await spawnAsync([tmux, "kill-pane", "-t", paneId]);
+    log("[tmux] closeTmuxPane: result", {
+      exitCode: result.exitCode,
+      stderr: result.stderr.trim()
+    });
+    if (result.exitCode === 0) {
+      log("[tmux] closeTmuxPane: SUCCESS, pane closed", { paneId });
+      if (storedConfig) {
+        const layout = storedConfig.layout ?? "main-vertical";
+        const mainPaneSize = storedConfig.main_pane_size ?? 60;
+        await applyLayout(tmux, layout, mainPaneSize);
+        log("[tmux] closeTmuxPane: layout reapplied", { layout });
+      }
+      return true;
+    }
+    log("[tmux] closeTmuxPane: failed (pane may already be closed)", {
+      paneId
+    });
+    return false;
+  } catch (err) {
+    log("[tmux] closeTmuxPane: exception", { error: String(err) });
+    return false;
+  }
+}
+function killTmuxSessionSync() {
+  let tmux = tmuxPath;
+  log("[tmux] killTmuxSessionSync starting", { tmuxPath: tmux });
+  if (!tmux) {
+    try {
+      tmux = execSync("which tmux", { encoding: "utf-8" }).trim();
+      log("[tmux] killTmuxSessionSync resolved via which", { tmux });
+    } catch {
+      tmux = "/usr/local/bin/tmux";
+      if (!existsSync2(tmux)) {
+        tmux = "/opt/homebrew/bin/tmux";
+      }
+      log("[tmux] killTmuxSessionSync using fallback", { tmux });
+    }
+  }
+  try {
+    let sessionName = "";
+    try {
+      sessionName = execSync(`${tmux} display-message -p '#S'`, { encoding: "utf-8" }).trim();
+      log("[tmux] killTmuxSessionSync target session identified", { sessionName });
+    } catch {
+      log("[tmux] killTmuxSessionSync could not identify session name, using default");
+    }
+    log("[tmux] killTmuxSessionSync executing kill-session", { tmux, sessionName });
+    const args = sessionName ? ["kill-session", "-t", sessionName] : ["kill-session"];
+    const result = spawnSync(tmux, args);
+    log("[tmux] killTmuxSessionSync result", {
+      status: result.status,
+      error: result.error?.message,
+      stderr: result.stderr?.toString().trim()
+    });
+    return result.status === 0;
+  } catch (err) {
+    log("[tmux] killTmuxSessionSync exception", { error: String(err) });
+    return false;
+  }
+}
+async function killTmuxSession() {
+  const tmux = await getTmuxPath();
+  if (!tmux) {
+    log("[tmux] killTmuxSession: tmux binary not found");
+    return false;
+  }
+  try {
+    log("[tmux] killTmuxSession: killing current session");
+    const result = spawnSync(tmux, ["kill-session"]);
+    log("[tmux] killTmuxSession: result", {
+      status: result.status,
+      stderr: result.stderr?.toString().trim()
+    });
+    return result.status === 0;
+  } catch (err) {
+    log("[tmux] killTmuxSession: exception", { error: String(err) });
+    return false;
+  }
+}
+function startTmuxCheck() {
+  if (!tmuxChecked) {
+    getTmuxPath().catch(() => {
+    });
+  }
+}
+var tmuxPath, tmuxChecked, storedConfig, serverAvailable, serverCheckUrl;
+var init_tmux = __esm({
+  "src/utils/tmux.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    tmuxPath = null;
+    tmuxChecked = false;
+    storedConfig = null;
+    serverAvailable = null;
+    serverCheckUrl = null;
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+import * as fs2 from "fs";
+import * as path3 from "path";
+
+// src/config.ts
+init_esm_shims();
+import { z } from "zod";
+var TmuxLayoutSchema = z.enum([
+  "main-horizontal",
+  "main-vertical",
+  "tiled",
+  "even-horizontal",
+  "even-vertical",
+  "dynamic-vertical"
+]);
+var TmuxConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  layout: TmuxLayoutSchema.default("dynamic-vertical"),
+  main_pane_size: z.number().min(20).max(80).default(60),
+  max_agents_per_column: z.number().min(0).max(10).default(3)
+});
+var PluginConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  port: z.number().default(4096),
+  layout: TmuxLayoutSchema.default("dynamic-vertical"),
+  main_pane_size: z.number().min(20).max(80).default(60),
+  max_agents_per_column: z.number().min(0).max(10).default(3),
+  auto_close: z.boolean().default(true)
+});
+var POLL_INTERVAL_MS = 2e3;
+var SESSION_TIMEOUT_MS = 10 * 60 * 1e3;
+var SESSION_MISSING_GRACE_MS = POLL_INTERVAL_MS * 3;
+
+// src/tmux-session-manager.ts
+init_esm_shims();
+
+// src/utils/index.ts
+init_esm_shims();
+init_logger();
+init_tmux();
+
+// src/utils/layout.ts
+init_esm_shims();
+function generateLayoutString(params) {
+  const { width, height, mainPaneSizePercent, paneIds, mainPaneId, maxAgentsPerColumn } = params;
+  const cleanPaneIds = paneIds.filter((id) => id !== mainPaneId);
+  if (width <= 0 || height <= 0) {
+    return ``;
+  }
+  const mainPaneWidth = Math.floor(width * mainPaneSizePercent / 100);
+  const subagentAreaWidth = width - mainPaneWidth;
+  if (cleanPaneIds.length === 0) {
+    const layout = formatNode(width, height, 0, 0, mainPaneId);
+    return withChecksum(layout);
+  }
+  const mainNode = formatNode(mainPaneWidth, height, 0, 0, mainPaneId);
+  const numSubagents = cleanPaneIds.length;
+  const limit = maxAgentsPerColumn > 0 ? maxAgentsPerColumn : numSubagents;
+  const numCols = Math.ceil(numSubagents / limit);
+  const colWidth = Math.floor(subagentAreaWidth / numCols);
+  const columns = [];
+  let currentX = mainPaneWidth;
+  let remainingAgents = numSubagents;
+  let agentsProcessed = 0;
+  for (let c = 0; c < numCols; c++) {
+    const isLastCol = c === numCols - 1;
+    const thisColWidth = isLastCol ? width - currentX : colWidth;
+    const agentsInThisCol = Math.min(remainingAgents, limit);
+    remainingAgents -= agentsInThisCol;
+    const colPaneIds = cleanPaneIds.slice(agentsProcessed, agentsProcessed + agentsInThisCol);
+    agentsProcessed += agentsInThisCol;
+    const colNode = buildColumn(thisColWidth, height, currentX, 0, colPaneIds);
+    columns.push(colNode);
+    currentX += thisColWidth;
+  }
+  let subagentAreaNode;
+  if (columns.length === 1) {
+    subagentAreaNode = columns[0];
+  } else {
+    subagentAreaNode = `${subagentAreaWidth}x${height},${mainPaneWidth},0{${columns.join(",")}}`;
+  }
+  const rootLayout = `${width}x${height},0,0{${mainNode},${subagentAreaNode}}`;
+  return withChecksum(rootLayout);
+}
+function buildColumn(width, height, x, y, paneIds) {
+  if (paneIds.length === 0) return "";
+  if (paneIds.length === 1) {
+    return formatNode(width, height, x, y, paneIds[0]);
+  }
+  const rowHeight = Math.floor(height / paneIds.length);
+  const nodes = [];
+  let currentY = y;
+  for (let i = 0; i < paneIds.length; i++) {
+    const isLast = i === paneIds.length - 1;
+    const thisRowHeight = isLast ? height - (currentY - y) : rowHeight;
+    nodes.push(formatNode(width, thisRowHeight, x, currentY, paneIds[i]));
+    currentY += thisRowHeight;
+  }
+  return `${width}x${height},${x},${y}[${nodes.join(",")}]`;
+}
+function formatNode(w, h, x, y, id) {
+  return `${w}x${h},${x},${y},${id}`;
+}
+function withChecksum(layout) {
+  let csum = 0;
+  for (let i = 0; i < layout.length; i++) {
+    let byte = layout.charCodeAt(i);
+    csum = (csum >> 1) + ((csum & 1) << 15);
+    csum += byte;
+  }
+  csum = csum & 65535;
+  return `${csum.toString(16).toLowerCase()},${layout}`;
+}
+
+// src/tmux-session-manager.ts
+var TmuxSessionManager = class {
+  client;
+  tmuxConfig;
+  serverUrl;
+  sessions = /* @__PURE__ */ new Map();
+  pollInterval;
+  enabled = false;
+  shuttingDown = false;
+  mainPaneId = null;
+  readyPromise = null;
+  constructor(ctx, tmuxConfig, serverUrl) {
+    this.client = ctx.client;
+    this.tmuxConfig = tmuxConfig;
+    this.serverUrl = serverUrl;
+    this.enabled = tmuxConfig.enabled && isInsideTmux();
+    log("[tmux-session-manager] initialized", {
+      enabled: this.enabled,
+      tmuxConfig: this.tmuxConfig,
+      serverUrl: this.serverUrl
+    });
+    if (this.enabled) {
+      this.readyPromise = this.initMainPaneId();
+      this.registerShutdownHandlers();
+    }
+  }
+  async initMainPaneId() {
+    try {
+      const tmux = await getTmuxPath();
+      if (!tmux) return;
+      const { execSync: execSync2 } = await import("child_process");
+      const result = execSync2(`${tmux} display-message -p "#{pane_id}"`, { encoding: "utf-8" }).trim();
+      if (result.startsWith("%")) {
+        this.mainPaneId = result;
+        log("[tmux-session-manager] identified main pane", { mainPaneId: this.mainPaneId });
+      }
+    } catch (err) {
+      log("[tmux-session-manager] failed to identify main pane", { error: String(err) });
+    }
+  }
+  async onSessionCreated(event) {
+    if (this.readyPromise) {
+      await this.readyPromise;
+    }
+    if (!this.enabled) return;
+    if (event.type !== "session.created") return;
+    const info = event.properties?.info;
+    if (!info?.id || !info?.parentID) {
+      return;
+    }
+    const sessionId = info.id;
+    const parentId = info.parentID;
+    const title = info.title ?? "Subagent";
+    if (this.sessions.has(sessionId)) {
+      log("[tmux-session-manager] session already tracked", { sessionId });
+      return;
+    }
+    log("[tmux-session-manager] child session created, spawning pane", {
+      sessionId,
+      parentId,
+      title
+    });
+    const paneResult = await spawnTmuxPane(
+      sessionId,
+      title,
+      this.tmuxConfig,
+      this.serverUrl
+    ).catch((err) => {
+      log("[tmux-session-manager] failed to spawn pane", {
+        error: String(err)
+      });
+      return { success: false, paneId: void 0 };
+    });
+    if (paneResult.success && paneResult.paneId) {
+      const now = Date.now();
+      this.sessions.set(sessionId, {
+        sessionId,
+        paneId: paneResult.paneId,
+        parentId,
+        title,
+        createdAt: now,
+        lastSeenAt: now
+      });
+      log("[tmux-session-manager] pane spawned", {
+        sessionId,
+        paneId: paneResult.paneId
+      });
+      this.startPolling();
+      void this.recalculateLayout();
+    }
+  }
+  async recalculateLayout() {
+    if (this.tmuxConfig.layout !== "dynamic-vertical") return;
+    if (!this.mainPaneId) return;
+    const tmux = await getTmuxPath();
+    if (!tmux) return;
+    try {
+      const { execSync: execSync2 } = await import("child_process");
+      const dims = execSync2(`${tmux} display-message -p "#{window_width},#{window_height}"`, { encoding: "utf-8" }).trim().split(",");
+      const width = parseInt(dims[0], 10);
+      const height = parseInt(dims[1], 10);
+      if (isNaN(width) || isNaN(height)) return;
+      const paneIds = Array.from(this.sessions.values()).sort((a, b) => a.createdAt - b.createdAt).map((s) => s.paneId).filter((id) => id !== this.mainPaneId);
+      const layoutString = generateLayoutString({
+        width,
+        height,
+        mainPaneSizePercent: this.tmuxConfig.main_pane_size ?? 60,
+        paneIds,
+        mainPaneId: this.mainPaneId,
+        maxAgentsPerColumn: this.tmuxConfig.max_agents_per_column ?? 3
+      });
+      if (layoutString) {
+        const { spawnAsync: spawnAsync2 } = await Promise.resolve().then(() => (init_tmux(), tmux_exports));
+        await spawnAsync2([tmux, "select-layout", layoutString]);
+        log("[tmux-session-manager] applied dynamic layout", { layoutString });
+      }
+    } catch (err) {
+      log("[tmux-session-manager] failed to recalculate layout", { error: String(err) });
+    }
+  }
+  startPolling() {
+    if (this.pollInterval) return;
+    this.pollInterval = setInterval(
+      () => this.pollSessions(),
+      POLL_INTERVAL_MS
+    );
+    log("[tmux-session-manager] polling started");
+  }
+  stopPolling() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = void 0;
+      log("[tmux-session-manager] polling stopped");
+    }
+  }
+  async pollSessions() {
+    if (this.sessions.size === 0) {
+      this.stopPolling();
+      return;
+    }
+    try {
+      const statusResult = await this.client.session.status();
+      const allStatuses = statusResult.data ?? {};
+      const now = Date.now();
+      const sessionsToClose = [];
+      for (const [sessionId, tracked] of this.sessions.entries()) {
+        const status = allStatuses[sessionId];
+        const isIdle = status?.type === "idle";
+        if (status) {
+          tracked.lastSeenAt = now;
+          tracked.missingSince = void 0;
+        } else if (!tracked.missingSince) {
+          tracked.missingSince = now;
+        }
+        const missingTooLong = !!tracked.missingSince && now - tracked.missingSince >= SESSION_MISSING_GRACE_MS;
+        const isTimedOut = now - tracked.createdAt > SESSION_TIMEOUT_MS;
+        if (isIdle || missingTooLong || isTimedOut) {
+          sessionsToClose.push(sessionId);
+        }
+      }
+      for (const sessionId of sessionsToClose) {
+        await this.closeSession(sessionId);
+      }
+    } 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) => {
+      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"));
+  }
+  handleShutdown(reason) {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    log("[tmux-session-manager] shutdown detected", { reason });
+    if (reason === "SIGINT") {
+      log("[tmux-session-manager] aggressive kill triggered (SIGINT)", { reason });
+      const result = killTmuxSessionSync();
+      log("[tmux-session-manager] killTmuxSessionSync result", { result });
+      process.exit(0);
+    }
+    void this.cleanup().finally(() => {
+      if (reason !== "beforeExit") {
+        process.exit(0);
+      }
+    });
+  }
+  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) {
+    const tracked = this.sessions.get(sessionId);
+    if (!tracked) return;
+    log("[tmux-session-manager] closing session pane", {
+      sessionId,
+      paneId: tracked.paneId
+    });
+    await closeTmuxPane(tracked.paneId);
+    this.sessions.delete(sessionId);
+    void this.recalculateLayout();
+    if (this.sessions.size === 0) {
+      this.stopPolling();
+    }
+  }
+  createEventHandler() {
+    return async (input) => {
+      await this.onSessionCreated(input.event);
+    };
+  }
+  async cleanup() {
+    this.stopPolling();
+    if (this.sessions.size > 0) {
+      log("[tmux-session-manager] closing all panes", {
+        count: this.sessions.size
+      });
+      const closePromises = Array.from(this.sessions.values()).map(
+        (s) => closeTmuxPane(s.paneId).catch(
+          (err) => log("[tmux-session-manager] cleanup error for pane", {
+            paneId: s.paneId,
+            error: String(err)
+          })
+        )
+      );
+      await Promise.all(closePromises);
+      this.sessions.clear();
+    }
+    log("[tmux-session-manager] cleanup complete");
+  }
+};
+
+// src/index.ts
+function detectServerUrl() {
+  if (process.env.OPENCODE_PORT) {
+    return `http://localhost:${process.env.OPENCODE_PORT}`;
+  }
+  return "http://localhost:4096";
+}
+function loadConfig(directory) {
+  const home = process.env.HOME ?? "";
+  const configPaths = [
+    {
+      path: path3.join(directory, "opentmux.json"),
+      legacy: false
+    },
+    {
+      path: path3.join(directory, "opencode-agent-tmux.json"),
+      legacy: true
+    },
+    {
+      path: path3.join(home, ".config", "opencode", "opentmux.json"),
+      legacy: false
+    },
+    {
+      path: path3.join(home, ".config", "opencode", "opencode-agent-tmux.json"),
+      legacy: true
+    }
+  ];
+  for (const { path: configPath, legacy } of configPaths) {
+    try {
+      if (fs2.existsSync(configPath)) {
+        if (legacy) {
+          console.warn(
+            "Deprecation: Using legacy opencode-agent-tmux config. Please update to opentmux"
+          );
+        }
+        const content = fs2.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(content);
+        const result = PluginConfigSchema.safeParse(parsed);
+        if (result.success) {
+          log("[plugin] loaded config", { configPath, config: result.data });
+          return result.data;
+        }
+        log("[plugin] config parse error", {
+          configPath,
+          error: result.error.message
+        });
+      }
+    } catch (err) {
+      log("[plugin] config load error", { configPath, error: String(err) });
+    }
+  }
+  const defaultConfig = PluginConfigSchema.parse({});
+  log("[plugin] using default config", { config: defaultConfig });
+  return defaultConfig;
+}
+var OpencodeTmux = async (ctx) => {
+  const config = loadConfig(ctx.directory);
+  const tmuxConfig = {
+    enabled: config.enabled,
+    layout: config.layout,
+    main_pane_size: config.main_pane_size,
+    max_agents_per_column: config.max_agents_per_column
+  };
+  const serverUrl = ctx.serverUrl?.toString() || detectServerUrl();
+  log("[plugin] initialized", {
+    tmuxConfig,
+    directory: ctx.directory,
+    serverUrl
+  });
+  if (tmuxConfig.enabled) {
+    startTmuxCheck();
+  }
+  const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig, serverUrl);
+  return {
+    name: "opentmux",
+    event: async (input) => {
+      await tmuxSessionManager.onSessionCreated(
+        input.event
+      );
+    }
+  };
+};
+var src_default = OpencodeTmux;
+export {
+  src_default as default
+};