cortex-agents 2.2.0 → 2.3.0

package/dist/utils/terminal.js

@@ -0,0 +1,627 @@
+/**
+ * Terminal Driver System — Strategy pattern for cross-platform terminal tab management.
+ *
+ * Each supported terminal emulator implements the TerminalDriver interface for:
+ *   - detect()  — check if this is the active terminal
+ *   - openTab() — open a new tab and return identifiers
+ *   - closeTab() — close a tab by its identifiers (idempotent, never throws)
+ *
+ * Session data is persisted to `.cortex/.terminal-session` inside each worktree
+ * so tabs can be closed when the worktree is removed.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { exec, shellEscape, spawn, which } from "./shell.js";
+// ─── Session I/O ─────────────────────────────────────────────────────────────
+const SESSION_FILE = ".terminal-session";
+/** Persist terminal session data to the worktree's .cortex directory. */
+export function writeSession(worktreePath, session) {
+    const cortexDir = path.join(worktreePath, ".cortex");
+    if (!fs.existsSync(cortexDir)) {
+        fs.mkdirSync(cortexDir, { recursive: true });
+    }
+    fs.writeFileSync(path.join(cortexDir, SESSION_FILE), JSON.stringify(session, null, 2));
+}
+/** Read terminal session data from the worktree's .cortex directory. */
+export function readSession(worktreePath) {
+    const sessionPath = path.join(worktreePath, ".cortex", SESSION_FILE);
+    if (!fs.existsSync(sessionPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(sessionPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Helper: build the shell command for the new tab ─────────────────────────
+function buildTabCommand(opts) {
+    return `cd "${opts.worktreePath}" && "${opts.opencodeBin}" --agent ${opts.agent}`;
+}
+// ─── Helper: safe process kill ───────────────────────────────────────────────
+function killPid(pid) {
+    try {
+        process.kill(pid, "SIGTERM");
+        return true;
+    }
+    catch {
+        return false; // Process already dead or permission denied
+    }
+}
+// ═════════════════════════════════════════════════════════════════════════════
+// Driver Implementations
+// ═════════════════════════════════════════════════════════════════════════════
+// ─── tmux (multiplexer — highest priority) ───────────────────────────────────
+class TmuxDriver {
+    name = "tmux";
+    detect() {
+        return !!process.env.TMUX;
+    }
+    async openTab(opts) {
+        const cmd = buildTabCommand(opts);
+        try {
+            // -P prints info about the new window, -F formats it
+            const result = await exec("tmux", [
+                "new-window",
+                "-P",
+                "-F",
+                "#{pane_id}",
+                "-c",
+                opts.worktreePath,
+                cmd,
+            ]);
+            const paneId = result.stdout.trim();
+            return { paneId: paneId || undefined };
+        }
+        catch {
+            // Fallback: try without -P (older tmux)
+            try {
+                await exec("tmux", ["new-window", "-c", opts.worktreePath, cmd]);
+                return {};
+            }
+            catch {
+                throw new Error("Failed to open tmux window");
+            }
+        }
+    }
+    async closeTab(session) {
+        if (session.paneId) {
+            try {
+                await exec("tmux", ["kill-pane", "-t", session.paneId], { nothrow: true });
+                return true;
+            }
+            catch {
+                // Pane already closed
+            }
+        }
+        // Fallback: kill PID
+        if (session.pid)
+            return killPid(session.pid);
+        return false;
+    }
+}
+// ─── iTerm2 (macOS) ──────────────────────────────────────────────────────────
+class ITerm2Driver {
+    name = "iterm2";
+    detect() {
+        if (process.platform !== "darwin")
+            return false;
+        if (process.env.ITERM_SESSION_ID)
+            return true;
+        if (process.env.TERM_PROGRAM === "iTerm.app")
+            return true;
+        const bundleId = process.env.__CFBundleIdentifier;
+        if (bundleId?.includes("iterm2") || bundleId?.includes("iTerm"))
+            return true;
+        return false;
+    }
+    async openTab(opts) {
+        const safePath = shellEscape(opts.worktreePath);
+        const safeBin = shellEscape(opts.opencodeBin);
+        const safeAgent = shellEscape(opts.agent);
+        // Create tab, write command, capture session ID
+        const script = `tell application "iTerm2"
+  tell current window
+    create tab with default profile
+    tell current session of current tab
+      write text "cd \\"${safePath}\\" && \\"${safeBin}\\" --agent ${safeAgent}"
+      return id
+    end tell
+  end tell
+end tell`;
+        try {
+            const result = await exec("osascript", ["-e", script]);
+            const sessionId = result.stdout.trim();
+            return { sessionId: sessionId || undefined };
+        }
+        catch {
+            // Fallback: try without capturing ID
+            const fallbackScript = `tell application "iTerm2"
+  tell current window
+    create tab with default profile
+    tell current session of current tab
+      write text "cd \\"${safePath}\\" && \\"${safeBin}\\" --agent ${safeAgent}"
+    end tell
+  end tell
+end tell`;
+            try {
+                await exec("osascript", ["-e", fallbackScript]);
+                return {};
+            }
+            catch {
+                throw new Error("Failed to open iTerm2 tab");
+            }
+        }
+    }
+    async closeTab(session) {
+        if (!session.sessionId) {
+            if (session.pid)
+                return killPid(session.pid);
+            return false;
+        }
+        const script = `tell application "iTerm2"
+  repeat with w in windows
+    repeat with t in tabs of w
+      repeat with s in sessions of t
+        if id of s is "${shellEscape(session.sessionId)}" then
+          close s
+          return "closed"
+        end if
+      end repeat
+    end repeat
+  end repeat
+  return "not_found"
+end tell`;
+        try {
+            const result = await exec("osascript", ["-e", script], { nothrow: true });
+            return result.stdout.trim() === "closed";
+        }
+        catch {
+            return false;
+        }
+    }
+}
+// ─── Terminal.app (macOS) ────────────────────────────────────────────────────
+class TerminalAppDriver {
+    name = "terminal.app";
+    detect() {
+        if (process.platform !== "darwin")
+            return false;
+        if (process.env.TERM_PROGRAM === "Apple_Terminal")
+            return true;
+        const bundleId = process.env.__CFBundleIdentifier;
+        if (bundleId?.includes("Terminal") || bundleId?.includes("apple.Terminal"))
+            return true;
+        return false;
+    }
+    async openTab(opts) {
+        const safePath = shellEscape(opts.worktreePath);
+        const safeBin = shellEscape(opts.opencodeBin);
+        const safeAgent = shellEscape(opts.agent);
+        // do script returns tab reference; we capture the window ID
+        const script = `tell application "Terminal"
+  activate
+  set newTab to do script "cd \\"${safePath}\\" && \\"${safeBin}\\" --agent ${safeAgent}"
+  return id of window of newTab
+end tell`;
+        try {
+            const result = await exec("osascript", ["-e", script]);
+            const windowId = result.stdout.trim();
+            return { windowId: windowId || undefined };
+        }
+        catch {
+            // Fallback: basic open without capturing ID
+            try {
+                await exec("open", ["-a", "Terminal", opts.worktreePath]);
+                return {};
+            }
+            catch {
+                throw new Error("Failed to open Terminal.app");
+            }
+        }
+    }
+    async closeTab(session) {
+        if (!session.windowId) {
+            if (session.pid)
+                return killPid(session.pid);
+            return false;
+        }
+        const script = `tell application "Terminal"
+  try
+    close window id ${session.windowId}
+    return "closed"
+  on error
+    return "not_found"
+  end try
+end tell`;
+        try {
+            const result = await exec("osascript", ["-e", script], { nothrow: true });
+            return result.stdout.trim() === "closed";
+        }
+        catch {
+            return false;
+        }
+    }
+}
+// ─── kitty (Linux/macOS) ─────────────────────────────────────────────────────
+class KittyDriver {
+    name = "kitty";
+    detect() {
+        return !!process.env.KITTY_WINDOW_ID || process.env.TERM_PROGRAM === "kitty";
+    }
+    /**
+     * Check if kitty remote control is available.
+     * Requires `allow_remote_control yes` in kitty.conf.
+     */
+    async hasRemoteControl() {
+        try {
+            await exec("kitty", ["@", "ls"], { timeout: 3000, nothrow: true });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async openTab(opts) {
+        const cmd = buildTabCommand(opts);
+        // Prefer IPC tab creation if remote control is enabled
+        if (await this.hasRemoteControl()) {
+            try {
+                const result = await exec("kitty", [
+                    "@",
+                    "launch",
+                    "--type=tab",
+                    `--cwd=${opts.worktreePath}`,
+                    `--title=Worktree: ${opts.branchName}`,
+                    "bash",
+                    "-c",
+                    cmd,
+                ]);
+                const tabId = result.stdout.trim();
+                return { tabId: tabId || undefined };
+            }
+            catch {
+                // Fall through to new-window approach
+            }
+        }
+        // Fallback: open a new kitty window (captures PID)
+        const child = spawn("kitty", [
+            "--directory",
+            opts.worktreePath,
+            "--title",
+            `Worktree: ${opts.branchName}`,
+            "--",
+            "bash",
+            "-c",
+            cmd,
+        ], { cwd: opts.worktreePath });
+        return { pid: child.pid ?? undefined };
+    }
+    async closeTab(session) {
+        // Try IPC close by tab ID
+        if (session.tabId) {
+            try {
+                await exec("kitty", ["@", "close-tab", `--match=id:${session.tabId}`], { nothrow: true });
+                return true;
+            }
+            catch {
+                // Tab may not exist
+            }
+        }
+        // Try IPC close by PID
+        if (session.pid) {
+            try {
+                await exec("kitty", ["@", "close-window", `--match=pid:${session.pid}`], { nothrow: true });
+                return true;
+            }
+            catch {
+                // Fall through to kill
+            }
+        }
+        // Fallback: kill PID
+        if (session.pid)
+            return killPid(session.pid);
+        return false;
+    }
+}
+// ─── wezterm ─────────────────────────────────────────────────────────────────
+class WeztermDriver {
+    name = "wezterm";
+    detect() {
+        return !!process.env.WEZTERM_PANE || process.env.TERM_PROGRAM === "WezTerm";
+    }
+    async openTab(opts) {
+        const cmd = buildTabCommand(opts);
+        // wezterm cli spawn opens a tab in the current window
+        try {
+            const result = await exec("wezterm", [
+                "cli",
+                "spawn",
+                "--cwd",
+                opts.worktreePath,
+                "--",
+                "bash",
+                "-c",
+                cmd,
+            ]);
+            const paneId = result.stdout.trim();
+            return { paneId: paneId || undefined };
+        }
+        catch {
+            // Fallback: wezterm start opens a new window
+            const child = spawn("wezterm", [
+                "start",
+                "--cwd",
+                opts.worktreePath,
+                "--",
+                "bash",
+                "-c",
+                cmd,
+            ], { cwd: opts.worktreePath });
+            return { pid: child.pid ?? undefined };
+        }
+    }
+    async closeTab(session) {
+        if (session.paneId) {
+            try {
+                await exec("wezterm", ["cli", "kill-pane", "--pane-id", session.paneId], { nothrow: true });
+                return true;
+            }
+            catch {
+                // Pane may not exist
+            }
+        }
+        if (session.pid)
+            return killPid(session.pid);
+        return false;
+    }
+}
+// ─── Konsole (KDE) ───────────────────────────────────────────────────────────
+class KonsoleDriver {
+    name = "konsole";
+    detect() {
+        return !!process.env.KONSOLE_VERSION;
+    }
+    /** Find the qdbus binary (qdbus or qdbus6 on newer KDE). */
+    async findQdbus() {
+        const bin = await which("qdbus");
+        if (bin)
+            return "qdbus";
+        const bin6 = await which("qdbus6");
+        if (bin6)
+            return "qdbus6";
+        return null;
+    }
+    async openTab(opts) {
+        const cmd = buildTabCommand(opts);
+        const qdbus = await this.findQdbus();
+        const service = process.env.KONSOLE_DBUS_SERVICE
+            ? `org.kde.konsole-${process.env.KONSOLE_DBUS_SERVICE}`
+            : "org.kde.konsole";
+        // Try D-Bus new session
+        if (qdbus) {
+            try {
+                const result = await exec(qdbus, [
+                    service,
+                    "/Windows/1",
+                    "newSession",
+                ]);
+                const sessionNum = result.stdout.trim();
+                const dbusPath = `/Sessions/${sessionNum}`;
+                // Set working directory and run command
+                await exec(qdbus, [service, dbusPath, "setProfile", "Default"]);
+                await exec(qdbus, [service, dbusPath, "runCommand", cmd]);
+                return { dbusPath };
+            }
+            catch {
+                // Fall through
+            }
+        }
+        // Fallback: launch konsole with --new-tab
+        try {
+            const child = spawn("konsole", [
+                "--new-tab",
+                "--workdir",
+                opts.worktreePath,
+                "-e",
+                "bash",
+                "-c",
+                cmd,
+            ], { cwd: opts.worktreePath });
+            return { pid: child.pid ?? undefined };
+        }
+        catch {
+            throw new Error("Failed to open Konsole tab");
+        }
+    }
+    async closeTab(session) {
+        if (session.dbusPath) {
+            const qdbus = await this.findQdbus();
+            const service = process.env.KONSOLE_DBUS_SERVICE
+                ? `org.kde.konsole-${process.env.KONSOLE_DBUS_SERVICE}`
+                : "org.kde.konsole";
+            if (qdbus) {
+                try {
+                    await exec(qdbus, [service, session.dbusPath, "close"], { nothrow: true });
+                    return true;
+                }
+                catch {
+                    // Session may not exist
+                }
+            }
+        }
+        if (session.pid)
+            return killPid(session.pid);
+        return false;
+    }
+}
+// ─── GNOME Terminal ──────────────────────────────────────────────────────────
+class GnomeTerminalDriver {
+    name = "gnome-terminal";
+    detect() {
+        return !!process.env.GNOME_TERMINAL_SERVICE;
+    }
+    async openTab(opts) {
+        const cmd = buildTabCommand(opts);
+        // gnome-terminal --tab opens in the current window
+        try {
+            const child = spawn("gnome-terminal", [
+                "--tab",
+                `--working-directory=${opts.worktreePath}`,
+                "--",
+                "bash",
+                "-c",
+                cmd,
+            ], { cwd: opts.worktreePath });
+            return { pid: child.pid ?? undefined };
+        }
+        catch {
+            // Fallback: open a new window
+            const child = spawn("gnome-terminal", [
+                `--working-directory=${opts.worktreePath}`,
+                "--",
+                "bash",
+                "-c",
+                cmd,
+            ], { cwd: opts.worktreePath });
+            return { pid: child.pid ?? undefined };
+        }
+    }
+    async closeTab(session) {
+        // GNOME Terminal has no reliable tab-close API — kill PID
+        if (session.pid)
+            return killPid(session.pid);
+        return false;
+    }
+}
+// ─── Fallback (PID-based, always matches) ────────────────────────────────────
+class FallbackDriver {
+    name = "fallback";
+    detect() {
+        return true; // Always matches — catch-all
+    }
+    async openTab(opts) {
+        const cmd = buildTabCommand(opts);
+        const platform = process.platform;
+        // macOS: try generic open
+        if (platform === "darwin") {
+            try {
+                await exec("open", ["-a", "Terminal", opts.worktreePath]);
+                return {};
+            }
+            catch {
+                // Fall through
+            }
+        }
+        // Linux: try common terminals in order
+        if (platform === "linux") {
+            const terminals = [
+                { name: "xterm", args: ["-e", "bash", "-c", cmd] },
+                { name: "x-terminal-emulator", args: ["-e", "bash", "-c", cmd] },
+            ];
+            for (const t of terminals) {
+                try {
+                    const child = spawn(t.name, t.args, { cwd: opts.worktreePath });
+                    return { pid: child.pid ?? undefined };
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        // Windows: try Windows Terminal, then cmd
+        if (platform === "win32") {
+            // Try Windows Terminal first
+            const wt = await which("wt.exe");
+            if (wt) {
+                try {
+                    const child = spawn("wt.exe", [
+                        "new-tab",
+                        "--startingDirectory",
+                        opts.worktreePath,
+                        "cmd",
+                        "/k",
+                        cmd,
+                    ], { cwd: opts.worktreePath });
+                    return { pid: child.pid ?? undefined };
+                }
+                catch {
+                    // Fall through to cmd
+                }
+            }
+            try {
+                await exec("cmd", ["/k", cmd], { cwd: opts.worktreePath });
+                return {};
+            }
+            catch {
+                // Nothing worked
+            }
+        }
+        throw new Error(`Could not open terminal on ${platform}`);
+    }
+    async closeTab(session) {
+        if (session.pid)
+            return killPid(session.pid);
+        return false;
+    }
+}
+// ═════════════════════════════════════════════════════════════════════════════
+// Detection Registry
+// ═════════════════════════════════════════════════════════════════════════════
+/**
+ * Ordered list of terminal drivers. Detection runs first-to-last.
+ *
+ * Priority: multiplexers first (tmux), then terminal emulators, then fallback.
+ * This ensures that if the user is in tmux inside iTerm2, we open a tmux window.
+ */
+const DRIVERS = [
+    new TmuxDriver(),
+    new ITerm2Driver(),
+    new TerminalAppDriver(),
+    new KittyDriver(),
+    new WeztermDriver(),
+    new KonsoleDriver(),
+    new GnomeTerminalDriver(),
+    new FallbackDriver(),
+];
+/** Map of driver name → driver instance for reverse lookup. */
+const DRIVER_MAP = new Map(DRIVERS.map((d) => [d.name, d]));
+/**
+ * Detect the active terminal emulator and return the matching driver.
+ * Falls back to FallbackDriver if no specific terminal is detected.
+ */
+export function detectDriver() {
+    for (const driver of DRIVERS) {
+        if (driver.detect())
+            return driver;
+    }
+    // Should never reach here (FallbackDriver always matches)
+    return new FallbackDriver();
+}
+/**
+ * Get a driver by name (used when closing a tab from a persisted session).
+ * Returns null if the driver name is unknown.
+ */
+export function getDriverByName(name) {
+    return DRIVER_MAP.get(name) ?? null;
+}
+/**
+ * Close a terminal session using the appropriate driver.
+ * Handles all modes (terminal, pty, background) with PID fallback.
+ *
+ * This is the main entry point for worktree_remove cleanup.
+ */
+export async function closeSession(session) {
+    if (session.mode === "terminal") {
+        const driver = getDriverByName(session.terminal);
+        if (driver) {
+            const closed = await driver.closeTab(session);
+            if (closed)
+                return true;
+        }
+    }
+    // Universal fallback: kill PID
+    if (session.pid)
+        return killPid(session.pid);
+    return false;
+}

package/dist/utils/worktree-detect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worktree-detect.d.ts","sourceRoot":"","sources":["../../src/utils/worktree-detect.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,qFAAqF;IACrF,UAAU,EAAE,OAAO,CAAC;IACpB,8BAA8B;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAqC3E"}
+{"version":3,"file":"worktree-detect.d.ts","sourceRoot":"","sources":["../../src/utils/worktree-detect.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,qFAAqF;IACrF,UAAU,EAAE,OAAO,CAAC;IACpB,8BAA8B;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAqC3E"}

package/dist/utils/worktree-detect.js

@@ -1,4 +1,5 @@
 import * as path from "path";
+import { git } from "./shell.js";
 /**
  * Detect whether the current git directory is a linked worktree.
  *
@@ -14,16 +15,16 @@ export async function detectWorktreeInfo(cwd) {
     };
     // Get current branch
     try {
-        const branch = await Bun.$ `git -C ${cwd} branch --show-current`.quiet().text();
-        result.currentBranch = branch.trim();
+        const { stdout } = await git(cwd, "branch", "--show-current");
+        result.currentBranch = stdout.trim();
     }
     catch {
         result.currentBranch = "(unknown)";
     }
     // Compare git-dir and git-common-dir
     try {
-        const gitDirRaw = await Bun.$ `git -C ${cwd} rev-parse --git-dir`.quiet().text();
-        const commonDirRaw = await Bun.$ `git -C ${cwd} rev-parse --git-common-dir`.quiet().text();
+        const { stdout: gitDirRaw } = await git(cwd, "rev-parse", "--git-dir");
+        const { stdout: commonDirRaw } = await git(cwd, "rev-parse", "--git-common-dir");
         // Resolve both to absolute paths for reliable comparison
         const absGitDir = path.resolve(cwd, gitDirRaw.trim());
         const absCommonDir = path.resolve(cwd, commonDirRaw.trim());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortex-agents",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Supercharge OpenCode with structured workflows, intelligent agents, and automated development practices",
   "type": "module",
   "main": "dist/index.js",
@@ -14,6 +14,8 @@
   ],
   "scripts": {
     "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepare": "npm run build",
     "postinstall": "echo 'Run: npx cortex-agents install && npx cortex-agents configure'"
   },
@@ -53,11 +55,10 @@
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.0.0",
-    "@types/bun": "^1.3.9",
     "@types/node": "^20.0.0",
     "@types/prompts": "^2.4.9",
-    "bun-types": "^1.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
   },
   "dependencies": {
     "prompts": "^2.4.2"