tmux-agent 0.1.0

package/dist/lib/fs/safeRm.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeRemove = safeRemove;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function resolvePath(input) {
+    return node_path_1.default.resolve(input);
+}
+async function safeRemove(targetPath, allowedRoot) {
+    const resolvedTarget = resolvePath(targetPath);
+    const resolvedRoot = resolvePath(allowedRoot);
+    const relative = node_path_1.default.relative(resolvedRoot, resolvedTarget);
+    if (!relative || relative === "" || relative === ".") {
+        throw new Error("refuse to remove allowed root");
+    }
+    if (relative.startsWith("..") || node_path_1.default.isAbsolute(relative)) {
+        throw new Error("path is outside allowed_root");
+    }
+    try {
+        await node_fs_1.promises.rm(resolvedTarget, { recursive: true, force: true });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/lib/io/readStdin.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStdin = readStdin;
+async function readStdin() {
+    return await new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", (error) => reject(error));
+    });
+}

package/dist/lib/os/process.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProcesses = listProcesses;
+const node_child_process_1 = require("node:child_process");
+function parseProcessLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const match = trimmed.match(/^(\d+)\s+(\d+)\s+(.*)$/);
+    if (!match) {
+        return null;
+    }
+    const pid = Number(match[1]);
+    const ppid = Number(match[2]);
+    if (!Number.isFinite(pid) || !Number.isFinite(ppid)) {
+        return null;
+    }
+    return { pid, ppid, command: match[3] };
+}
+async function listProcesses() {
+    return await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)("ps", ["-ax", "-o", "pid=,ppid=,command="]);
+        let stdout = "";
+        let stderr = "";
+        if (child.stdout) {
+            child.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+        }
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("close", (code) => {
+            const exitCode = code ?? 0;
+            if (exitCode !== 0) {
+                reject(new Error(stderr.trim() || stdout.trim() || `ps exited with ${exitCode}`));
+                return;
+            }
+            const processes = [];
+            for (const line of stdout.split(/\r?\n/)) {
+                const parsed = parseProcessLine(line);
+                if (parsed) {
+                    processes.push(parsed);
+                }
+            }
+            resolve(processes);
+        });
+    });
+}

package/dist/lib/output/format.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatWindowStatus = formatWindowStatus;
+exports.formatPaneStatus = formatPaneStatus;
+exports.formatCommandTitle = formatCommandTitle;
+exports.formatWindowTable = formatWindowTable;
+exports.formatPaneTable = formatPaneTable;
+exports.formatJson = formatJson;
+exports.ensureErrorPrefix = ensureErrorPrefix;
+const TITLE_SEPARATOR = " \u00b7 ";
+function buildTable(columns) {
+    const widths = columns.map((col) => Math.max(col.header.length, ...col.values.map((value) => value.length)));
+    const header = columns
+        .map((col, index) => col.header.padEnd(widths[index]))
+        .join("  ");
+    const rows = columns[0].values.map((_, rowIndex) => columns
+        .map((col, colIndex) => col.values[rowIndex].padEnd(widths[colIndex]))
+        .join("  "));
+    return [header, ...rows].join("\n");
+}
+function formatWindowStatus(status) {
+    return status === "active" ? "[Active]" : "[Idle]";
+}
+function formatPaneStatus(status) {
+    if (status === "active") {
+        return "[Active]";
+    }
+    if (status === "dead") {
+        return "[Dead]";
+    }
+    return "[Idle]";
+}
+function formatCommandTitle(command, title) {
+    if (title) {
+        if (!command) {
+            return title;
+        }
+        return `${command}${TITLE_SEPARATOR}${title}`;
+    }
+    return command;
+}
+function formatWindowTable(windows) {
+    return buildTable([
+        {
+            header: "WIDX",
+            values: windows.map((window) => String(window.widx))
+        },
+        {
+            header: "WID",
+            values: windows.map((window) => window.wid)
+        },
+        {
+            header: "STATUS",
+            values: windows.map((window) => formatWindowStatus(window.status))
+        },
+        {
+            header: "NAME",
+            values: windows.map((window) => window.name)
+        }
+    ]);
+}
+function formatPaneTable(panes) {
+    return buildTable([
+        {
+            header: "IDX",
+            values: panes.map((pane) => String(pane.idx))
+        },
+        {
+            header: "ID",
+            values: panes.map((pane) => pane.id)
+        },
+        {
+            header: "STATUS",
+            values: panes.map((pane) => formatPaneStatus(pane.status))
+        },
+        {
+            header: "COMMAND/TITLE",
+            values: panes.map((pane) => formatCommandTitle(pane.command, pane.title))
+        }
+    ]);
+}
+function formatJson(data) {
+    return JSON.stringify(data);
+}
+function ensureErrorPrefix(message) {
+    const trimmed = message.trim();
+    if (!trimmed) {
+        return "Error: unknown error";
+    }
+    if (trimmed.toLowerCase().startsWith("error:")) {
+        const rest = trimmed.slice(trimmed.indexOf(":") + 1);
+        return `Error:${rest}`;
+    }
+    return `Error: ${trimmed}`;
+}

package/dist/lib/proc/lsof.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listOpenFiles = listOpenFiles;
+const node_child_process_1 = require("node:child_process");
+async function listOpenFiles(pid) {
+    return await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)("lsof", ["-p", String(pid), "-Fn"]);
+        let stdout = "";
+        let stderr = "";
+        if (child.stdout) {
+            child.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+        }
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("close", (code) => {
+            const exitCode = code ?? 0;
+            if (exitCode !== 0) {
+                reject(new Error(stderr.trim() || stdout.trim() || `lsof exited with ${exitCode}`));
+                return;
+            }
+            const paths = [];
+            for (const line of stdout.split(/\r?\n/)) {
+                if (!line.startsWith("n")) {
+                    continue;
+                }
+                const path = line.slice(1);
+                if (path) {
+                    paths.push(path);
+                }
+            }
+            resolve(paths);
+        });
+    });
+}

package/dist/lib/proc/ps.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProcesses = listProcesses;
+const node_child_process_1 = require("node:child_process");
+function parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const match = trimmed.match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/);
+    if (!match) {
+        return null;
+    }
+    const pid = Number(match[1]);
+    const ppid = Number(match[2]);
+    if (!Number.isFinite(pid) || !Number.isFinite(ppid)) {
+        return null;
+    }
+    return {
+        pid,
+        ppid,
+        tty: match[3],
+        command: match[4]
+    };
+}
+async function listProcesses() {
+    return await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)("ps", ["-axo", "pid=,ppid=,tty=,command=", "-ww"]);
+        let stdout = "";
+        let stderr = "";
+        if (child.stdout) {
+            child.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+        }
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("close", (code) => {
+            const exitCode = code ?? 0;
+            if (exitCode !== 0) {
+                reject(new Error(stderr.trim() || stdout.trim() || `ps exited with ${exitCode}`));
+                return;
+            }
+            const entries = [];
+            for (const line of stdout.split(/\r?\n/)) {
+                const parsed = parseLine(line);
+                if (parsed) {
+                    entries.push(parsed);
+                }
+            }
+            resolve(entries);
+        });
+    });
+}

package/dist/lib/targeting/errors.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetResolutionError = void 0;
+class TargetResolutionError extends Error {
+    constructor(options) {
+        super(options.message);
+        this.targetKind = options.targetKind;
+        this.kind = options.kind;
+        this.target = options.target;
+        this.candidates = options.candidates;
+    }
+}
+exports.TargetResolutionError = TargetResolutionError;

package/dist/lib/targeting/resolvePaneTarget.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePaneTarget = resolvePaneTarget;
+const errors_1 = require("./errors");
+function isNumeric(value) {
+    return /^\d+$/.test(value);
+}
+const COMPOSITE_REGEX = /^(@[^%]+)(%[^%]+)$/;
+function resolvePaneTarget(panes, target, options = {}) {
+    const compositeMatch = target.match(COMPOSITE_REGEX);
+    if (compositeMatch) {
+        const [, windowId, paneId] = compositeMatch;
+        const matches = panes.filter((pane) => pane.id === paneId);
+        const inWindow = matches.find((pane) => pane.windowId === windowId);
+        if (!inWindow) {
+            throw new errors_1.TargetResolutionError({
+                targetKind: "pane",
+                kind: "invalid",
+                target,
+                message: `pane ${paneId} is not in window ${windowId}`
+            });
+        }
+        return { id: inWindow.id, idx: inWindow.idx };
+    }
+    if (target.startsWith("%")) {
+        const matches = panes.filter((pane) => pane.id === target);
+        if (matches.length === 0) {
+            throw new errors_1.TargetResolutionError({
+                targetKind: "pane",
+                kind: "not_found",
+                target,
+                message: `pane target "${target}" not found`
+            });
+        }
+        return { id: matches[0].id, idx: matches[0].idx };
+    }
+    if (!options.windowId) {
+        throw new errors_1.TargetResolutionError({
+            targetKind: "pane",
+            kind: "invalid",
+            target,
+            message: "window scope is required for IDX/keyword targets"
+        });
+    }
+    const scoped = panes.filter((pane) => pane.windowId === options.windowId);
+    if (isNumeric(target)) {
+        const idx = Number(target);
+        const matches = scoped.filter((pane) => pane.idx === idx);
+        if (matches.length === 0) {
+            throw new errors_1.TargetResolutionError({
+                targetKind: "pane",
+                kind: "not_found",
+                target,
+                message: `pane target "${target}" not found`
+            });
+        }
+        if (matches.length > 1) {
+            throw new errors_1.TargetResolutionError({
+                targetKind: "pane",
+                kind: "ambiguous",
+                target,
+                message: `target "${target}" matched ${matches.length} panes; use IDX or %pane_id`,
+                candidates: matches
+            });
+        }
+        return { id: matches[0].id, idx: matches[0].idx };
+    }
+    const query = target.toLowerCase();
+    const matches = scoped.filter((pane) => {
+        return (pane.command.toLowerCase().includes(query) ||
+            pane.title.toLowerCase().includes(query));
+    });
+    if (matches.length === 0) {
+        throw new errors_1.TargetResolutionError({
+            targetKind: "pane",
+            kind: "not_found",
+            target,
+            message: `pane target "${target}" not found`
+        });
+    }
+    if (matches.length > 1) {
+        throw new errors_1.TargetResolutionError({
+            targetKind: "pane",
+            kind: "ambiguous",
+            target,
+            message: `target "${target}" matched ${matches.length} panes; use IDX or %pane_id`,
+            candidates: matches
+        });
+    }
+    return { id: matches[0].id, idx: matches[0].idx };
+}

package/dist/lib/targeting/resolveWindowTarget.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWindowTarget = resolveWindowTarget;
+const errors_1 = require("./errors");
+function isNumeric(value) {
+    return /^\d+$/.test(value);
+}
+function resolveWindowTarget(windows, target) {
+    let matches = [];
+    if (target.startsWith("@")) {
+        matches = windows.filter((window) => window.wid === target);
+    }
+    else if (isNumeric(target)) {
+        const index = Number(target);
+        matches = windows.filter((window) => window.widx === index);
+    }
+    else {
+        const query = target.toLowerCase();
+        matches = windows.filter((window) => window.name.toLowerCase().includes(query));
+    }
+    if (matches.length === 0) {
+        throw new errors_1.TargetResolutionError({
+            targetKind: "window",
+            kind: "not_found",
+            target,
+            message: `window target "${target}" not found`
+        });
+    }
+    if (matches.length > 1) {
+        throw new errors_1.TargetResolutionError({
+            targetKind: "window",
+            kind: "ambiguous",
+            target,
+            message: `target "${target}" matched ${matches.length} windows; use WIDX or @window_id`,
+            candidates: matches
+        });
+    }
+    const match = matches[0];
+    return { widx: match.widx, wid: match.wid, name: match.name };
+}

package/dist/lib/targeting/scope.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSessionScope = resolveSessionScope;
+exports.resolveWindowScope = resolveWindowScope;
+const snapshotWindows_1 = require("../tmux/snapshotWindows");
+const exec_1 = require("../tmux/exec");
+const errors_1 = require("./errors");
+const resolveWindowTarget_1 = require("./resolveWindowTarget");
+async function resolveSessionScope(sessionArg, env = process.env) {
+    if (sessionArg) {
+        return { session: sessionArg, source: "explicit" };
+    }
+    if (env.TMUX) {
+        const result = await (0, exec_1.tmuxExec)([
+            "display-message",
+            "-p",
+            "#{session_name}"
+        ]);
+        const session = result.stdout.trim();
+        if (!session) {
+            throw new Error("unable to resolve current session");
+        }
+        return { session, source: "tmux" };
+    }
+    const result = await (0, exec_1.tmuxExec)(["list-sessions", "-F", "#{session_name}"]);
+    const sessions = result.stdout
+        .trim()
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (sessions.length === 0) {
+        throw new Error("no tmux sessions found");
+    }
+    if (sessions.length > 1) {
+        throw new Error("default session is ambiguous; use --session <name>");
+    }
+    return { session: sessions[0], source: "unique" };
+}
+async function resolveWindowScope(session, windowTarget) {
+    const windows = await (0, snapshotWindows_1.snapshotWindows)(session);
+    if (windows.length === 0) {
+        throw new Error(`session ${session} has no windows`);
+    }
+    if (windowTarget) {
+        return (0, resolveWindowTarget_1.resolveWindowTarget)(windows, windowTarget);
+    }
+    const active = windows.find((window) => window.status === "active");
+    if (!active) {
+        throw new errors_1.TargetResolutionError({
+            targetKind: "window",
+            kind: "not_found",
+            target: "active",
+            message: "no active window found",
+            candidates: windows
+        });
+    }
+    return { widx: active.widx, wid: active.wid, name: active.name };
+}

package/dist/lib/tmux/capturePane.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capturePane = capturePane;
+exports.splitLines = splitLines;
+const exec_1 = require("./exec");
+async function capturePane(paneId, lines) {
+    const args = ["capture-pane", "-p", "-t", paneId];
+    if (Number.isFinite(lines) && lines > 0) {
+        args.push("-S", `-${lines}`);
+    }
+    const result = await (0, exec_1.tmuxExec)(args);
+    return result.stdout.replace(/\r?\n$/, "");
+}
+function splitLines(text) {
+    const lines = text.split(/\r?\n/);
+    if (lines.length && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines;
+}

package/dist/lib/tmux/exec.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TmuxExecError = void 0;
+exports.tmuxExec = tmuxExec;
+const node_child_process_1 = require("node:child_process");
+class TmuxExecError extends Error {
+    constructor(message, result) {
+        super(message);
+        this.stdout = result.stdout;
+        this.stderr = result.stderr;
+        this.exitCode = result.exitCode;
+    }
+}
+exports.TmuxExecError = TmuxExecError;
+function getServerArgs(env) {
+    const server = env.AGENT_TMUX_SERVER || env.AGENT_TMUX_SOCKET;
+    if (!server) {
+        return [];
+    }
+    return ["-L", server];
+}
+async function tmuxExec(args, options = {}) {
+    const baseEnv = options.env ?? process.env;
+    const serverArgs = getServerArgs(baseEnv);
+    const env = serverArgs.length > 0 ? { ...baseEnv } : baseEnv;
+    if (serverArgs.length > 0 && "TMUX" in env) {
+        delete env.TMUX;
+    }
+    const finalArgs = [...serverArgs, ...args];
+    return await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)("tmux", finalArgs, { env });
+        let stdout = "";
+        let stderr = "";
+        if (child.stdout) {
+            child.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+        }
+        child.on("error", (error) => {
+            reject(new TmuxExecError(error.message, {
+                stdout,
+                stderr,
+                exitCode: 1
+            }));
+        });
+        child.on("close", (code) => {
+            const exitCode = code ?? 0;
+            const result = { stdout, stderr, exitCode };
+            if (exitCode === 0) {
+                resolve(result);
+                return;
+            }
+            const message = stderr.trim() || stdout.trim() || `tmux exited with ${exitCode}`;
+            reject(new TmuxExecError(message, result));
+        });
+        if (options.input !== undefined) {
+            child.stdin?.write(options.input);
+            child.stdin?.end();
+        }
+    });
+}

package/dist/lib/tmux/paneOps.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paneSpawn = paneSpawn;
+exports.paneTitle = paneTitle;
+exports.paneKill = paneKill;
+const exec_1 = require("./exec");
+async function paneSpawn(windowId) {
+    const args = [
+        "split-window",
+        "-P",
+        "-F",
+        "#{pane_id}\t#{pane_index}",
+        "-t",
+        windowId,
+        "-d"
+    ];
+    const result = await (0, exec_1.tmuxExec)(args);
+    const [id, idxRaw] = result.stdout.trim().split("\t");
+    return {
+        id,
+        idx: Number(idxRaw)
+    };
+}
+async function paneTitle(paneId, title) {
+    await (0, exec_1.tmuxExec)(["select-pane", "-t", paneId, "-T", title]);
+}
+async function paneKill(paneId) {
+    await (0, exec_1.tmuxExec)(["kill-pane", "-t", paneId]);
+}

package/dist/lib/tmux/paste.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pasteText = pasteText;
+const exec_1 = require("./exec");
+function createBufferName() {
+    const rand = Math.random().toString(36).slice(2, 10);
+    return `__agent_tmux_${process.pid}_${Date.now()}_${rand}`;
+}
+async function pasteText(paneId, text) {
+    const bufferName = createBufferName();
+    await (0, exec_1.tmuxExec)(["load-buffer", "-b", bufferName, "-"], { input: text });
+    try {
+        await (0, exec_1.tmuxExec)(["paste-buffer", "-p", "-d", "-b", bufferName, "-t", paneId]);
+    }
+    finally {
+        try {
+            await (0, exec_1.tmuxExec)(["delete-buffer", "-b", bufferName]);
+        }
+        catch {
+            // ignore best-effort cleanup failures
+        }
+    }
+}