// No shebang in source. The published bin is the compiled `bin/cli.js` // (see scripts/build-cli.mjs) which adds `#!/usr/bin/env node` via the // esbuild banner. Dev iteration uses `bun bin/cli.ts` directly, which // doesn't need a shebang. import { parseArgs } from "node:util"; import { resolve, dirname, join } from "node:path"; import { execFileSync } from "node:child_process"; import { existsSync } from "node:fs"; import { fileURLToPath } from "node:url"; const __dirname = dirname(fileURLToPath(import.meta.url)); // The node-runnable CLI path that spawned TUI surfaces shell back to (the app's // async fleet poll + `detect --write`). When we're the published `bin/cli.js` // this file IS it; under dev (`bun bin/cli.ts`) it's the built sibling // `bin/cli.js`. Forwarded to surfaces as TMUX_IDE_CLI so the COMPILED TUI binary // — whose own `import.meta.url` is a virtual bunfs path with no real cli.js next // to it — can still find the CLI to run its subprocesses. const selfPath = fileURLToPath(import.meta.url); const nodeCliPath = selfPath.endsWith(".js") ? selfPath : resolve(__dirname, "cli.js"); import { launch } from "../packages/daemon/src/launch.ts"; import { resolveEntry } from "../packages/daemon/src/tui/team/entry.ts"; import { loadAppConfig } from "../packages/daemon/src/lib/app-config.ts"; import { resolveTuiLaunch, findCompiledTui, isBunAvailable, } from "../packages/daemon/src/tui/compiled.ts"; import { init } from "../packages/daemon/src/init.ts"; import { stop } from "../packages/daemon/src/stop.ts"; import { attach } from "../packages/daemon/src/attach.ts"; import { ls } from "../packages/daemon/src/ls.ts"; import { doctor } from "../packages/daemon/src/doctor.ts"; import { status } from "../packages/daemon/src/status.ts"; import { inspect } from "../packages/daemon/src/inspect.ts"; import { validate } from "../packages/daemon/src/validate.ts"; import { detect } from "../packages/daemon/src/detect.ts"; import { config } from "../packages/daemon/src/config.ts"; import { restart } from "../packages/daemon/src/restart.ts"; import { restore } from "../packages/daemon/src/restore.ts"; import { send } from "../packages/daemon/src/send.ts"; import { IdeError } from "../packages/daemon/src/lib/errors.ts"; import { printCommandError } from "../packages/daemon/src/lib/output.ts"; import { wantsHostedApp, hostedEnvVars, hostedCommandLine, hostExistsArgv, hostCreateArgv, hostSetupArgvs, hostAttachArgv, HOSTED_ENV, } from "../packages/daemon/src/tui/mirror/hosted.ts"; const { positionals, values } = parseArgs({ allowPositionals: true, strict: false, options: { json: { type: "boolean" }, row: { type: "string" }, pane: { type: "string" }, title: { type: "string" }, command: { type: "string" }, size: { type: "string" }, write: { type: "boolean" }, template: { type: "string" }, name: { type: "string" }, verbose: { type: "boolean", default: false }, help: { type: "boolean", short: "h" }, version: { type: "boolean", short: "v" }, port: { type: "string" }, // setup command flags edit: { type: "boolean" }, wizard: { type: "boolean" }, // send command flags to: { type: "string" }, "no-enter": { type: "boolean" }, // wait command flags status: { type: "string" }, timeout: { type: "string" }, match: { type: "string" }, // events command flag follow: { type: "boolean" }, // force the team cockpit instead of launching a project team: { type: "boolean" }, // adopt every live (non-internal) session at once all: { type: "boolean" }, // restore: print the plan without touching tmux "dry-run": { type: "boolean" }, // restore: replay recorded pane commands (off by default for safety) "run-commands": { type: "boolean" }, // restore: revive agent conversations via `claude --resume ` "resume-agents": { type: "boolean" }, // statusline: the session whose bar is being rendered active: { type: "string" }, // switcher: the tmux client the popup was invoked on (see `switcher` case) client: { type: "string" }, // team --popup: run the home cockpit as a popup over a tmux client (M-h) popup: { type: "boolean" }, // sidebar-toggle: the session whose nav column is toggled (see `sidebar-toggle`) session: { type: "string" }, // menu: the click position (mouse binds forward #{mouse_x}/#{mouse_y}) so the // actions menu opens at the pointer instead of centered (see `menu` case) x: { type: "string" }, y: { type: "string" }, // app: host the cockpit in the internal `_tmux-ide-app` session and attach // to it (M23.2) — `--detachable` is the primary name, `--hosted` the alias detachable: { type: "boolean" }, hosted: { type: "boolean" }, // worktree: base ref for a new branch, the worktree checkout dir override, // skip creating a session, and force-remove a dirty worktree (see `worktree`) from: { type: "string" }, dir: { type: "string" }, "no-session": { type: "boolean" }, force: { type: "boolean" }, }, }); const knownCommands = new Set([ "start", "init", "stop", "attach", "restart", "restore", "ls", "doctor", "status", "inspect", "validate", "detect", "config", "setup", "send", "settings", "team", "app", "switcher", "wait", "events", "statusline", "adopt", "unadopt", "agent", "integration", "chrome-updater", "cheatsheet", "welcome", "menu", "popup", "sidebar-toggle", "worktree", "update", "skill-sync", "serve", "command-center", "server", "help", ]); // --version / -v if (values.version) { const pkg = await import("../package.json"); console.log(`tmux-ide v${pkg.version}`); process.exit(0); } if (values.verbose) { globalThis.__tmuxIdeVerbose = true; } const firstPositional = positionals[0]; const resolved = firstPositional; const hasKnownCommand = resolved ? knownCommands.has(resolved) : false; const command = hasKnownCommand ? resolved : "start"; const startTargetDir = hasKnownCommand ? positionals[1] : firstPositional; const json = values.json ?? false; const noColor = "NO_COLOR" in process.env; const bold = (s: string) => (noColor ? s : `\x1b[1m${s}\x1b[22m`); const cyan = (s: string) => (noColor ? s : `\x1b[36m${s}\x1b[39m`); const dim = (s: string) => (noColor ? s : `\x1b[2m${s}\x1b[22m`); if (values.help) { printHelp(); process.exit(0); } function printHelp() { console.log(`${bold("tmux-ide")} — Terminal IDE powered by tmux ${bold("Usage:")} ${cyan("tmux-ide")} ${dim("Launch ide.yml, or open the team cockpit if none")} ${cyan("tmux-ide ")} ${dim("Launch from a specific directory (cockpit if no ide.yml)")} ${cyan("tmux-ide setup")} ${dim("Interactive TUI setup wizard")} ${cyan("tmux-ide setup --edit")} ${dim("Open config tree editor")} ${cyan("tmux-ide settings")} ${dim("Interactive TUI config manager")} ${cyan("tmux-ide init")} [--template] ${dim("Scaffold a new ide.yml (auto-detects stack)")} ${cyan("tmux-ide stop")} ${dim("Kill the current IDE session")} ${cyan("tmux-ide restart")} ${dim("Stop and relaunch the IDE session")} ${cyan("tmux-ide restore")} [--dry-run] [--run-commands] [--resume-agents] [--json] ${dim("Rebuild the fleet from the last snapshot after a tmux crash")} ${dim("(--resume-agents revives claude conversations via claude --resume)")} ${cyan("tmux-ide attach")} ${dim("Reattach to a running session")} ${cyan("tmux-ide team")} [--json] ${dim("TUI over all tmux sessions (--json prints fleet state)")} ${cyan("tmux-ide app")} [session] ${dim("Unified app: fleet home + live session mirror (bare = home)")} ${cyan("tmux-ide app --detachable")} ${dim("Host the app in tmux and attach — survives the terminal, ^q detaches")} ${cyan("tmux-ide switcher")} ${dim("Compact session picker (opens in the M-p popup on adopted sessions)")} ${cyan("tmux-ide wait agent-status")} --status [--timeout ] ${dim("Block until a session reaches a status (exit 0 match / 1 timeout)")} ${cyan("tmux-ide wait output")} --match [--timeout ] ${dim("Block until a pane's output matches a regex (exit 0 match / 1 timeout)")} ${cyan("tmux-ide events")} [--follow] [--json] [--socket] ${dim("Stream agent-status transitions (--socket: push from a running serve)")} ${cyan("tmux-ide serve")} [--socket ] ${dim("Local control socket: NDJSON verbs + pushed events (~/.tmux-ide/control.sock)")} ${cyan("tmux-ide adopt")} ${dim("Add the live tmux-ide status bar to a session")} ${cyan("tmux-ide adopt --all")} ${dim("Adopt every live (non-internal) session")} ${cyan("tmux-ide unadopt")} ${dim("Remove the status bar")} ${cyan("tmux-ide integration install claude")} ${dim("Authoritative agent status via Claude Code hooks")} ${cyan("tmux-ide agent explain")} [--json] ${dim("Debug how a pane's agent state is detected")} ${cyan("tmux-ide cheatsheet")} ${dim("Print the key cheat sheet (⌥k / [ ? keys ] popup)")} ${cyan("tmux-ide menu")} [--client N] ${dim("Open the right-click actions menu (⌥m / right-click any pane or the bar)")} ${cyan("tmux-ide popup")} ${dim("Open a widget as a floating panel (explorer/changes/config; ⌥e/⌥g/⌥,)")} ${cyan("tmux-ide sidebar-toggle")} [--session S] ${dim("Toggle the app nav column (⌥b on adopted sessions)")} ${cyan("tmux-ide worktree create")} [--from ] [--dir ] [--no-session] ${dim("Add a git worktree (new branch) + open a session in it")} ${cyan("tmux-ide worktree open")} ${dim("Open (or switch to) the session for an existing worktree")} ${cyan("tmux-ide worktree list")} [--json] ${dim("List worktrees joined with their session status")} ${cyan("tmux-ide worktree remove")} [--force] ${dim("Kill the worktree's session + remove the worktree")} ${cyan("tmux-ide ls")} ${dim("List all tmux sessions")} ${cyan("tmux-ide status")} [--json] ${dim("Show session status")} ${cyan("tmux-ide inspect")} [--json] ${dim("Show effective config and runtime state")} ${cyan("tmux-ide doctor")} ${dim("Check system requirements")} ${cyan("tmux-ide update")} [--dry-run] ${dim("Update tmux-ide (detects dev checkout vs npm/pnpm/bun global)")} ${cyan("tmux-ide update --manifests")} ${dim("Fetch the latest agent-detection manifest pack (your overrides still win)")} ${cyan("tmux-ide skill-sync")} ${dim("Refresh the bundled Claude Code skill in ~/.claude/skills/tmux-ide")} ${cyan("tmux-ide validate")} [--json] ${dim("Validate ide.yml")} ${cyan("tmux-ide detect")} [--json] ${dim("Detect project stack")} ${cyan("tmux-ide detect --write")} ${dim("Detect and write ide.yml")} ${cyan("tmux-ide config")} [--json] ${dim("Dump config as JSON")} ${cyan("tmux-ide config set")} ${cyan("tmux-ide config add-pane")} --row --title [--command ] ${cyan("tmux-ide config remove-pane")} --row --pane ${cyan("tmux-ide config add-row")} [--size ] ${cyan("tmux-ide config enable-team")} [--name ] ${dim("Enable agent teams")} ${cyan("tmux-ide config disable-team")} ${dim("Disable agent teams")} ${bold("Pane Messaging:")} ${cyan("tmux-ide send")} ${dim("Send message to a pane")} ${cyan("tmux-ide send")} --to ${dim("Target by name, title, role, or ID")} ${cyan("tmux-ide send")} --no-enter msg ${dim("Send text without pressing Enter")} ${bold("Server:")} ${cyan("tmux-ide command-center")} [--port N] ${dim("Start the command-center HTTP API")} ${cyan("tmux-ide server")} [--port N] ${dim("Start HTTP + PTY WebSocket server")} ${bold("Discover (in the TUI):")} ${dim("Bare")} ${cyan("tmux-ide")} ${dim("with no ide.yml opens the HOME cockpit — the fleet home screen.")} ${dim("Once a session is adopted, the whole UI is one keystroke away:")} ${cyan("⌥h")} ${dim("home cockpit from anywhere ")}${cyan("⌥p")} ${dim("switch session")} ${cyan("⌥k")} ${dim("cheat sheet (all keys) ")}${cyan("⌥m")} ${dim("actions menu (or right-click any pane / the bar)")} ${cyan("⌥e ⌥g ⌥,")} ${dim("file / changes / config panels ")}${cyan("⌥b")} ${dim("sidebar")} ${dim("A first-run welcome card names these keys once. Run")} ${cyan("tmux-ide cheatsheet")} ${dim("to see the full sheet.")} ${bold("Flags:")} ${cyan("--json")} ${dim("Output as JSON (all commands)")} ${cyan("--template ")} ${dim("Use specific template for init")} ${cyan("--write")} ${dim("Write detected config to ide.yml")} ${cyan("--verbose")} ${dim("Log all tmux commands (or set TMUX_IDE_DEBUG=1)")} ${cyan("-h, --help")} ${dim("Show usage")} ${cyan("-v, --version")} ${dim("Show version number")}`); } // The TUI surfaces are OpenTUI/Solid `.tsx` that need the `bun` runtime and the // checkout sources. On a clean `npm i -g tmux-ide` neither is present, so we // fall back to the compiled `tmux-ide-tui` binary (see scripts/build-tui.mjs). // `resolveTuiLaunch` encodes the "checkout first, binary second" order; when // nothing is available it hands back an actionable reason set for an IdeError. function execBunWidget( surface: string, scriptPath: string, args: string[], commandLabel: string, extraEnv: Record = {}, ): void { const launch = resolveTuiLaunch({ surface, scriptPath, args, checkoutExists: existsSync(scriptPath), bunAvailable: isBunAvailable(), compiledBinary: findCompiledTui(), }); if (launch.mode === "unavailable") { throw new IdeError( `\`tmux-ide ${commandLabel}\` is unavailable because ${launch.reasons.join(" and ")}.\n` + `Install bun (https://bun.sh) — the TUI surfaces run on it. Sources ship with the npm package since v2.6.1.`, { code: "USAGE", exitCode: 1 }, ); } const env = { ...process.env, TMUX_IDE_CWD: process.cwd(), TMUX_IDE_CLI: nodeCliPath, ...extraEnv, }; if (launch.mode === "bun") { // Spawn from the repo root so bun finds `bunfig.toml` (the @opentui/solid // JSX preload). Without this, running from any other cwd — e.g. bare // `tmux-ide` in a project dir — falls back to the React JSX runtime and the // widget fails to load. The real invocation dir rides in env so in-widget // prompts (register / new session) still default to where the user is. execFileSync(launch.bin, launch.argv, { stdio: "inherit", cwd: resolve(__dirname, ".."), env, }); return; } // Compiled binary: the JSX transform and native dylib are already baked in, // so there is no bunfig to find — run from the user's actual cwd (also avoids // a stray repo-root bunfig.toml preload the standalone binary can't resolve). execFileSync(launch.bin, launch.argv, { stdio: "inherit", env }); } // The detachable cockpit (M23.2): instead of running the app in THIS terminal, // ensure the internal `_tmux-ide-app` session exists running it full-screen // (status off, window-size latest — see hostSetupArgvs), then attach here. // Re-invocation from any terminal reattaches the SAME cockpit; ^q inside a // hosted app detaches (the HOSTED_ENV marker on the pane command flips it). // Inside tmux the client switch-clients instead of nesting an attach. function launchHostedApp(scriptPath: string, appArgs: string[]): void { const launch = resolveTuiLaunch({ surface: "app", scriptPath, args: appArgs, checkoutExists: existsSync(scriptPath), bunAvailable: isBunAvailable(), compiledBinary: findCompiledTui(), }); if (launch.mode === "unavailable") { throw new IdeError( `\`tmux-ide app --detachable\` is unavailable because ${launch.reasons.join(" and ")}.\n` + `Install bun (https://bun.sh) — the TUI surfaces run on it. Sources ship with the npm package since v2.6.1.`, { code: "USAGE", exitCode: 1 }, ); } let exists = true; try { execFileSync("tmux", hostExistsArgv(), { stdio: "ignore" }); } catch { exists = false; // also covers "no server yet" — new-session starts one } if (!exists) { // Same cwd rule as execBunWidget: bun needs the repo root (bunfig preload), // the compiled binary must NOT run from it. The app's real env travels on // the pane command line — the tmux server's environment is not ours. const cwd = launch.mode === "bun" ? resolve(__dirname, "..") : process.cwd(); const commandLine = hostedCommandLine( launch.bin, launch.argv, hostedEnvVars({ cwd: process.cwd(), cli: nodeCliPath, path: process.env.PATH, home: process.env.TMUX_IDE_HOME, config: process.env.TMUX_IDE_CONFIG, tuiBin: process.env.TMUX_IDE_TUI_BIN, }), ); execFileSync("tmux", hostCreateArgv({ cwd, commandLine }), { stdio: "ignore" }); } // Setup runs on EVERY ensure, not just create (M25.5): the list is // idempotent, so this upgrades a host created by an older tmux-ide (no // resize hooks yet) and re-asserts `window-size latest` on a host a stray // `resize-window` flipped to manual — the measured way a cockpit gets stuck // at a departed client's size. for (const args of hostSetupArgvs()) execFileSync("tmux", args, { stdio: "ignore" }); execFileSync("tmux", hostAttachArgv(Boolean(process.env.TMUX)), { stdio: "inherit" }); } // The scriptable control surface for the cockpit: print the fleet state as JSON // and exit without spawning the (bun/OpenTUI) TUI. Shared by `tmux-ide team // --json` and bare `tmux-ide --json` when there's no ide.yml to launch. Dynamic // imports keep the interactive path free of the data-layer modules. async function printFleetJson(): Promise { const { createStatusTracker } = await import("../packages/daemon/src/tui/detect/classify.ts"); const { listTeamProjects } = await import("../packages/daemon/src/tui/team/projects.ts"); const { toFleetJson } = await import("../packages/daemon/src/tui/team/report.ts"); console.log(JSON.stringify(toFleetJson(listTeamProjects(createStatusTracker())), null, 2)); } // The `--socket[=path]` opt-in (undeclared in parseArgs on purpose: bare // `--socket` parses to `true`, `--socket=/path` to the path — strict:false // gives optional-value semantics parseArgs can't declare). `true | string | // undefined`; string overrides the default socket path. const socketFlag = values.socket as string | boolean | undefined; // Run a `wait` on a live `tmux-ide serve` (connect once, the server holds the // wait — no local polling). Returns null when the flag is off, no server // answers, or the connection drops mid-wait — callers fall back SILENTLY to // the local polling implementation (same shared logic, tui/team/wait.ts). async function waitOverSocket( params: Record, ): Promise<{ timedOut: boolean; data?: unknown } | null> { if (!socketFlag) return null; const { connectControl, ControlRequestError } = await import("../packages/daemon/src/control/client.ts"); let client: Awaited>; try { client = await connectControl({ socketPath: typeof socketFlag === "string" ? socketFlag : undefined, }); } catch { return null; // no server listening — poll locally instead } try { const data = await client.request("wait", params); return { timedOut: false, data }; } catch (err) { if (err instanceof ControlRequestError && err.code === "timeout") return { timedOut: true }; return null; // dropped/errored mid-wait — fall back to polling } finally { client.close(); } } const teamScriptPath = resolve(__dirname, "../packages/daemon/src/tui/team/index.tsx"); const appScriptPath = resolve(__dirname, "../packages/daemon/src/tui/mirror/app.tsx"); // `tmux-ide team` runs the standalone full-screen cockpit (the OpenTUI app owns // the whole terminal). The floating switcher popup (M-p on adopted sessions) // supersedes the old nested `[ switcher | main ]` host shell. function launchTeamCockpit(): void { execBunWidget("team", teamScriptPath, [], "team"); } // The one entry for the unified app: `--detachable`/`--hosted` (or // `app.detachable` in config) route through the hosted launcher, everything // else runs the app in this terminal as before. The HOSTED_ENV guard keeps the // app INSIDE the host session from re-hosting itself. function runApp(appArgs: string[]): void { const hosted = wantsHostedApp({ flagDetachable: values.detachable === true, flagHosted: values.hosted === true, configDetachable: loadAppConfig().app.detachable, hostedEnv: process.env[HOSTED_ENV] === "1", }); if (hosted) launchHostedApp(appScriptPath, appArgs); else execBunWidget("app", appScriptPath, appArgs, "app"); } // The unified app as the front door (M22.6): bare `tmux-ide` opens `tmux-ide // app`'s HOME panel when `app.frontDoor` is on and there's nothing else to // launch. Same entry as the explicit `app` command with no session positional // — including the hosted flip when `app.detachable` is set (M23.2). function launchApp(): void { runApp([]); } try { switch (command) { case "start": { // npm-style staleness nudge: one dim stderr line when a newer version is // cached (never on --json, never blocking — best-effort, and stderr so it // can't corrupt piped stdout). The dock is the primary surface; this is the // hint for the moment you actually run the command. if (!json) { try { const { getUpdateStatus } = await import("../packages/daemon/src/lib/update-check.ts"); const { latest, updateAvailable } = getUpdateStatus(); if (updateAvailable && latest) { process.stderr.write( dim(`⬆ tmux-ide v${latest} available — run \`tmux-ide update\`\n`), ); } } catch { // never let the update hint interfere with launching } } const targetDir = resolve(startTargetDir || "."); const hasIdeYml = existsSync(join(targetDir, "ide.yml")); // M22.6 — the front-door decision. `--team` always means the classic // cockpit; a present ide.yml still auto-launches the project; otherwise // `app.frontDoor` flips the default no-project entry to the unified app. const entry = resolveEntry({ hasIdeYml, teamFlag: values.team === true, frontDoor: loadAppConfig().app.frontDoor, }); if (entry !== "project") { // No project to launch here. `--json` is a scripting surface — it always // prints the fleet, whichever interactive front door is configured. if (json) { await printFleetJson(); break; } if (entry === "app") launchApp(); else launchTeamCockpit(); break; } await launch(startTargetDir, { json }); break; } case "init": await init({ template: values.template, json }); break; case "stop": await stop(positionals[1], { json }); break; case "attach": await attach(positionals[1], { json }); break; case "restart": await restart(positionals[1], { json }); break; case "restore": await restore({ json, dryRun: values["dry-run"] === true, runCommands: values["run-commands"] === true, resumeAgents: values["resume-agents"] === true, }); break; case "ls": await ls({ json }); break; case "doctor": await doctor({ json }); break; case "status": await status(positionals[1], { json }); break; case "inspect": await inspect(positionals[1], { json }); break; case "validate": await validate(positionals[1], { json }); break; case "detect": await detect(positionals[1], { json, write: values.write }); break; case "config": { const sub = positionals[1]; let action = "dump"; let configArgs: string[] = []; if (sub === "set") { action = "set"; configArgs = positionals.slice(2); } else if (sub === "add-pane") { action = "add-pane"; configArgs = []; if (values.row !== undefined) configArgs.push("--row", values.row); if (values.title !== undefined) configArgs.push("--title", values.title); if (values.command !== undefined) configArgs.push("--command", values.command); if (values.size !== undefined) configArgs.push("--size", values.size); } else if (sub === "remove-pane") { action = "remove-pane"; configArgs = []; if (values.row !== undefined) configArgs.push("--row", values.row); if (values.pane !== undefined) configArgs.push("--pane", values.pane); } else if (sub === "add-row") { action = "add-row"; configArgs = []; if (values.size !== undefined) configArgs.push("--size", values.size); } else if (sub === "enable-team") { action = "enable-team"; configArgs = []; if (values.name !== undefined) configArgs.push("--name", values.name); } else if (sub === "disable-team") { action = "disable-team"; configArgs = []; } else if (sub === "edit") { const scriptPath = resolve(__dirname, "../packages/daemon/src/widgets/setup/index.tsx"); execBunWidget( "setup", scriptPath, ["--dir=" + resolve(startTargetDir || "."), "--edit"], "config edit", ); break; } await config(null, { json, action, args: configArgs }); break; } case "setup": { const scriptPath = resolve(__dirname, "../packages/daemon/src/widgets/setup/index.tsx"); const setupArgs = ["--dir=" + resolve(startTargetDir || ".")]; if (positionals[1] === "--edit" || values.edit) setupArgs.push("--edit"); if (positionals[1] === "--wizard" || values.wizard) setupArgs.push("--wizard"); execBunWidget("setup", scriptPath, setupArgs, "setup"); break; } case "send": { const target = values.to ?? positionals[1]; const messageStart = values.to ? 1 : 2; let message = positionals.slice(messageStart).join(" "); if (!message && !process.stdin.isTTY) { const { readFileSync } = await import("node:fs"); message = readFileSync(0, "utf-8").trim(); } await send(null, { json, to: target, message, noEnter: values["no-enter"] }); break; } case "settings": { const scriptPath = resolve(__dirname, "../packages/daemon/src/widgets/config/index.tsx"); execBunWidget("config", scriptPath, ["--dir=" + resolve(startTargetDir || ".")], "settings"); break; } case "team": { // `--json` is the scriptable control surface: print the fleet state and // exit without spawning the (bun/OpenTUI) TUI. if (json) { await printFleetJson(); break; } // `--popup` runs the FULL home cockpit inside a tmux `display-popup` (bound // to `M-h` on adopt / the dock's `[ ⌂ home ⌥h ]` trigger). Like the // switcher, `TMUX_IDE_POPUP_CLIENT` flips popup mode (Enter switch-clients // the invoking client + closes) and carries an optional explicit client; // empty means "resolve it yourself from inside the popup". Unlike the // switcher it keeps the full two-column layout, not the compact picker. if (values.popup === true) { const clientArg = typeof values.client === "string" ? values.client : ""; execBunWidget("team", teamScriptPath, [], "team --popup", { TMUX_IDE_POPUP_CLIENT: clientArg, }); break; } launchTeamCockpit(); break; } case "app": { // The unified app (M18.1): sidebar fleet + a live tmux-session mirror. // Bare `tmux-ide app` opens the HOME panel (fleet cards); an optional // session positional boots straight into that session's mirror. With // `--detachable` (alias `--hosted`, or `app.detachable` in config) the // app runs in the internal `_tmux-ide-app` session instead and this // terminal attaches to it (M23.2) — the positional only shapes the // cockpit at CREATE time; a reattach finds the app exactly as left. const session = positionals[1]; const appArgs = session ? [`--target=${session}`] : []; runApp(appArgs); break; } case "switcher": { // Runs the team app in PICKER mode inside a tmux `display-popup` (bound to // `M-p` on adopt). Picking a session `switch-client`s the invoking client // there and the app exits, closing the popup. `TMUX_IDE_PICKER_CLIENT` // both flips the app into picker mode and carries an optional explicit // client name; empty means "resolve it yourself from inside the popup". const clientArg = typeof values.client === "string" ? values.client : ""; execBunWidget("team", teamScriptPath, [], "switcher", { TMUX_IDE_PICKER_CLIENT: clientArg }); break; } case "wait": { const sub = positionals[1]; // `wait output --match ` — block until a pane's // captured text matches. The target may be a pane id (%N) or a session // name; tmux resolves both (a session targets its active pane). if (sub === "output") { const target = positionals[2]; const pattern = values.match; if (!target || typeof pattern !== "string" || pattern.length === 0) { console.error( "Usage: tmux-ide wait output --match [--timeout ] [--socket[=path]]", ); process.exit(1); } try { new RegExp(pattern!); // validate up front; a bad pattern is a usage error } catch (err) { console.error(`Invalid --match regex: ${(err as Error).message}`); process.exit(1); } const outTimeout = Number(values.timeout ?? "60000"); // `--socket` fast path: let a running `tmux-ide serve` hold the wait // (one process, no spawn-per-poll). Falls back silently when no server // is listening — the polling below is exactly the same implementation. const viaSocket = await waitOverSocket({ kind: "output", target, match: pattern, timeoutMs: outTimeout, }); if (viaSocket) { if (viaSocket.timedOut) { console.error( `Timed out after ${outTimeout}ms waiting for ${target} output to match /${pattern}/`, ); process.exit(1); } const hit = (viaSocket.data as { matched: string }).matched; if (json) console.log(JSON.stringify({ matched: hit })); else console.log(hit); process.exit(0); } const { waitForOutputMatch } = await import("../packages/daemon/src/tui/team/wait.ts"); const result = await waitForOutputMatch(target!, pattern!, { timeoutMs: outTimeout }); if (!result.ok) { console.error( `Timed out after ${outTimeout}ms waiting for ${target} output to match /${pattern}/`, ); process.exit(1); } if (json) console.log(JSON.stringify({ matched: result.matched })); else console.log(result.matched); process.exit(0); } const VALID = new Set(["blocked", "working", "done", "idle", "unknown"]); const sessionName = positionals[2]; const want = values.status; if (sub !== "agent-status" || !sessionName || typeof want !== "string" || !VALID.has(want)) { console.error( "Usage: tmux-ide wait agent-status --status [--timeout ] [--socket[=path]]", ); process.exit(1); } const timeout = Number(values.timeout ?? "60000"); const viaSocket = await waitOverSocket({ kind: "agent-status", session: sessionName, status: want, timeoutMs: timeout, }); if (viaSocket) { if (viaSocket.timedOut) { console.error( `Timed out after ${timeout}ms waiting for ${sessionName} to reach status "${want}"`, ); process.exit(1); } if (json) console.log(JSON.stringify({ session: sessionName, status: want, ok: true })); else console.log(`${sessionName} reached status: ${want}`); process.exit(0); } const { waitForAgentStatus } = await import("../packages/daemon/src/tui/team/wait.ts"); const result = await waitForAgentStatus( sessionName!, want as import("../packages/daemon/src/tui/detect/classify.ts").AgentStatus, { timeoutMs: timeout }, ); if (!result.ok) { console.error( `Timed out after ${timeout}ms waiting for ${sessionName} to reach status "${want}" (last: ${result.status ?? "absent"})`, ); process.exit(1); } if (json) { console.log(JSON.stringify({ session: sessionName, status: result.status, ok: true })); } else { console.log(`${sessionName} reached status: ${result.status}`); } process.exit(0); break; } case "events": { // Stream agent-status transitions from the log the chrome updater writes. const { readFileSync, existsSync, statSync, openSync, readSync, closeSync } = await import("node:fs"); const { eventsPath, formatEventLine } = await import("../packages/daemon/src/tui/chrome/events.ts"); type Status = "blocked" | "working" | "done" | "idle" | "unknown"; type EventLike = { ts: string; session: string; from: Status | null; to: Status }; const path = eventsPath(); // Status → ANSI color, matching the chrome bar's palette in spirit. const paintStatus = (status: Status | null, text: string): string => { if (noColor || status === null) return text; const code = status === "blocked" ? "203" : status === "working" ? "221" : status === "done" ? "111" : status === "idle" ? "114" : "244"; return `\x1b[38;5;${code}m${text}\x1b[39m`; }; const printLine = (raw: string): void => { if (json) { console.log(raw); return; } try { const ev = JSON.parse(raw) as EventLike; console.log(formatEventLine(ev, paintStatus)); } catch { // skip malformed line } }; // `--follow --socket` fast path: a running `tmux-ide serve` PUSHES // transitions the moment its detection tick sees them — no file polling. // The last-50 backlog still comes from the log (the server has no // history); falls back silently to the polling path when no server is up. if (values.follow && socketFlag) { const { connectControl } = await import("../packages/daemon/src/control/client.ts"); const client = await connectControl({ socketPath: typeof socketFlag === "string" ? socketFlag : undefined, }).catch(() => null); if (client) { if (existsSync(path)) { const backlog = readFileSync(path, "utf8") .split("\n") .filter((l) => l.trim().length > 0); for (const line of backlog.slice(-50)) printLine(line); } await client.subscribe((frame) => { if (frame.event === "agent-status") printLine(JSON.stringify(frame.data)); }); process.on("SIGINT", () => { client.close(); process.exit(0); }); // Ends when the server shuts down (EOF) — exit cleanly then. await client.done; break; } } if (!existsSync(path)) { console.log("no events yet — is a session adopted? (the chrome updater writes events)"); break; } const allLines = readFileSync(path, "utf8") .split("\n") .filter((l) => l.trim().length > 0); for (const line of allLines.slice(-50)) printLine(line); if (!values.follow) break; // Follow: poll the file for appended bytes and stream complete new lines. let offset = statSync(path).size; let leftover = ""; const timer = setInterval(() => { let size: number; try { size = statSync(path).size; } catch { return; } if (size < offset) { // rotated/truncated — restart from the top of the new file offset = 0; leftover = ""; } if (size <= offset) return; const fd = openSync(path, "r"); try { const buf = Buffer.alloc(size - offset); readSync(fd, buf, 0, buf.length, offset); offset = size; const parts = (leftover + buf.toString("utf8")).split("\n"); leftover = parts.pop() ?? ""; for (const line of parts) if (line.trim().length > 0) printLine(line); } finally { closeSync(fd); } }, 500); process.on("SIGINT", () => { clearInterval(timer); process.exit(0); }); // Keep the process alive; the interval + SIGINT handler own the lifecycle. await new Promise(() => {}); break; } case "statusline": { // Called by tmux via #() every status-interval — keep it lean and never // let an error corrupt the bar (print a minimal brand instead). try { const { createStatusTracker } = await import("../packages/daemon/src/tui/detect/classify.ts"); const { listTeamProjects } = await import("../packages/daemon/src/tui/team/projects.ts"); const { buildStatusline } = await import("../packages/daemon/src/tui/chrome/statusline.ts"); const { getAppConfig } = await import("../packages/daemon/src/lib/app-config.ts"); const projects = listTeamProjects(createStatusTracker()); console.log(buildStatusline(projects, values.active ?? null, 12, getAppConfig().theme)); } catch { console.log("#[fg=colour75,bold] tmux-ide #[default]"); } break; } case "adopt": { const { adoptSession, adoptableSessionNames } = await import("../packages/daemon/src/tui/chrome/statusline.ts"); if (values.all) { // Adopt every live session that isn't internal (`_`-prefixed plumbing). const raw = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], }).trim(); const targets = raw ? adoptableSessionNames(raw.split("\n")) : []; if (targets.length === 0) { console.log("no adoptable sessions"); break; } for (const name of targets) { adoptSession(name); console.log(`adopted ${name}`); } break; } const target = positionals[1]; if (!target) { console.error("Usage: tmux-ide adopt | tmux-ide adopt --all"); process.exit(1); } adoptSession(target); console.log(`adopted ${target} — chrome row active (unadopt to remove)`); break; } case "unadopt": { const { unadoptSession } = await import("../packages/daemon/src/tui/chrome/statusline.ts"); const target = positionals[1]; if (!target) { console.error("Usage: tmux-ide unadopt "); process.exit(1); } unadoptSession(target); console.log(`unadopted ${target}`); break; } case "agent": { const sub = positionals[1]; const target = positionals[2]; if (sub !== "explain" || !target) { console.error( "Usage: tmux-ide agent explain [--json]\n" + " a pane id (%N) or a session name (uses its active pane)\n" + " Prints how the fleet detector classifies the pane: authority,\n" + " hint, resolved manifest, per-state rule results, and the snapshot.", ); process.exit(1); } const { agentExplain } = await import("../packages/daemon/src/agent-explain.ts"); agentExplain(target, { json }); break; } case "integration": { const sub = positionals[1]; const agent = positionals[2]; // `status` and `offer` need no agent arg; install/uninstall take a kind // we ship an integration for (claude hooks, opencode plugin). const needsAgent = sub === "install" || sub === "uninstall"; const installable = agent === "claude" || agent === "opencode"; if (!sub || (needsAgent && !installable)) { console.error( "Usage: tmux-ide integration [claude|opencode]\n" + " install claude: hook lifecycle events into tmux pane state\n" + " opencode: plugin that records the session id for restore --resume-agents\n" + " uninstall remove exactly the tmux-ide entries for that agent\n" + " status list discovered agents + integration/capture state\n" + " offer one-time first-adopt install prompt (used by the popup)", ); process.exit(1); } if (needsAgent && agent === "opencode") { const oc = await import("../packages/daemon/src/tui/integrations/opencode.ts"); if (sub === "install") { const { pluginPath } = oc.installOpencodeIntegration(); console.log(`plugin: ${pluginPath}`); console.log( "installed — NEW opencode sessions record their session id into the pane\n" + "(@agent_session_id), so `tmux-ide restore --resume-agents` can revive them.", ); } else { const { wasInstalled } = oc.uninstallOpencodeIntegration(); console.log(wasInstalled ? "uninstalled — plugin removed" : "was not installed"); } break; } const mod = await import("../packages/daemon/src/tui/integrations/claude.ts"); if (sub === "install") { const { scriptPath, settingsPath } = mod.installClaudeIntegration(); // Hooks + skill = the complete agent setup, so one command does both: // the lifecycle hooks (authoritative status) AND a fresh copy of the // skill that tells the agent how to drive tmux-ide. const { syncSkill } = await import("../packages/daemon/src/lib/skill-sync.ts"); const skill = syncSkill(); console.log(`hook script: ${scriptPath}`); console.log(`settings: ${settingsPath} (backup written once as .tmux-ide.bak)`); console.log(`skill: ${skill.action} → ${skill.path} (v${skill.to})`); console.log( "installed — NEW Claude Code sessions now report working/blocked/done " + "authoritatively into the tmux-ide chrome.", ); // M25.1: this is the moment the user is wiring notifications, so offer // the macOS banner channel here — one plain y/N key, same shape as the // first-adopt offer. Skipped when already on, off-macOS, or when there // is no TTY to ask (TMUX_IDE_NOTIFY_KEY forces an answer for tests). const { getAppConfig, updateAppConfig } = await import("../packages/daemon/src/lib/app-config.ts"); const forcedKey = process.env.TMUX_IDE_NOTIFY_KEY; const canAsk = forcedKey !== undefined || process.stdin.isTTY === true; if (process.platform === "darwin" && !getAppConfig().notifications.macos && canAsk) { const act = (key: string): void => { if (key === "y" || key === "Y") { updateAppConfig({ notifications: { macos: true } }); console.log( "macOS notifications on — native branded banners will jump to the session when clicked.", ); } else { console.log( "skipped — turn banners on anytime: notifications.macos in ~/.tmux-ide/config.json.", ); } }; process.stdout.write("\nAlso get a macOS notification when an agent needs you? [y/N] "); if (forcedKey !== undefined) { console.log(forcedKey); act(forcedKey); } else { const key = await new Promise((resolve) => { try { process.stdin.setRawMode?.(true); process.stdin.resume(); process.stdin.once("data", (data) => resolve(data.toString())); } catch { resolve(""); // no readable stdin — treat as "no" } }); try { process.stdin.setRawMode?.(false); process.stdin.pause(); } catch { // best-effort terminal restore } console.log(/^[ -~]$/.test(key) ? key : ""); act(key); } } } else if (sub === "uninstall") { const { wasInstalled } = mod.uninstallClaudeIntegration(); console.log(wasInstalled ? "uninstalled — hook entries removed" : "was not installed"); } else if (sub === "offer") { // The one-time first-adopt prompt, run inside a `display-popup` by // adoptSession (see ../packages/daemon/src/tui/integrations/offer.ts). It // reads ONE key: `y` installs, anything else skips — and writes the // marker either way so it never asks twice. Must never throw or hang. const offerMod = await import("../packages/daemon/src/tui/integrations/offer.ts"); try { console.log(offerMod.buildOfferText()); } catch { console.log("Claude Code detected — install the tmux-ide integration? [y/N]"); } const act = (key: string): void => { offerMod.markIntegrationOffered(); if (key === "y" || key === "Y") { try { mod.installClaudeIntegration(); console.log("\ninstalled — new Claude Code sessions now report state to tmux-ide."); } catch (e) { console.log(`\ninstall failed: ${(e as Error).message}`); } } else { console.log("\nskipped — run `tmux-ide integration install claude` anytime."); } }; // Test/automation hook: a forced key exits immediately, no stdin — lets // the offer flow be exercised deterministically without a live keypress. const forced = process.env.TMUX_IDE_OFFER_KEY; if (forced !== undefined) { act(forced); process.exit(0); } const closeOffer = () => process.exit(0); const offerTimer = setTimeout(closeOffer, 60_000); offerTimer.unref?.(); try { process.stdin.setRawMode?.(true); process.stdin.resume(); process.stdin.once("data", (data) => { act(data.toString()); console.log("\n[ press any key to close ]"); process.stdin.once("data", closeOffer); process.stdin.once("end", closeOffer); }); process.stdin.once("end", closeOffer); } catch { closeOffer(); } } else { // status — the discovery table: every known agent, whether it's on PATH, // and (for agents we integrate) whether the integration is installed. const { discoverAgents } = await import("../packages/daemon/src/lib/agent-discovery.ts"); const agents = discoverAgents(); if (json) { console.log(JSON.stringify({ agents }, null, 2)); break; } for (const a of agents) { let state: string; if (a.path === null) state = "not found"; else if (a.integration) state = a.installed ? "integration installed ✓" : "on PATH — integration not installed"; else state = "detected (no integration)"; // The resume-key story: how @agent_session_id (what `restore // --resume-agents` revives from) gets captured for this kind. let capture = ""; if (a.path !== null) { if (a.capture === "probe") capture = " · session-id capture: automatic"; else if (a.capture !== null) capture = a.captureActive ? ` · session-id capture: ${a.capture} ✓` : ` · session-id capture: ${a.capture} (install to enable)`; else capture = " · session-id capture: none"; } console.log(` ${a.id.padEnd(10)} ${state}${capture}`); } } break; } case "chrome-updater": { // The background loop that keeps every adopted session's status var fresh. // Hosted in the hidden `_tmux-ide-chrome` tmux session (started on adopt); // blocks forever. Never let a boot error crash it — a dead updater just // means stale bars, not broken sessions. try { const { runUpdaterLoop } = await import("../packages/daemon/src/tui/chrome/updater.ts"); runUpdaterLoop(); } catch { process.exit(0); } break; } case "cheatsheet": { // Renders the static key cheat sheet, then blocks until ANY key closes it // (the popup exits). Runs inside a tmux `display-popup` (bound to M-k on // adopt / the `[ ? keys ]` bar trigger), so it must never throw — a broken // render should still print something and still close on a keypress. try { const { buildCheatsheet } = await import("../packages/daemon/src/tui/chrome/cheatsheet.ts"); const { getAppConfig } = await import("../packages/daemon/src/lib/app-config.ts"); const cfg = getAppConfig(); console.log( buildCheatsheet({ width: process.stdout.columns ?? 100, keys: cfg.keys, theme: cfg.theme, }), ); } catch { console.log("tmux-ide — press ⌥p for the switcher, ⌥k for this sheet. Any key closes."); } // Wait for a single keypress, then exit 0 so the popup closes. Fall back to // an auto-close after 60s if stdin never delivers (e.g. no raw mode). const close = () => process.exit(0); const timer = setTimeout(close, 60_000); timer.unref?.(); try { process.stdin.setRawMode?.(true); process.stdin.resume(); process.stdin.once("data", close); // A closed/redirected stdin (` process.exit(0); const welcomeTimer = setTimeout(closeWelcome, 60_000); welcomeTimer.unref?.(); try { process.stdin.setRawMode?.(true); process.stdin.resume(); process.stdin.once("data", closeWelcome); process.stdin.once("end", closeWelcome); } catch { closeWelcome(); } break; } case "menu": { // Build the native tmux actions menu at CLICK TIME (the session list is // live) and display it on the invoking client. Bound via `run-shell -b` so // `#{client_name}` format-expands into `--client` (verified live on tmux // 3.6 — it resolves to the triggering / most-recently-active client). Runs // inside tmux's key/mouse dispatch, so it must never throw or HANG — every // tmux call below is capped at 2s and a missing client degrades to a no-op. try { // Every tmux shell-out gets a hard 2s cap: the old fallback // (`display-message -p '#{client_name}'` from outside a client) could // block indefinitely and wedge the bind. `timeout` throws on expiry, // caught below → silent no-op. const tmuxCap = { encoding: "utf8" as const, stdio: ["ignore", "pipe", "ignore"] as const, timeout: 2000, }; // Resolve the target client. Prefer the `--client` the bind expanded; if // it's empty or an unexpanded `#{…}` literal, fall back to the // most-recently-active attached client (list-clients sorted by // client_activity desc). No clients at all → exit 0 silently (fired from // tmux dispatch, a no-op beats an error). const rawClient = typeof values.client === "string" ? values.client : ""; let client = rawClient && !rawClient.includes("#{") ? rawClient : ""; if (!client) { const raw = execFileSync( "tmux", ["list-clients", "-F", "#{client_activity} #{client_name}"], tmuxCap, ).trim(); const newest = raw .split("\n") .filter(Boolean) .map((line) => { const sp = line.indexOf(" "); return { activity: Number(line.slice(0, sp)), name: line.slice(sp + 1) }; }) .sort((a, b) => b.activity - a.activity)[0]; client = newest?.name ?? ""; } if (!client) break; // no attached clients — nothing to show const { createStatusTracker } = await import("../packages/daemon/src/tui/detect/classify.ts"); const { listTeamSessions } = await import("../packages/daemon/src/tui/team/sessions.ts"); const { buildMenu, menuPositionArgs } = await import("../packages/daemon/src/tui/chrome/menu.ts"); const { getAppConfig } = await import("../packages/daemon/src/lib/app-config.ts"); const { getUpdateStatus } = await import("../packages/daemon/src/lib/update-check.ts"); // listTeamSessions already drops internal `_`-prefixed plumbing. const sessions = listTeamSessions(createStatusTracker()).map((s) => ({ name: s.name, status: s.status, })); // Position flags from a mouse bind's forwarded coords; empty (→ centered) // for the keyboard path or unexpanded #{mouse_*} literals. Must precede // the menu spec (buildMenu opens with -T), so they slot in right after -c. const position = menuPositionArgs( typeof values.x === "string" ? values.x : undefined, typeof values.y === "string" ? values.y : undefined, ); const args = [ "display-menu", "-c", client, ...position, ...buildMenu(sessions, getAppConfig().theme, getUpdateStatus()), ]; execFileSync("tmux", args, { stdio: "ignore", timeout: 2000 }); } catch { // no client / tmux unavailable / a call timed out — nothing to show } break; } case "popup": { // Open a widget as a floating panel. This CLI invocation IS the popup // process (a root-table key or a menu row ran `display-popup -E "tmux-ide // popup "`), so we exec the bun widget SYNCHRONOUSLY into the // popup's PTY; when the widget exits (esc/q) the popup closes. const { POPUP_WIDGETS } = await import("../packages/daemon/src/tui/chrome/panels.ts"); const widget = positionals[1]; if (!widget || !POPUP_WIDGETS.includes(widget)) { throw new IdeError( `Usage: tmux-ide popup \nKnown panels: ${POPUP_WIDGETS.join(", ")}.`, { code: "USAGE", exitCode: 1 }, ); } // Resolve the widget entry from THIS file's dir (bin/), mirroring the // setup/config cases — the bundler rewrites `import.meta.url` to the bin/ // bundle, so a `resolve.ts`-relative path would miss the sources. const scriptPath = resolve(__dirname, "../packages/daemon/src/widgets", widget, "index.tsx"); // The popup opened with `-d '#{pane_current_path}'`, so our cwd IS the // pane's project dir — forward it as `--dir`. Resolve the session so the // widget's tmux side-channels (preview file, "send to claude") target it; // best-effort — an empty session just disables those (the widget still // renders and browses). let popupSession = ""; try { popupSession = execFileSync("tmux", ["display-message", "-p", "#{session_name}"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 2000, }).trim(); } catch { // not inside a tmux client — leave session empty } const popupArgs = [`--dir=${process.cwd()}`]; if (popupSession) popupArgs.push(`--session=${popupSession}`); execBunWidget(widget, scriptPath, popupArgs, `popup ${widget}`); break; } case "sidebar-toggle": { // Toggle the app nav column in a session (bound to `keys.sidebar`, default // M-b, via `run-shell` which expands `--session '#{session_name}'`). If a // sidebar pane already exists → close it; else split a full-height left // column running the sidebar widget. Runs inside tmux key dispatch, so it // stays best-effort — a failure is a silent no-op, never a wedged bind. try { const { findSidebarPane, openSidebarPane, closeSidebarPane, resolveSidebarConfig, DEFAULT_SIDEBAR_WIDTH, } = await import("../packages/daemon/src/tui/chrome/sidebar.ts"); // Resolve the target session: the explicit --session, else the invoking // client's session via display-message. let session = typeof values.session === "string" ? values.session.trim() : ""; if (!session || session.includes("#{")) { try { session = execFileSync("tmux", ["display-message", "-p", "#{session_name}"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 2000, }).trim(); } catch { session = ""; } } if (!session) break; // no session context — nothing to toggle const existing = findSidebarPane(session); if (existing) { closeSidebarPane(existing); break; } // Opening: resolve the session's cwd + best-effort sidebar width/theme // from an ide.yml there (any adopted session may have none → defaults). const { getSessionCwd } = await import("../packages/tmux-bridge/src/index.ts"); let dir = process.cwd(); try { dir = getSessionCwd(session) ?? dir; } catch { // no cwd — fall back to the CLI's cwd } let width = DEFAULT_SIDEBAR_WIDTH; let theme = null; try { const { readConfig } = await import("../packages/daemon/src/lib/yaml-io.ts"); const { config } = readConfig(dir); theme = config.theme ?? null; const sb = resolveSidebarConfig(config.sidebar); if (sb.enabled) width = sb.width; } catch { // no/invalid ide.yml — defaults are fine } openSidebarPane(session, dir, width, theme); } catch { // tmux unavailable / widget missing — silent no-op (fired from a bind) } break; } case "worktree": { const sub = positionals[1]; const KNOWN_SUBS = new Set(["create", "open", "list", "remove"]); if (!sub || !KNOWN_SUBS.has(sub)) { throw new IdeError( "Usage: tmux-ide worktree [flags]\n" + " create [--from ] [--dir ] [--no-session]\n" + " open \n" + " list [--json]\n" + " remove [--force]", { code: "USAGE", exitCode: 1 }, ); } const { worktreeSessionName, worktreePath, listWorktrees, createWorktree, removeWorktree, WorktreeError, } = await import("../packages/daemon/src/lib/worktree.ts"); const { getSessionName } = await import("../packages/daemon/src/lib/yaml-io.ts"); const { getSessionCwd, hasSession, killSession, createDetachedSession } = await import("../packages/tmux-bridge/src/index.ts"); // The repo the command targets: the --session's cwd when invoked from the // menu (run-shell's own cwd is the tmux server's, not the pane's — verified // live), else the CLI's cwd. let repoDir = process.cwd(); const sessionArg = typeof values.session === "string" ? values.session.trim() : ""; if (sessionArg && !sessionArg.includes("#{")) { try { const cwd = getSessionCwd(sessionArg); if (cwd) repoDir = cwd; } catch { // fall back to the CLI cwd } } // The project identity for session names: the MAIN worktree's ide.yml name // (or its dir basename). `git worktree list` returns the main checkout first. const worktrees = listWorktrees(repoDir); const mainPath = worktrees[0]?.path ?? repoDir; const projectName = getSessionName(mainPath).name; // Start a session in a worktree checkout: full IDE layout when it has an // ide.yml (launch under the worktree's own session name so it never // collides with the parent repo's session), else a plain adopted session. // Never auto-attaches — the caller may be inside tmux (the menu) — it prints // how to switch instead. async function openWorktreeSession(wtPath: string, name: string): Promise { if (existsSync(join(wtPath, "ide.yml"))) { await launch(wtPath, { attach: false, sessionName: name }); } else { if (!hasSession(name)) createDetachedSession(name, wtPath); const { adoptSession } = await import("../packages/daemon/src/tui/chrome/statusline.ts"); adoptSession(name); } } function printSwitchHint(name: string, wtPath: string): void { console.log(`Worktree ready: ${wtPath}`); console.log(`Session: ${name}`); if (process.env.TMUX) { console.log(`Switch to it: tmux switch-client -t '${name}'`); } else { console.log(`Attach to it: tmux attach -t '${name}'`); } } if (sub === "create") { const branch = positionals[2]; if (!branch) { throw new IdeError( "Usage: tmux-ide worktree create [--from ] [--dir ] [--no-session]", { code: "USAGE", exitCode: 1 }, ); } const { getAppConfig } = await import("../packages/daemon/src/lib/app-config.ts"); const dirOverride = typeof values.dir === "string" && values.dir.length > 0 ? values.dir : getAppConfig().worktrees.dir || null; const wtPath = worktreePath(repoDir, branch, dirOverride); const from = typeof values.from === "string" ? values.from : null; // Default: create a NEW branch off `from` (HEAD when absent). If the // branch already exists and no explicit base was given, fall back to // checking it out into the worktree instead of failing. try { createWorktree(repoDir, branch, wtPath, { newBranch: true, from }); } catch (err) { if (err instanceof WorktreeError && err.code === "BRANCH_EXISTS" && !from) { createWorktree(repoDir, branch, wtPath, { newBranch: false }); } else { throw err; } } const sessionName = worktreeSessionName(projectName, branch); if (!values["no-session"]) { await openWorktreeSession(wtPath, sessionName); } if (json) { console.log( JSON.stringify({ branch, path: wtPath, session: values["no-session"] ? null : sessionName, }), ); } else if (values["no-session"]) { console.log(`Worktree ready: ${wtPath}`); console.log(`Open a session later: tmux-ide worktree open '${branch}'`); } else { printSwitchHint(sessionName, wtPath); } break; } if (sub === "open") { const branch = positionals[2]; if (!branch) { throw new IdeError("Usage: tmux-ide worktree open ", { code: "USAGE", exitCode: 1, }); } const entry = worktrees.find((w) => w.branch === branch); if (!entry) { throw new IdeError( `No worktree for branch "${branch}". Create one with: tmux-ide worktree create '${branch}'`, { code: "USAGE", exitCode: 1 }, ); } const sessionName = worktreeSessionName(projectName, branch); const already = hasSession(sessionName); if (!already) await openWorktreeSession(entry.path, sessionName); if (json) { console.log( JSON.stringify({ branch, path: entry.path, session: sessionName, created: !already }), ); } else { if (already) console.log(`Session already running.`); printSwitchHint(sessionName, entry.path); } break; } if (sub === "remove") { const branch = positionals[2]; if (!branch) { throw new IdeError("Usage: tmux-ide worktree remove [--force]", { code: "USAGE", exitCode: 1, }); } const entry = worktrees.find((w) => w.branch === branch); if (!entry) { throw new IdeError(`No worktree for branch "${branch}".`, { code: "USAGE", exitCode: 1, }); } // Remove the worktree FIRST so a failed removal (e.g. dirty without // --force, which throws here) never orphan-kills the still-usable // session. Only after a clean removal do we kill ONLY this worktree's // own session (never the parent repo's or a user session — the name is // fully derived from the worktree's branch). removeWorktree(repoDir, entry.path, { force: values.force === true }); const sessionName = worktreeSessionName(projectName, branch); const killed = hasSession(sessionName) ? killSession(sessionName).stopped : false; if (json) { console.log( JSON.stringify({ branch, path: entry.path, sessionKilled: killed, removed: true }), ); } else { console.log(`Removed worktree ${entry.path}${killed ? ` (killed ${sessionName})` : ""}.`); } break; } // sub === "list" const { createStatusTracker } = await import("../packages/daemon/src/tui/detect/classify.ts"); const { listTeamSessions } = await import("../packages/daemon/src/tui/team/sessions.ts"); const sessions = listTeamSessions(createStatusTracker()); const rows = worktrees.map((wt) => { const isPrimary = wt.path === mainPath; const candidates: string[] = []; if (isPrimary) candidates.push(projectName); if (wt.branch) candidates.push(worktreeSessionName(projectName, wt.branch)); const match = sessions.find((s) => candidates.includes(s.name)) ?? null; return { path: wt.path, branch: wt.branch, primary: isPrimary, session: match?.name ?? null, running: match !== null, status: match?.status ?? null, }; }); if (json) { console.log(JSON.stringify({ repo: mainPath, worktrees: rows }, null, 2)); } else if (rows.length === 0) { console.log("No worktrees."); } else { for (const r of rows) { const tag = r.primary ? " (primary)" : ""; const state = r.running ? `${r.status} · ${r.session}` : "no session"; console.log(`${r.branch ?? "(detached)"}${tag} ${state}\n ${r.path}`); } } break; } case "update": { // `--manifests`: fetch the agent-detection manifest pack (versioned JSON, // a GitHub release asset) into ~/.tmux-ide/agent-detection/pack/ — the // loader hot-merges it under bundled console.error(m) }); if (json) { console.log(JSON.stringify({ ok: true, ...r }, null, 2)); } else { console.log( `manifest pack ${r.packVersion} installed (${r.count} manifests): ${r.path}`, ); console.log( "your own agent-detection/*.json overrides still win — the pack merges beneath them", ); } } catch (err) { const message = err instanceof Error ? err.message : String(err); if (json) console.log(JSON.stringify({ ok: false, error: message }, null, 2)); else console.error(`manifest pack NOT installed: ${message}`); process.exitCode = 1; } break; } // `--tui-binary`: download the per-platform TUI binary (the fallback that // lets an npm install with no bun run the full cockpit). Explicit opt-in — // never auto-fetched on install (it's ~70MB). See lib/tui-binary.ts. if (values["tui-binary"] === true) { const { downloadTuiBinary } = await import("../packages/daemon/src/lib/tui-binary.ts"); const { path } = await downloadTuiBinary({ log: (m) => console.error(m) }); if (json) { console.log(JSON.stringify({ ok: true, path }, null, 2)); } else { console.log(`TUI binary ready: ${path}`); } break; } // Detect how tmux-ide was installed and act on the pending update: a dev // checkout prints the `git pull` hint; a global install prints (with // --dry-run) or runs its package manager's update command. `__dirname` is // this CLI's own directory — the anchor for the git-checkout probe + the // package-manager path heuristic (see lib/update.ts). const { runUpdate } = await import("../packages/daemon/src/lib/update.ts"); const dryRun = values["dry-run"] === true; const plan = runUpdate({ cliDir: __dirname, dryRun }); if (!dryRun) { // The managed skill copy has to track the CLI. A global install refreshes // it via the package's own postinstall (which just ran); a dev checkout // has no postinstall, so `tmux-ide update` IS the checkout's refresh path // — sync the skill directly here. const { syncSkill } = await import("../packages/daemon/src/lib/skill-sync.ts"); if (plan.method === "dev") { const result = syncSkill(); console.log(""); console.log(`skill: ${result.action} → ${result.path} (v${result.to})`); } else { console.log(""); console.log("skill: refreshed by the package postinstall (~/.claude/skills/tmux-ide)"); } } break; } case "skill-sync": { // The universal manual refresh of the managed Claude Code skill copy. // Fully-managed dir: overwrite is correct; version-equal is a no-op. const { syncSkill } = await import("../packages/daemon/src/lib/skill-sync.ts"); const result = syncSkill(); if (json) { console.log(JSON.stringify(result, null, 2)); } else { const detail = result.action === "updated" && result.from ? ` (v${result.from} → v${result.to})` : ` (v${result.to})`; console.log(`skill ${result.action}${detail}: ${result.path}`); } break; } case "serve": { // The local control socket (M23.3): NDJSON verbs + pushed agent-status // events over a 0600 Unix socket. Foreground on purpose — the process // the user (or their agent loop) started is the process they own; see // the host tradeoff in control/server.ts. const { startControlServer, defaultControlSocketPath } = await import("../packages/daemon/src/control/server.ts"); const socketPath = typeof socketFlag === "string" ? socketFlag : (positionals[1] ?? defaultControlSocketPath()); const server = await startControlServer({ socketPath, log: (m) => console.error(`[serve] ${m}`), }); let closing = false; const shutdown = () => { if (closing) return; closing = true; // Unlinks the socket and EOFs every client before exiting. void server.close().then(() => process.exit(0)); }; process.on("SIGTERM", shutdown); process.on("SIGINT", shutdown); await new Promise(() => {}); // the server owns the process lifetime break; } case "command-center": { const { startCommandCenter } = await import("../packages/daemon/src/command-center/index.ts"); await startCommandCenter({ port: parseInt(values.port ?? "4000") }); break; } case "server": { if ("bun" in process.versions) { const scriptPath = resolve(__dirname, "../packages/daemon/src/server/standalone.ts"); const serverArgs = ["--experimental-strip-types", scriptPath]; if (values.port) serverArgs.push("--port", values.port); execFileSync("node", serverArgs, { stdio: "inherit" }); } else { const { start } = await import("../packages/daemon/src/server/index.ts"); await start(values.port ? parseInt(values.port, 10) : undefined); } break; } case "help": printHelp(); break; default: throw new IdeError(`Unknown command: ${command}\nRun "tmux-ide help" for usage.`, { code: "USAGE", exitCode: 1, }); } } catch (error) { if (error instanceof IdeError) { printCommandError(error, { json }); } else { throw error; } }