tmux-agent 0.1.0

package/src/lib/codex/send.ts

@@ -0,0 +1,84 @@
+import { capturePane } from "../tmux/capturePane";
+import { tmuxExec } from "../tmux/exec";
+import { pasteText } from "../tmux/paste";
+import { parseKeyExpression } from "../tmux/sendKeys";
+
+export type CodexSendOptions = {
+  submitKey?: string;
+  submitDelayMs?: number;
+  postDelayMs?: number;
+  captureTailLines?: number;
+};
+
+export type CodexSendResult = {
+  mode: "text" | "keys";
+  submit?: string;
+  submit_delay_ms?: number;
+  post_delay_ms?: number;
+  capture_tail?: string;
+};
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function normalizeTmuxKey(key: string): string {
+  const parsed = parseKeyExpression(key);
+  return parsed ?? key;
+}
+
+export async function codexSend(
+  paneId: string,
+  input: string,
+  options: CodexSendOptions = {}
+): Promise<CodexSendResult> {
+  const submitKey = options.submitKey?.trim() ?? "";
+  const submitDelayMs = Math.max(0, options.submitDelayMs ?? 0);
+  const postDelayMs = Math.max(0, options.postDelayMs ?? 0);
+  const captureTailLines = options.captureTailLines;
+
+  const tmuxKey = parseKeyExpression(input);
+  if (tmuxKey) {
+    await tmuxExec(["send-keys", "-t", paneId, tmuxKey]);
+    if (postDelayMs > 0) {
+      await sleep(postDelayMs);
+    }
+    const capture_tail =
+      captureTailLines && captureTailLines > 0
+        ? await capturePane(paneId, captureTailLines)
+        : undefined;
+    return {
+      mode: "keys",
+      ...(capture_tail ? { capture_tail } : {})
+    };
+  }
+
+  await pasteText(paneId, input);
+  if (submitKey) {
+    if (submitDelayMs > 0) {
+      await sleep(submitDelayMs);
+    }
+    await tmuxExec(["send-keys", "-t", paneId, normalizeTmuxKey(submitKey)]);
+  }
+
+  if (postDelayMs > 0) {
+    await sleep(postDelayMs);
+  }
+
+  const capture_tail =
+    captureTailLines && captureTailLines > 0
+      ? await capturePane(paneId, captureTailLines)
+      : undefined;
+
+  return {
+    mode: "text",
+    ...(submitKey
+      ? {
+          submit: submitKey,
+          submit_delay_ms: submitDelayMs
+        }
+      : {}),
+    ...(postDelayMs > 0 ? { post_delay_ms: postDelayMs } : {}),
+    ...(capture_tail ? { capture_tail } : {})
+  };
+}

package/src/lib/codex/sessionInfo.ts

@@ -0,0 +1,521 @@
+import { promises as fs } from "node:fs";
+import type { Dirent } from "node:fs";
+import path from "node:path";
+import { listProcesses, type ProcessEntry } from "../proc/ps";
+import { listOpenFiles } from "../proc/lsof";
+import { tmuxExec } from "../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
+];
+
+export type SessionInfoResult = {
+  sessionId: string;
+  rolloutPath: string;
+  method: string;
+  matchedPids?: number[];
+  selfPid?: number;
+  codexHome?: string;
+};
+
+type ShellSnapshotHit = {
+  sessionId: string;
+  snapshotPath: string;
+  codexHome?: string;
+};
+
+function matchesCodexCommand(command: string): boolean {
+  return CODEX_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
+}
+
+function parseSessionIdFromPath(value: string): string {
+  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: string): string | undefined {
+  const parts = path.resolve(rolloutPath).split(path.sep);
+  const idx = parts.lastIndexOf("sessions");
+  if (idx <= 0) {
+    return undefined;
+  }
+  return parts.slice(0, idx).join(path.sep);
+}
+
+function inferCodexHomeFromSnapshotPath(snapshotPath: string): string | undefined {
+  const resolved = path.resolve(snapshotPath);
+  const parent = path.dirname(resolved);
+  if (path.basename(parent) !== "shell_snapshots") {
+    return undefined;
+  }
+  return path.dirname(parent);
+}
+
+function tryParseShellSnapshot(cmdline: string): ShellSnapshotHit | null {
+  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: string, limit = 800): Promise<string[]> {
+  const sessionsDir = path.join(codexHome, "sessions");
+  const results: { path: string; mtimeMs: number }[] = [];
+  const stack: string[] = [sessionsDir];
+
+  while (stack.length) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    let entries: Dirent[];
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.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 fs.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: string,
+  sessionId: string
+): Promise<string | null> {
+  const rollouts = await listRolloutFiles(codexHome, 800);
+  const candidates = rollouts.filter((p) => path.basename(p).includes(sessionId));
+  if (candidates.length === 0) {
+    return null;
+  }
+  return candidates[0];
+}
+
+async function readSessionMetaCwd(rolloutPath: string, maxLines = 30): Promise<string | null> {
+  try {
+    const handle = await fs.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: ProcessEntry[]): {
+  parentByPid: Map<number, number>;
+  commandByPid: Map<number, string>;
+  ttyByPid: Map<number, string>;
+} {
+  const parentByPid = new Map<number, number>();
+  const commandByPid = new Map<number, string>();
+  const ttyByPid = new Map<number, string>();
+  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: number,
+  ancestorPid: number,
+  parentByPid: Map<number, number>
+): boolean {
+  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: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const filePath of paths) {
+    if (!filePath.includes("rollout-") || !filePath.endsWith(".jsonl")) {
+      continue;
+    }
+    if (!filePath.includes(`${path.sep}sessions${path.sep}`)) {
+      continue;
+    }
+    if (seen.has(filePath)) {
+      continue;
+    }
+    seen.add(filePath);
+    out.push(filePath);
+  }
+  return out;
+}
+
+async function latestExistingPath(paths: string[]): Promise<string> {
+  const candidates: { path: string; mtimeMs: number }[] = [];
+  for (const p of paths) {
+    try {
+      const stat = await fs.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: string): Promise<number | undefined> {
+  try {
+    const result = await 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: ProcessEntry[],
+  codexHome: string
+): Promise<SessionInfoResult | null> {
+  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: number,
+  processes: ProcessEntry[],
+  codexHome: string
+): Promise<{ rolloutPath: string; matchedPids: number[]; method: string }> {
+  const { parentByPid, commandByPid } = buildProcessMaps(processes);
+  const matchedPids: number[] = [];
+  let paths: string[] = [];
+  const snapshotHits: ShellSnapshotHit[] = [];
+  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 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: ProcessEntry[],
+  codexHome: string
+): Promise<{ rolloutPath: string; matchedPids: number[]; method: string }> {
+  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: { pid: number; path: string }[] = [];
+    for (const proc of processes) {
+      if (!matchesCodexCommand(proc.command)) {
+        continue;
+      }
+      if ((ttyByPid.get(proc.pid) ?? "?") !== selfTty) {
+        continue;
+      }
+      const openFiles = await 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: { pid: number; path: string }[] = [];
+  for (const proc of processes) {
+    if (!matchesCodexCommand(proc.command)) {
+      continue;
+    }
+    const openFiles = await 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");
+}
+
+export type SessionInfoOptions = {
+  paneId?: string;
+  panePid?: number;
+  codexHome?: string;
+  cd?: string;
+  allowScanSessions?: boolean;
+};
+
+export async function resolveCodexSessionInfo(
+  options: SessionInfoOptions = {}
+): Promise<SessionInfoResult> {
+  const codexHome =
+    options.codexHome?.trim() ||
+    process.env.CODEX_HOME?.trim() ||
+    path.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 listProcesses();
+    picked = await pickRolloutForAnchorPid(anchorPid, processes, codexHome);
+  } else {
+    const processes = await 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 && path.resolve(cwd) !== path.resolve(options.cd)) {
+      if (options.allowScanSessions) {
+        const rollouts = await listRolloutFiles(codexHome, 800);
+        const matches: { sessionId: string; path: string }[] = [];
+        for (const rollout of rollouts) {
+          const metaCwd = await readSessionMetaCwd(rollout);
+          if (!metaCwd) {
+            continue;
+          }
+          if (path.resolve(metaCwd) !== path.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
+  };
+}