@towry/mcp 0.1.7 → 0.3.0

package/dist/tmux.js

@@ -1,797 +0,0 @@
-/**
- * Tmux CLI Controller - TypeScript port
- *
- * Provides tmux pane management without external Python dependency.
- * Auto-detects whether running inside tmux or not.
- *
- * Keywords: tmux, pane-management, terminal-multiplexer
- */
-import { spawn } from "node:child_process";
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-// Unit Separator - safe delimiter for tmux format strings (pane_title etc. may contain |)
-const TMUX_SEP = "\x1f";
-// ============================================================================
-// Helpers
-// ============================================================================
-/**
- * Get the full command line of a pane's foreground process via its PID.
- * Looks up the first child process of the shell, falls back to the given default.
- */
-async function getFullCommand(panePid, fallback) {
-    if (!panePid)
-        return fallback;
-    try {
-        const proc = spawn("pgrep", ["-P", panePid], {
-            stdio: ["ignore", "pipe", "pipe"],
-            shell: false,
-        });
-        let stdout = "";
-        proc.stdout.on("data", (d) => (stdout += d.toString()));
-        await new Promise((resolve) => proc.on("close", () => resolve()));
-        const childPid = stdout.trim().split("\n")[0];
-        if (!childPid)
-            return fallback;
-        const ps = spawn("ps", ["-o", "command=", "-p", childPid], {
-            stdio: ["ignore", "pipe", "pipe"],
-            shell: false,
-        });
-        let cmd = "";
-        ps.stdout.on("data", (d) => (cmd += d.toString()));
-        await new Promise((resolve) => ps.on("close", () => resolve()));
-        const trimmed = cmd.trim();
-        if (!trimmed)
-            return fallback;
-        // Strip nix store prefix for readability: /nix/store/...-name/bin/foo -> foo
-        return trimmed.replace(/\/nix\/store\/[^/]+-[^/]+\/bin\//g, "");
-    }
-    catch {
-        return fallback;
-    }
-}
-// ============================================================================
-// Tmux Command Runner
-// ============================================================================
-async function runTmux(args) {
-    return new Promise((resolve) => {
-        const proc = spawn("tmux", args, {
-            stdio: ["ignore", "pipe", "pipe"],
-            shell: false,
-        });
-        let stdout = "";
-        proc.stdout.on("data", (d) => (stdout += d.toString()));
-        proc.on("close", (code) => resolve({ stdout: stdout.trim(), exitCode: code ?? 0 }));
-        proc.on("error", () => resolve({ stdout: "", exitCode: 1 }));
-    });
-}
-/**
- * Validate that a path is absolute and exists.
- * Returns { valid: true } or { valid: false, error: string }
- */
-function validateCwd(cwd) {
-    if (!cwd)
-        return { valid: true };
-    if (!path.isAbsolute(cwd)) {
-        return { valid: false, error: `cwd must be an absolute path, got: ${cwd}` };
-    }
-    try {
-        const stat = fs.statSync(cwd);
-        if (!stat.isDirectory()) {
-            return { valid: false, error: `cwd is not a directory: ${cwd}` };
-        }
-        return { valid: true };
-    }
-    catch {
-        return { valid: false, error: `cwd does not exist: ${cwd}` };
-    }
-}
-// ============================================================================
-// TmuxCLIController - For use inside tmux
-// ============================================================================
-export class TmuxCLIController {
-    targetPane = null;
-    async getCurrentSession() {
-        const { stdout, exitCode } = await runTmux(["display-message", "-p", "#{session_name}"]);
-        return exitCode === 0 ? stdout : null;
-    }
-    async getCurrentWindow() {
-        const { stdout, exitCode } = await runTmux(["display-message", "-p", "#{window_name}"]);
-        return exitCode === 0 ? stdout : null;
-    }
-    async getCurrentPane() {
-        const { stdout, exitCode } = await runTmux(["display-message", "-p", "#{pane_id}"]);
-        return exitCode === 0 ? stdout : null;
-    }
-    async getCurrentPaneIndex() {
-        const { stdout, exitCode } = await runTmux(["display-message", "-p", "#{pane_index}"]);
-        return exitCode === 0 ? stdout : null;
-    }
-    async formatPaneIdentifier(paneId) {
-        if (!paneId)
-            return paneId;
-        try {
-            const [session, window, pane] = await Promise.all([
-                runTmux(["display-message", "-t", paneId, "-p", "#{session_name}"]),
-                runTmux(["display-message", "-t", paneId, "-p", "#{window_index}"]),
-                runTmux(["display-message", "-t", paneId, "-p", "#{pane_index}"]),
-            ]);
-            if (session.exitCode === 0 &&
-                window.exitCode === 0 &&
-                pane.exitCode === 0 &&
-                session.stdout &&
-                window.stdout &&
-                pane.stdout) {
-                return `${session.stdout}:${window.stdout}.${pane.stdout}`;
-            }
-            return paneId;
-        }
-        catch {
-            return paneId;
-        }
-    }
-    async resolvePaneIdentifier(identifier) {
-        if (!identifier)
-            return null;
-        identifier = String(identifier);
-        // Already a pane ID
-        if (identifier.startsWith("%"))
-            return identifier;
-        // Numeric index
-        if (/^\d+$/.test(identifier)) {
-            const panes = await this.listPanes();
-            const pane = panes.find((p) => p.index === identifier);
-            return pane?.id ?? null;
-        }
-        // session:window.pane format
-        if (identifier.includes(":") && identifier.includes(".")) {
-            try {
-                const { stdout, exitCode } = await runTmux([
-                    "display-message",
-                    "-t",
-                    identifier,
-                    "-p",
-                    "#{pane_id}",
-                ]);
-                return exitCode === 0 ? stdout : null;
-            }
-            catch {
-                return null;
-            }
-        }
-        return null;
-    }
-    async getCurrentWindowId() {
-        const currentPane = process.env.TMUX_PANE;
-        if (currentPane) {
-            const { stdout, exitCode } = await runTmux([
-                "display-message",
-                "-t",
-                currentPane,
-                "-p",
-                "#{window_id}",
-            ]);
-            return exitCode === 0 ? stdout : null;
-        }
-        const { stdout, exitCode } = await runTmux(["display-message", "-p", "#{window_id}"]);
-        return exitCode === 0 ? stdout : null;
-    }
-    async listPanes(session) {
-        // Use Unit Separator (\x1f) as delimiter to avoid conflicts with pane_title content
-        // Default to current session if no session specified
-        const targetSession = session || (await this.getCurrentSession());
-        if (!targetSession)
-            return [];
-        const format = `#{pane_id}${TMUX_SEP}#{pane_index}${TMUX_SEP}#{pane_title}${TMUX_SEP}#{pane_active}${TMUX_SEP}#{pane_width}x#{pane_height}${TMUX_SEP}#{pane_current_command}${TMUX_SEP}#{window_index}${TMUX_SEP}#{window_name}${TMUX_SEP}#{pane_pid}${TMUX_SEP}#{pane_current_path}`;
-        const { stdout, exitCode } = await runTmux([
-            "list-panes",
-            "-s",
-            "-t",
-            targetSession,
-            "-F",
-            format,
-        ]);
-        if (exitCode !== 0)
-            return [];
-        const panes = [];
-        for (const line of stdout.split("\n")) {
-            if (!line)
-                continue;
-            const parts = line.split(TMUX_SEP);
-            const paneId = parts[0];
-            const shortCmd = parts[5] || "";
-            const panePid = parts[8] || "";
-            const cwd = parts[9] || "";
-            panes.push({
-                id: paneId,
-                index: parts[1],
-                title: parts[2],
-                active: parts[3] === "1",
-                size: parts[4],
-                command: await getFullCommand(panePid, shortCmd),
-                formatted_id: await this.formatPaneIdentifier(paneId),
-                cwd,
-                window_index: parts[6],
-                window_name: parts[7],
-            });
-        }
-        return panes;
-    }
-    async listSessions() {
-        const { stdout, exitCode } = await runTmux([
-            "list-sessions",
-            "-F",
-            `#{session_name}${TMUX_SEP}#{session_id}${TMUX_SEP}#{session_windows}${TMUX_SEP}#{session_attached}${TMUX_SEP}#{session_created}`,
-        ]);
-        if (exitCode !== 0)
-            return [];
-        const current = await this.getCurrentSession();
-        const sessions = [];
-        for (const line of stdout.split("\n")) {
-            if (!line)
-                continue;
-            const parts = line.split(TMUX_SEP);
-            sessions.push({
-                name: parts[0],
-                id: parts[1],
-                windows: parts[2],
-                attached: parts[3] === "1",
-                created: parts[4],
-                current: parts[0] === current,
-            });
-        }
-        return sessions;
-    }
-    async createSession(name, command, cwd) {
-        const cmd = ["new-session", "-s", name, "-d", "-P", "-F", "#{session_name}"];
-        if (cwd)
-            cmd.push("-c", cwd);
-        if (command)
-            cmd.push(command);
-        const { stdout, exitCode } = await runTmux(cmd);
-        return exitCode === 0 ? stdout : null;
-    }
-    async killSession(name) {
-        const current = await this.getCurrentSession();
-        if (current && name === current) {
-            throw new Error(`Cannot kill current session '${name}'`);
-        }
-        const { exitCode } = await runTmux(["kill-session", "-t", name]);
-        return exitCode === 0;
-    }
-    async createWindow(options = {}) {
-        const { name, command, session, cwd, detached = true } = options;
-        const targetSession = session || (await this.getCurrentSession());
-        const cmd = ["new-window", "-P", "-F", "#{pane_id}"];
-        if (detached)
-            cmd.push("-d");
-        if (targetSession)
-            cmd.push("-t", targetSession);
-        if (cwd)
-            cmd.push("-c", cwd);
-        if (name)
-            cmd.push("-n", name);
-        if (command)
-            cmd.push(command);
-        const { stdout, exitCode } = await runTmux(cmd);
-        return exitCode === 0 && stdout ? stdout : null;
-    }
-    async createPane(vertical = true, size, startCommand) {
-        const currentWindowId = await this.getCurrentWindowId();
-        const baseCmd = ["split-window"];
-        if (currentWindowId)
-            baseCmd.push("-t", currentWindowId);
-        baseCmd.push(vertical ? "-h" : "-v");
-        const sizeFlags = size ? [["-l", `${size}%`], ["-p", String(size)]] : [[]];
-        for (const sizeFlag of sizeFlags) {
-            const cmd = [...baseCmd];
-            if (sizeFlag.length)
-                cmd.push(...sizeFlag);
-            cmd.push("-P", "-F", "#{pane_id}");
-            if (startCommand)
-                cmd.push(startCommand);
-            const { stdout, exitCode } = await runTmux(cmd);
-            if (exitCode === 0 && stdout && stdout.startsWith("%")) {
-                this.targetPane = stdout;
-                return stdout;
-            }
-        }
-        return null;
-    }
-    selectPane(paneId, paneIndex) {
-        if (paneId) {
-            this.targetPane = paneId;
-        }
-        else if (paneIndex !== undefined) {
-            // Will be resolved later
-            this.targetPane = String(paneIndex);
-        }
-    }
-    async sendKeys(text, paneId, enter = true, delayEnter = true) {
-        const target = paneId || this.targetPane;
-        if (!target)
-            throw new Error("No target pane specified");
-        if (enter && delayEnter) {
-            await runTmux(["send-keys", "-l", "-t", target, text]);
-            const delay = typeof delayEnter === "number" ? delayEnter : 0.1;
-            await new Promise((r) => setTimeout(r, delay * 1000));
-            await runTmux(["send-keys", "-t", target, "Enter"]);
-        }
-        else {
-            const cmd = ["send-keys", "-l", "-t", target, text];
-            if (enter)
-                cmd.push("Enter");
-            await runTmux(cmd);
-        }
-    }
-    async capturePane(paneId, lines) {
-        const target = paneId || this.targetPane;
-        if (!target)
-            throw new Error("No target pane specified");
-        const cmd = ["capture-pane", "-t", target, "-p"];
-        if (lines)
-            cmd.push("-S", `-${lines}`);
-        const { stdout } = await runTmux(cmd);
-        return stdout;
-    }
-    async waitForIdle(paneId, idleTime = 2.0, checkInterval = 0.5, timeout) {
-        const target = paneId || this.targetPane;
-        if (!target)
-            throw new Error("No target pane specified");
-        const startTime = Date.now();
-        let lastChangeTime = Date.now();
-        let lastHash = "";
-        while (true) {
-            if (timeout && Date.now() - startTime > timeout * 1000)
-                return false;
-            const content = await this.capturePane(target);
-            const contentHash = crypto.createHash("md5").update(content).digest("hex");
-            if (contentHash !== lastHash) {
-                lastHash = contentHash;
-                lastChangeTime = Date.now();
-            }
-            else if (Date.now() - lastChangeTime >= idleTime * 1000) {
-                return true;
-            }
-            await new Promise((r) => setTimeout(r, checkInterval * 1000));
-        }
-    }
-    async killPane(paneId) {
-        const target = paneId || this.targetPane;
-        if (!target)
-            throw new Error("No target pane specified");
-        if (paneId) {
-            const currentPane = await this.getCurrentPane();
-            if (currentPane && target === currentPane) {
-                throw new Error("Cannot kill own pane!");
-            }
-        }
-        await runTmux(["kill-pane", "-t", target]);
-        if (target === this.targetPane) {
-            this.targetPane = null;
-        }
-    }
-    async sendInterrupt(paneId) {
-        const target = paneId || this.targetPane;
-        if (!target)
-            throw new Error("No target pane specified");
-        await runTmux(["send-keys", "-t", target, "C-c"]);
-    }
-    async sendEscape(paneId) {
-        const target = paneId || this.targetPane;
-        if (!target)
-            throw new Error("No target pane specified");
-        await runTmux(["send-keys", "-t", target, "Escape"]);
-    }
-    async launchCli(command, vertical = true, size = 50) {
-        const paneId = await this.createPane(vertical, size, command);
-        if (paneId) {
-            const formattedId = await this.formatPaneIdentifier(paneId);
-            return { paneId, formattedId };
-        }
-        return null;
-    }
-}
-// ============================================================================
-// RemoteTmuxController - For use outside tmux
-// ============================================================================
-export class RemoteTmuxController {
-    sessionName;
-    targetWindow = null;
-    constructor(sessionName = "remote-cli-session") {
-        this.sessionName = sessionName;
-    }
-    async ensureSession() {
-        const { exitCode } = await runTmux(["has-session", "-t", this.sessionName]);
-        if (exitCode !== 0) {
-            await runTmux([
-                "new-session",
-                "-d",
-                "-s",
-                this.sessionName,
-                "-P",
-                "-F",
-                "#{session_name}",
-            ]);
-            this.targetWindow = `${this.sessionName}:0`;
-        }
-        else if (!this.targetWindow) {
-            const { stdout, exitCode: code2 } = await runTmux([
-                "display-message",
-                "-p",
-                "-t",
-                this.sessionName,
-                "#{session_name}:#{window_index}",
-            ]);
-            if (code2 === 0 && stdout) {
-                this.targetWindow = stdout;
-            }
-        }
-    }
-    async windowTarget(pane) {
-        await this.ensureSession();
-        if (!pane) {
-            if (this.targetWindow)
-                return this.targetWindow;
-            const { stdout, exitCode } = await runTmux([
-                "display-message",
-                "-p",
-                "-t",
-                this.sessionName,
-                "#{session_name}:#{window_index}",
-            ]);
-            if (exitCode === 0 && stdout) {
-                this.targetWindow = stdout;
-                return stdout;
-            }
-            return `${this.sessionName}:0`;
-        }
-        if (/^\d+$/.test(pane)) {
-            return `${this.sessionName}:${pane}`;
-        }
-        return pane;
-    }
-    async listPanes() {
-        await this.ensureSession();
-        const { stdout, exitCode } = await runTmux([
-            "list-windows",
-            "-t",
-            this.sessionName,
-            "-F",
-            `#{window_index}${TMUX_SEP}#{window_name}${TMUX_SEP}#{window_active}${TMUX_SEP}#{window_width}x#{window_height}`,
-        ]);
-        if (exitCode !== 0 || !stdout)
-            return [];
-        const windows = [];
-        for (const line of stdout.split("\n")) {
-            if (!line)
-                continue;
-            const [idx, name, active, size] = line.split(TMUX_SEP);
-            windows.push({
-                id: `${this.sessionName}:${idx}`,
-                index: idx,
-                title: name,
-                active: active === "1",
-                size,
-                command: "",
-                formatted_id: `${this.sessionName}:${idx}`,
-            });
-        }
-        return windows;
-    }
-    async launchCli(command, name) {
-        await this.ensureSession();
-        const args = [
-            "new-window",
-            "-t",
-            this.sessionName,
-            "-P",
-            "-F",
-            "#{session_name}:#{window_index}",
-        ];
-        if (name)
-            args.push("-n", name);
-        if (command)
-            args.push(command);
-        const { stdout, exitCode } = await runTmux(args);
-        if (exitCode === 0 && stdout) {
-            this.targetWindow = stdout;
-            return stdout;
-        }
-        return null;
-    }
-    async sendKeys(text, paneId, enter = true, delayEnter = true) {
-        if (!text)
-            return;
-        const target = await this.windowTarget(paneId);
-        if (enter && delayEnter) {
-            await runTmux(["send-keys", "-l", "-t", target, text]);
-            const delay = typeof delayEnter === "number" ? delayEnter : 0.1;
-            await new Promise((r) => setTimeout(r, delay * 1000));
-            await runTmux(["send-keys", "-t", target, "Enter"]);
-        }
-        else {
-            const args = ["send-keys", "-l", "-t", target, text];
-            if (enter)
-                args.push("Enter");
-            await runTmux(args);
-        }
-    }
-    async capturePane(paneId, lines) {
-        const target = await this.windowTarget(paneId);
-        const args = ["capture-pane", "-t", target, "-p"];
-        if (lines)
-            args.push("-S", `-${lines}`);
-        const { stdout } = await runTmux(args);
-        return stdout;
-    }
-    async waitForIdle(paneId, idleTime = 2.0, checkInterval = 0.5, timeout) {
-        const target = await this.windowTarget(paneId);
-        const startTime = Date.now();
-        let lastChange = Date.now();
-        let lastHash = "";
-        while (true) {
-            if (timeout && Date.now() - startTime > timeout * 1000)
-                return false;
-            const { stdout } = await runTmux(["capture-pane", "-t", target, "-p"]);
-            const h = crypto.createHash("md5").update(stdout).digest("hex");
-            if (h !== lastHash) {
-                lastHash = h;
-                lastChange = Date.now();
-            }
-            else if (Date.now() - lastChange >= idleTime * 1000) {
-                return true;
-            }
-            await new Promise((r) => setTimeout(r, checkInterval * 1000));
-        }
-    }
-    async sendInterrupt(paneId) {
-        const target = await this.windowTarget(paneId);
-        await runTmux(["send-keys", "-t", target, "C-c"]);
-    }
-    async sendEscape(paneId) {
-        const target = await this.windowTarget(paneId);
-        await runTmux(["send-keys", "-t", target, "Escape"]);
-    }
-    async killWindow(windowId) {
-        const target = await this.windowTarget(windowId);
-        await runTmux(["kill-window", "-t", target]);
-        if (this.targetWindow === target) {
-            this.targetWindow = null;
-        }
-    }
-    async attachSession() {
-        await this.ensureSession();
-        spawn("tmux", ["attach-session", "-t", this.sessionName], {
-            stdio: "inherit",
-        });
-    }
-    async cleanupSession() {
-        await runTmux(["kill-session", "-t", this.sessionName]);
-        this.targetWindow = null;
-    }
-}
-// ============================================================================
-// Unified CLI Interface
-// ============================================================================
-export class TmuxCLI {
-    controller;
-    mode;
-    inTmux;
-    constructor(session) {
-        this.inTmux = Boolean(process.env.TMUX);
-        if (this.inTmux) {
-            this.controller = new TmuxCLIController();
-            this.mode = "local";
-        }
-        else {
-            this.controller = new RemoteTmuxController(session || "remote-cli-session");
-            this.mode = "remote";
-        }
-    }
-    async listTmuxPanes(session) {
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            return ctrl.listPanes(session);
-        }
-        else {
-            const ctrl = this.controller;
-            // Remote mode doesn't support session filter, just list windows
-            return ctrl.listPanes();
-        }
-    }
-    async listTmuxSessions() {
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            return ctrl.listSessions();
-        }
-        else {
-            // Remote mode: just return the managed session info
-            const ctrl = this.controller;
-            await ctrl.ensureSession();
-            return [
-                {
-                    name: ctrl.sessionName,
-                    id: "$0",
-                    windows: "1",
-                    attached: true,
-                    created: "",
-                    current: true,
-                },
-            ];
-        }
-    }
-    async createTmuxSession(name, command, cwd) {
-        const validation = validateCwd(cwd);
-        if (!validation.valid) {
-            throw new Error(validation.error);
-        }
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            return ctrl.createSession(name, command, cwd);
-        }
-        else {
-            // Remote mode already manages its own session
-            throw new Error("create_session not available in remote mode");
-        }
-    }
-    async killTmuxSession(name) {
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            return ctrl.killSession(name);
-        }
-        else {
-            throw new Error("kill_session not available in remote mode");
-        }
-    }
-    async createTmuxWindow(options = {}) {
-        const validation = validateCwd(options.cwd);
-        if (!validation.valid) {
-            throw new Error(validation.error);
-        }
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            return ctrl.createWindow(options);
-        }
-        else {
-            const ctrl = this.controller;
-            return ctrl.launchCli(options.command || "", options.name);
-        }
-    }
-    async launchTmuxPane(command, options = {}) {
-        const { vertical = true, size = 50, name } = options;
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            const result = await ctrl.launchCli(command, vertical, size);
-            return result?.paneId ?? null;
-        }
-        else {
-            const ctrl = this.controller;
-            return ctrl.launchCli(command, name);
-        }
-    }
-    async sendTmuxKeys(text, options = {}) {
-        const { pane, enter = true, delayEnter = true } = options;
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            if (pane) {
-                const resolved = await ctrl.resolvePaneIdentifier(pane);
-                if (!resolved)
-                    throw new Error(`Could not resolve pane identifier: ${pane}`);
-                ctrl.selectPane(resolved);
-            }
-            await ctrl.sendKeys(text, undefined, enter, delayEnter);
-        }
-        else {
-            const ctrl = this.controller;
-            await ctrl.sendKeys(text, pane, enter, delayEnter);
-        }
-    }
-    async captureTmuxPane(options = {}) {
-        const { pane, lines } = options;
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            if (pane) {
-                const resolved = await ctrl.resolvePaneIdentifier(pane);
-                if (!resolved)
-                    throw new Error(`Could not resolve pane identifier: ${pane}`);
-                ctrl.selectPane(resolved);
-            }
-            return ctrl.capturePane(undefined, lines);
-        }
-        else {
-            const ctrl = this.controller;
-            return ctrl.capturePane(pane, lines);
-        }
-    }
-    async interruptTmuxPane(pane) {
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            if (pane) {
-                const resolved = await ctrl.resolvePaneIdentifier(pane);
-                if (!resolved)
-                    throw new Error(`Could not resolve pane identifier: ${pane}`);
-                ctrl.selectPane(resolved);
-            }
-            await ctrl.sendInterrupt();
-        }
-        else {
-            const ctrl = this.controller;
-            await ctrl.sendInterrupt(pane);
-        }
-    }
-    async escapeTmuxPane(pane) {
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            if (pane) {
-                const resolved = await ctrl.resolvePaneIdentifier(pane);
-                if (!resolved)
-                    throw new Error(`Could not resolve pane identifier: ${pane}`);
-                ctrl.selectPane(resolved);
-            }
-            await ctrl.sendEscape();
-        }
-        else {
-            const ctrl = this.controller;
-            await ctrl.sendEscape(pane);
-        }
-    }
-    async killTmuxPane(pane) {
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            if (pane) {
-                const resolved = await ctrl.resolvePaneIdentifier(pane);
-                if (!resolved)
-                    throw new Error(`Could not resolve pane identifier: ${pane}`);
-                ctrl.selectPane(resolved);
-            }
-            await ctrl.killPane();
-        }
-        else {
-            const ctrl = this.controller;
-            await ctrl.killWindow(pane);
-        }
-    }
-    async waitTmuxPaneIdle(options = {}) {
-        const { pane, idleTime = 2.0, timeout } = options;
-        if (this.mode === "local") {
-            const ctrl = this.controller;
-            if (pane) {
-                const resolved = await ctrl.resolvePaneIdentifier(pane);
-                if (!resolved)
-                    throw new Error(`Could not resolve pane identifier: ${pane}`);
-                ctrl.selectPane(resolved);
-            }
-            return ctrl.waitForIdle(undefined, idleTime, 0.5, timeout);
-        }
-        else {
-            const ctrl = this.controller;
-            return ctrl.waitForIdle(pane, idleTime, 0.5, timeout);
-        }
-    }
-}
-// ============================================================================
-// Helper Functions (for MCP tools)
-// ============================================================================
-export async function getCurrentPaneInfo() {
-    const paneId = process.env.TMUX_PANE;
-    if (!paneId)
-        return { id: "", title: "" };
-    const { stdout } = await runTmux(["display-message", "-p", "-t", paneId, "#{pane_title}"]);
-    return { id: paneId, title: stdout };
-}
-export function shellQuote(s) {
-    return `'${s.replace(/'/g, `"'"'"'`)}'`;
-}
-export function parseLaunchPaneIds(stdout) {
-    const newFormatMatch = stdout.match(/in pane\s+(%\d+)\s+\(([^)]+)\)/);
-    if (newFormatMatch) {
-        return { paneId: newFormatMatch[1], paneFormattedId: newFormatMatch[2] };
-    }
-    const rawIdMatch = stdout.match(/in pane\s+(%\d+)/);
-    const paneId = rawIdMatch?.[1];
-    const formattedPaneMatch = stdout.match(/in pane\s+([^\s]+)$/);
-    const paneFormattedId = formattedPaneMatch?.[1];
-    return { paneId, paneFormattedId };
-}
-//# sourceMappingURL=tmux.js.map