tmux-agent 0.1.0

package/dist/lib/codex/sessionInfo.js

@@ -0,0 +1,449 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCodexSessionInfo = resolveCodexSessionInfo;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const ps_1 = require("../proc/ps");
+const lsof_1 = require("../proc/lsof");
+const exec_1 = require("../tmux/exec");
+const UUID_RE = /([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})/g;
+const SHELL_SNAPSHOT_RE = /(?<path>\/[^\s"' ]*\/shell_snapshots\/(?<uuid>[0-9a-fA-F-]{36})\.(?:sh|ps1))/;
+const CODEX_COMMAND_PATTERNS = [
+    /\/@openai\/codex\/.*\/vendor\/.*\/codex\/codex\b/i,
+    /\/@openai\/codex\/bin\/codex\b/i,
+    /(^|[\s/])codex([\s]|$)/i
+];
+function matchesCodexCommand(command) {
+    return CODEX_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
+}
+function parseSessionIdFromPath(value) {
+    const matches = value.match(UUID_RE);
+    if (!matches || matches.length === 0) {
+        throw new Error(`unable to parse session id from rollout path: ${value}`);
+    }
+    return matches[matches.length - 1];
+}
+function inferCodexHomeFromRolloutPath(rolloutPath) {
+    const parts = node_path_1.default.resolve(rolloutPath).split(node_path_1.default.sep);
+    const idx = parts.lastIndexOf("sessions");
+    if (idx <= 0) {
+        return undefined;
+    }
+    return parts.slice(0, idx).join(node_path_1.default.sep);
+}
+function inferCodexHomeFromSnapshotPath(snapshotPath) {
+    const resolved = node_path_1.default.resolve(snapshotPath);
+    const parent = node_path_1.default.dirname(resolved);
+    if (node_path_1.default.basename(parent) !== "shell_snapshots") {
+        return undefined;
+    }
+    return node_path_1.default.dirname(parent);
+}
+function tryParseShellSnapshot(cmdline) {
+    const match = SHELL_SNAPSHOT_RE.exec(cmdline);
+    if (!match || !match.groups) {
+        return null;
+    }
+    const snapshotPath = match.groups.path;
+    const sessionId = match.groups.uuid;
+    const codexHome = inferCodexHomeFromSnapshotPath(snapshotPath);
+    return { sessionId, snapshotPath, codexHome };
+}
+async function listRolloutFiles(codexHome, limit = 800) {
+    const sessionsDir = node_path_1.default.join(codexHome, "sessions");
+    const results = [];
+    const stack = [sessionsDir];
+    while (stack.length) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = await node_fs_1.promises.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            if (!entry.name.startsWith("rollout-") || !entry.name.endsWith(".jsonl")) {
+                continue;
+            }
+            try {
+                const stat = await node_fs_1.promises.stat(full);
+                results.push({ path: full, mtimeMs: stat.mtimeMs });
+            }
+            catch {
+                continue;
+            }
+            if (results.length >= limit) {
+                break;
+            }
+        }
+        if (results.length >= limit) {
+            break;
+        }
+    }
+    results.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return results.map((item) => item.path);
+}
+async function findRolloutBySessionId(codexHome, sessionId) {
+    const rollouts = await listRolloutFiles(codexHome, 800);
+    const candidates = rollouts.filter((p) => node_path_1.default.basename(p).includes(sessionId));
+    if (candidates.length === 0) {
+        return null;
+    }
+    return candidates[0];
+}
+async function readSessionMetaCwd(rolloutPath, maxLines = 30) {
+    try {
+        const handle = await node_fs_1.promises.open(rolloutPath, "r");
+        const stream = handle.createReadStream({ encoding: "utf8" });
+        let buffer = "";
+        let lineCount = 0;
+        for await (const chunk of stream) {
+            buffer += chunk;
+            let idx = buffer.indexOf("\n");
+            while (idx !== -1) {
+                const line = buffer.slice(0, idx).trim();
+                buffer = buffer.slice(idx + 1);
+                if (line) {
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj?.type === "session_meta" && typeof obj?.payload === "object") {
+                            const cwd = obj.payload?.cwd;
+                            if (typeof cwd === "string" && cwd) {
+                                await handle.close();
+                                return cwd;
+                            }
+                        }
+                    }
+                    catch {
+                        // ignore parse errors
+                    }
+                    lineCount += 1;
+                    if (lineCount >= maxLines) {
+                        await handle.close();
+                        return null;
+                    }
+                }
+                idx = buffer.indexOf("\n");
+            }
+        }
+        await handle.close();
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function buildProcessMaps(processes) {
+    const parentByPid = new Map();
+    const commandByPid = new Map();
+    const ttyByPid = new Map();
+    for (const proc of processes) {
+        parentByPid.set(proc.pid, proc.ppid);
+        commandByPid.set(proc.pid, proc.command);
+        ttyByPid.set(proc.pid, proc.tty);
+    }
+    return { parentByPid, commandByPid, ttyByPid };
+}
+function isDescendant(pid, ancestorPid, parentByPid) {
+    let current = pid;
+    for (let i = 0; i < 400; i += 1) {
+        if (current === ancestorPid) {
+            return true;
+        }
+        current = parentByPid.get(current) ?? 0;
+        if (current <= 1) {
+            return false;
+        }
+    }
+    return false;
+}
+function filterRolloutPaths(paths) {
+    const out = [];
+    const seen = new Set();
+    for (const filePath of paths) {
+        if (!filePath.includes("rollout-") || !filePath.endsWith(".jsonl")) {
+            continue;
+        }
+        if (!filePath.includes(`${node_path_1.default.sep}sessions${node_path_1.default.sep}`)) {
+            continue;
+        }
+        if (seen.has(filePath)) {
+            continue;
+        }
+        seen.add(filePath);
+        out.push(filePath);
+    }
+    return out;
+}
+async function latestExistingPath(paths) {
+    const candidates = [];
+    for (const p of paths) {
+        try {
+            const stat = await node_fs_1.promises.stat(p);
+            candidates.push({ path: p, mtimeMs: stat.mtimeMs });
+        }
+        catch {
+            continue;
+        }
+    }
+    if (candidates.length === 0) {
+        throw new Error("rollout file not found");
+    }
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return candidates[0].path;
+}
+async function getPanePid(paneId) {
+    try {
+        const result = await (0, exec_1.tmuxExec)(["display-message", "-p", "-t", paneId, "#{pane_pid}"]);
+        const trimmed = result.stdout.trim();
+        const pid = Number(trimmed);
+        return Number.isFinite(pid) ? pid : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function detectShellSnapshot(processes, codexHome) {
+    const { parentByPid, commandByPid } = buildProcessMaps(processes);
+    let current = process.pid;
+    for (let i = 0; i < 80; i += 1) {
+        const cmdline = commandByPid.get(current) ?? "";
+        const hit = tryParseShellSnapshot(cmdline);
+        if (hit) {
+            const home = hit.codexHome ?? codexHome;
+            const rolloutPath = await findRolloutBySessionId(home, hit.sessionId);
+            if (rolloutPath) {
+                const inferredHome = inferCodexHomeFromRolloutPath(rolloutPath) ?? home;
+                return {
+                    sessionId: hit.sessionId,
+                    rolloutPath,
+                    method: "shell-snapshot",
+                    selfPid: process.pid,
+                    codexHome: inferredHome
+                };
+            }
+        }
+        current = parentByPid.get(current) ?? 0;
+        if (current <= 1) {
+            break;
+        }
+    }
+    return null;
+}
+async function pickRolloutForAnchorPid(anchorPid, processes, codexHome) {
+    const { parentByPid, commandByPid } = buildProcessMaps(processes);
+    const matchedPids = [];
+    let paths = [];
+    const snapshotHits = [];
+    for (const proc of processes) {
+        if (!matchesCodexCommand(proc.command)) {
+            continue;
+        }
+        if (!isDescendant(proc.pid, anchorPid, parentByPid)) {
+            continue;
+        }
+        matchedPids.push(proc.pid);
+        const snapshotHit = tryParseShellSnapshot(proc.command);
+        if (snapshotHit) {
+            snapshotHits.push(snapshotHit);
+        }
+        try {
+            const openFiles = await (0, lsof_1.listOpenFiles)(proc.pid);
+            paths = paths.concat(filterRolloutPaths(openFiles));
+        }
+        catch {
+            // ignore
+        }
+    }
+    const uniqMatched = Array.from(new Set(matchedPids));
+    if (paths.length > 0) {
+        const rolloutPath = await latestExistingPath(paths);
+        return { rolloutPath, matchedPids: uniqMatched, method: "anchor" };
+    }
+    for (const hit of snapshotHits) {
+        const home = hit.codexHome ?? codexHome;
+        const rolloutPath = await findRolloutBySessionId(home, hit.sessionId);
+        if (rolloutPath) {
+            return { rolloutPath, matchedPids: uniqMatched, method: "anchor-shell-snapshot" };
+        }
+    }
+    const rollouts = await listRolloutFiles(codexHome, 200);
+    const uniqRollouts = Array.from(new Set(rollouts));
+    if (uniqRollouts.length === 1) {
+        return { rolloutPath: uniqRollouts[0], matchedPids: uniqMatched, method: "sessions-singleton" };
+    }
+    if (uniqRollouts.length > 1) {
+        const lines = uniqRollouts
+            .slice(0, 12)
+            .map((p) => `- ${p}`)
+            .join("\n");
+        throw new Error(`no rollout paths found for anchor pid ${anchorPid} (found ${uniqRollouts.length} rollouts under codex home)\n${lines}`);
+    }
+    throw new Error(`no rollout paths found for anchor pid ${anchorPid}`);
+}
+async function pickRolloutAuto(processes, codexHome) {
+    const { parentByPid, commandByPid, ttyByPid } = buildProcessMaps(processes);
+    const selfPid = process.pid;
+    let current = selfPid;
+    for (let i = 0; i < 600; i += 1) {
+        current = parentByPid.get(current) ?? 0;
+        if (current <= 1) {
+            break;
+        }
+        const cmd = commandByPid.get(current) ?? "";
+        if (matchesCodexCommand(cmd)) {
+            try {
+                const picked = await pickRolloutForAnchorPid(current, processes, codexHome);
+                return { ...picked, method: "ancestor" };
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    const selfTty = ttyByPid.get(selfPid) ?? "?";
+    if (selfTty && selfTty !== "?") {
+        const rolloutsByPid = [];
+        for (const proc of processes) {
+            if (!matchesCodexCommand(proc.command)) {
+                continue;
+            }
+            if ((ttyByPid.get(proc.pid) ?? "?") !== selfTty) {
+                continue;
+            }
+            const openFiles = await (0, lsof_1.listOpenFiles)(proc.pid);
+            const filtered = filterRolloutPaths(openFiles);
+            if (filtered.length === 0) {
+                continue;
+            }
+            try {
+                rolloutsByPid.push({ pid: proc.pid, path: await latestExistingPath(filtered) });
+            }
+            catch {
+                continue;
+            }
+        }
+        const uniq = Array.from(new Set(rolloutsByPid.map((item) => item.path)));
+        if (uniq.length === 1) {
+            return { rolloutPath: uniq[0], matchedPids: [rolloutsByPid[0].pid], method: "tty" };
+        }
+        if (uniq.length > 1) {
+            const lines = rolloutsByPid
+                .slice(0, 12)
+                .map((item) => `- pid=${item.pid} rollout=${item.path}`)
+                .join("\n");
+            throw new Error(`multiple codex sessions on same tty; provide pane/pid.\n${lines}`);
+        }
+    }
+    const rolloutsByPid = [];
+    for (const proc of processes) {
+        if (!matchesCodexCommand(proc.command)) {
+            continue;
+        }
+        const openFiles = await (0, lsof_1.listOpenFiles)(proc.pid);
+        const filtered = filterRolloutPaths(openFiles);
+        if (filtered.length === 0) {
+            continue;
+        }
+        try {
+            rolloutsByPid.push({ pid: proc.pid, path: await latestExistingPath(filtered) });
+        }
+        catch {
+            continue;
+        }
+    }
+    const uniq = Array.from(new Set(rolloutsByPid.map((item) => item.path)));
+    if (uniq.length === 1) {
+        return { rolloutPath: uniq[0], matchedPids: [rolloutsByPid[0].pid], method: "global-singleton" };
+    }
+    if (uniq.length > 1) {
+        const lines = rolloutsByPid
+            .slice(0, 12)
+            .map((item) => `- pid=${item.pid} rollout=${item.path}`)
+            .join("\n");
+        throw new Error(`multiple codex sessions found; provide pane/pid.\n${lines}`);
+    }
+    throw new Error("no active codex sessions detected");
+}
+async function resolveCodexSessionInfo(options = {}) {
+    const codexHome = options.codexHome?.trim() ||
+        process.env.CODEX_HOME?.trim() ||
+        node_path_1.default.join(process.env.HOME || "", ".codex");
+    let anchorPid = options.panePid;
+    if (!anchorPid && options.paneId) {
+        anchorPid = await getPanePid(options.paneId);
+    }
+    let picked;
+    if (anchorPid) {
+        const processes = await (0, ps_1.listProcesses)();
+        picked = await pickRolloutForAnchorPid(anchorPid, processes, codexHome);
+    }
+    else {
+        const processes = await (0, ps_1.listProcesses)();
+        const snapshot = await detectShellSnapshot(processes, codexHome);
+        if (snapshot) {
+            return snapshot;
+        }
+        picked = await pickRolloutAuto(processes, codexHome);
+    }
+    const sessionId = parseSessionIdFromPath(picked.rolloutPath);
+    const inferredHome = inferCodexHomeFromRolloutPath(picked.rolloutPath) ?? codexHome;
+    if (options.cd) {
+        const cwd = await readSessionMetaCwd(picked.rolloutPath);
+        if (cwd && node_path_1.default.resolve(cwd) !== node_path_1.default.resolve(options.cd)) {
+            if (options.allowScanSessions) {
+                const rollouts = await listRolloutFiles(codexHome, 800);
+                const matches = [];
+                for (const rollout of rollouts) {
+                    const metaCwd = await readSessionMetaCwd(rollout);
+                    if (!metaCwd) {
+                        continue;
+                    }
+                    if (node_path_1.default.resolve(metaCwd) !== node_path_1.default.resolve(options.cd)) {
+                        continue;
+                    }
+                    matches.push({ sessionId: parseSessionIdFromPath(rollout), path: rollout });
+                }
+                if (matches.length === 1) {
+                    return {
+                        sessionId: matches[0].sessionId,
+                        rolloutPath: matches[0].path,
+                        method: "sessions-cwd",
+                        codexHome: inferCodexHomeFromRolloutPath(matches[0].path) ?? codexHome
+                    };
+                }
+                if (matches.length > 1) {
+                    const lines = matches
+                        .slice(0, 12)
+                        .map((item) => `- ${item.sessionId} ${item.path}`)
+                        .join("\n");
+                    throw new Error(`multiple sessions matched cwd; provide explicit session id or rollout path.\n${lines}`);
+                }
+            }
+            throw new Error("detected rollout cwd does not match cd filter");
+        }
+    }
+    return {
+        sessionId,
+        rolloutPath: picked.rolloutPath,
+        method: picked.method,
+        matchedPids: picked.matchedPids,
+        selfPid: process.pid,
+        codexHome: inferredHome
+    };
+}

package/dist/lib/codex/spawn.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexSpawn = codexSpawn;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const exec_1 = require("../tmux/exec");
+function parseNumber(value) {
+    const num = Number(value);
+    return Number.isFinite(num) ? num : 0;
+}
+async function getWindowId(paneId) {
+    const result = await (0, exec_1.tmuxExec)(["display-message", "-p", "-t", paneId, "#{window_id}"]);
+    const windowId = result.stdout.trim();
+    if (!windowId) {
+        throw new Error(`unable to resolve window_id from pane ${paneId}`);
+    }
+    return windowId;
+}
+async function getPaneCurrentPath(paneId) {
+    const result = await (0, exec_1.tmuxExec)([
+        "display-message",
+        "-p",
+        "-t",
+        paneId,
+        "#{pane_current_path}"
+    ]);
+    return result.stdout.trim() || process.cwd();
+}
+async function listPaneLayout(windowId) {
+    const result = await (0, exec_1.tmuxExec)([
+        "list-panes",
+        "-t",
+        windowId,
+        "-F",
+        "#{pane_id}|#{pane_left}|#{pane_top}|#{pane_current_path}"
+    ]);
+    const rows = [];
+    for (const line of result.stdout.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const [paneId, leftRaw, topRaw, panePath] = trimmed.split("|");
+        if (!paneId) {
+            continue;
+        }
+        rows.push({
+            paneId,
+            left: parseNumber(leftRaw),
+            top: parseNumber(topRaw),
+            path: (panePath ?? "").trim()
+        });
+    }
+    rows.sort((a, b) => (a.left !== b.left ? a.left - b.left : a.top - b.top));
+    return rows;
+}
+function buildColumns(rows) {
+    const columns = [];
+    const byLeft = new Map();
+    for (const row of rows) {
+        let col = byLeft.get(row.left);
+        if (!col) {
+            col = {
+                left: row.left,
+                count: 0,
+                topPaneId: row.paneId,
+                topPath: row.path,
+                topTop: row.top,
+                bottomPaneId: row.paneId,
+                bottomPath: row.path,
+                bottomTop: row.top
+            };
+            byLeft.set(row.left, col);
+            columns.push(col);
+        }
+        col.count += 1;
+        if (row.top < col.topTop) {
+            col.topTop = row.top;
+            col.topPaneId = row.paneId;
+            col.topPath = row.path;
+        }
+        if (row.top > col.bottomTop) {
+            col.bottomTop = row.top;
+            col.bottomPaneId = row.paneId;
+            col.bottomPath = row.path;
+        }
+    }
+    columns.sort((a, b) => a.left - b.left);
+    return columns;
+}
+function resolveReadyFile() {
+    const dir = (process.env.CODEX_PANE_READY_DIR || process.env.TMPDIR || node_os_1.default.tmpdir()).trim();
+    if (!dir) {
+        return null;
+    }
+    const safeDir = dir.replace(/\/+$/, "");
+    const name = `codex_pane_ready_${process.pid}_${Date.now()}_${Math.random()
+        .toString(16)
+        .slice(2)}`;
+    return node_path_1.default.join(safeDir, name);
+}
+async function waitForReadyFile(filePath) {
+    const maxTries = parseNumber(process.env.CODEX_PANE_READY_MAX_TRIES || "120");
+    const sleepMs = parseNumber(process.env.CODEX_PANE_READY_SLEEP_MS || "50");
+    for (let i = 0; i < Math.max(1, maxTries); i += 1) {
+        try {
+            await node_fs_1.promises.stat(filePath);
+            try {
+                await node_fs_1.promises.rm(filePath, { force: true });
+            }
+            catch {
+                // ignore
+            }
+            return;
+        }
+        catch {
+            // keep waiting
+        }
+        await new Promise((resolve) => setTimeout(resolve, Math.max(0, sleepMs)));
+    }
+}
+async function splitWindow(args, readyFile) {
+    if (readyFile) {
+        try {
+            const result = await (0, exec_1.tmuxExec)([
+                ...args,
+                "-e",
+                `CODEX_PANE_READY_FILE=${readyFile}`
+            ]);
+            return { paneId: result.stdout.trim(), readyUsed: true };
+        }
+        catch {
+            // fall through
+        }
+    }
+    const result = await (0, exec_1.tmuxExec)(args);
+    return { paneId: result.stdout.trim(), readyUsed: false };
+}
+async function codexSpawn(originPaneId, options = {}) {
+    const windowId = await getWindowId(originPaneId);
+    const layout = await listPaneLayout(windowId);
+    const totalPanes = layout.length;
+    const readyFile = resolveReadyFile();
+    if (options.forceSimpleSplit) {
+        const originPath = await getPaneCurrentPath(originPaneId);
+        const { paneId, readyUsed } = await splitWindow(["split-window", "-d", "-P", "-F", "#{pane_id}", "-t", originPaneId, "-c", originPath], readyFile);
+        if (!paneId) {
+            throw new Error("failed to create new pane");
+        }
+        if (readyUsed && readyFile) {
+            await waitForReadyFile(readyFile);
+        }
+        return {
+            createdPaneId: paneId,
+            meta: {
+                window_id: windowId,
+                action: "simple_split",
+                total_panes: totalPanes + 1,
+                source: "force-simple-split"
+            }
+        };
+    }
+    const columns = buildColumns(layout);
+    const colCount = columns.length;
+    if (colCount === 0) {
+        throw new Error(`no panes detected in window ${windowId}`);
+    }
+    if (colCount > 3) {
+        throw new Error("window has more than 3 columns; refusing to add pane");
+    }
+    if (columns[0].count !== 1) {
+        throw new Error(`leftmost column has ${columns[0].count} panes; expected 1`);
+    }
+    if (totalPanes >= 7) {
+        throw new Error("window already at max panes (1+3+3)");
+    }
+    if (colCount < 3) {
+        if (colCount === 2 && columns[1].count !== 1) {
+            throw new Error("right column already split; refusing to add a third column");
+        }
+        const target = columns[colCount - 1];
+        const { paneId, readyUsed } = await splitWindow([
+            "split-window",
+            "-h",
+            "-d",
+            "-P",
+            "-F",
+            "#{pane_id}",
+            "-t",
+            target.topPaneId,
+            "-c",
+            target.topPath
+        ], readyFile);
+        if (!paneId) {
+            throw new Error("failed to create new pane");
+        }
+        if (readyUsed && readyFile) {
+            await waitForReadyFile(readyFile);
+        }
+        return {
+            createdPaneId: paneId,
+            meta: {
+                window_id: windowId,
+                action: "add_column",
+                column: colCount + 1,
+                total_panes: totalPanes + 1
+            }
+        };
+    }
+    if (columns[1].count >= 3 && columns[2].count >= 3) {
+        throw new Error("columns 2 and 3 are full; refusing to add pane");
+    }
+    const targetColumnIndex = columns[1].count < 3 ? 1 : 2;
+    const targetColumn = columns[targetColumnIndex];
+    const { paneId, readyUsed } = await splitWindow([
+        "split-window",
+        "-v",
+        "-d",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "-t",
+        targetColumn.bottomPaneId,
+        "-c",
+        targetColumn.bottomPath
+    ], readyFile);
+    if (!paneId) {
+        throw new Error("failed to create new pane");
+    }
+    if (readyUsed && readyFile) {
+        await waitForReadyFile(readyFile);
+    }
+    return {
+        createdPaneId: paneId,
+        meta: {
+            window_id: windowId,
+            action: "add_row",
+            column: targetColumnIndex + 1,
+            total_panes: totalPanes + 1
+        }
+    };
+}

package/dist/lib/contracts/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });