tokenmaxxing 1.7.0 → 1.8.0

package/src/lib/relay/turn.ts

@@ -0,0 +1,137 @@
+// relay turn: ensure session, send prompt, wait until turn-done OR permission-needed.
+
+import { delay } from "es-toolkit";
+import { loadRelayConfig } from "./config.ts";
+import {
+  clearPendingRequest,
+  clearTurnDoneMarker,
+  listPendingRequests,
+  readTurnDoneMarker,
+} from "./markers.ts";
+import { permissionPingsEnabled, type ClaudePermissionMode } from "./modes.ts";
+import { formatRelayStdout, type RelayStdout } from "./protocol.ts";
+import { readEntry, touchEntry, withSessionLock } from "./registry.ts";
+import { getTmux } from "./tmux.ts";
+import { ensureSession, sendPrompt } from "./worker.ts";
+import type { RelayWorker } from "./config.ts";
+
+const POLL_MS = 50;
+
+export type TurnParams = {
+  sessionId?: string;
+  worker?: RelayWorker;
+  permissionMode?: ClaudePermissionMode;
+  cwd: string;
+  prompt?: string;
+  /** When true, do not send a prompt; only wait for the next marker. */
+  waitOnly?: boolean;
+  timeoutMs?: number;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+};
+
+export type TurnResult = {
+  exitCode: number;
+  stdout: string;
+  payload: RelayStdout;
+  entrySessionId: string;
+};
+
+export async function runTurn(input: TurnParams): Promise<TurnResult> {
+  const cfg = loadRelayConfig();
+  const sleep = input.sleep ?? delay;
+  const now = input.now ?? Date.now;
+  const timeoutMs = input.timeoutMs ?? cfg.turnTimeoutMs;
+
+  const entry = await ensureSession({
+    sessionId: input.sessionId,
+    worker: input.worker,
+    permissionMode: input.permissionMode,
+    cwd: input.cwd,
+    now: now(),
+  });
+
+  if (!input.waitOnly) {
+    const prompt = input.prompt ?? "";
+    if (prompt.trim() === "") throw new Error("relay turn requires a prompt (argv or stdin)");
+    await sendPrompt({ sessionId: entry.sessionId, prompt });
+  } else {
+    await withSessionLock({
+      sessionId: entry.sessionId,
+      fn: () => touchEntry({ sessionId: entry.sessionId, state: "running", now: now() }),
+    });
+  }
+
+  const deadline = now() + timeoutMs;
+  while (now() < deadline) {
+    const pending = listPendingRequests({ sessionId: entry.sessionId });
+    const live = readEntry({ sessionId: entry.sessionId });
+    const mode = live?.permissionMode ?? entry.permissionMode;
+    if (pending.length > 0 && permissionPingsEnabled({ mode })) {
+      const req = pending[0]!;
+      await withSessionLock({
+        sessionId: entry.sessionId,
+        fn: () => touchEntry({
+          sessionId: entry.sessionId,
+          state: "permission-needed",
+          pendingRequestId: req.requestId,
+          now: now(),
+        }),
+      });
+      const payload: RelayStdout = {
+        kind: "permission-needed",
+        sessionId: entry.sessionId,
+        permissionMode: mode,
+        requestId: req.requestId,
+        summary: req.summary,
+        detail: req.detail,
+      };
+      return {
+        exitCode: 0,
+        stdout: formatRelayStdout({ payload }),
+        payload,
+        entrySessionId: entry.sessionId,
+      };
+    }
+    // Under bypassPermissions, auto-clear any stray pending (should not fire).
+    if (pending.length > 0 && !permissionPingsEnabled({ mode })) {
+      for (const req of pending) {
+        clearPendingRequest({ sessionId: entry.sessionId, requestId: req.requestId });
+      }
+    }
+
+    const done = readTurnDoneMarker({ sessionId: entry.sessionId });
+    if (done != null) {
+      const text = getTmux().capturePane({ name: entry.tmuxName });
+      clearTurnDoneMarker({ sessionId: entry.sessionId });
+      await withSessionLock({
+        sessionId: entry.sessionId,
+        fn: () => touchEntry({
+          sessionId: entry.sessionId,
+          state: "idle",
+          pendingRequestId: null,
+          now: now(),
+        }),
+      });
+      const payload: RelayStdout = {
+        kind: "turn-done",
+        sessionId: entry.sessionId,
+        permissionMode: mode,
+        text,
+      };
+      return {
+        exitCode: 0,
+        stdout: formatRelayStdout({ payload }),
+        payload,
+        entrySessionId: entry.sessionId,
+      };
+    }
+
+    await sleep(POLL_MS);
+  }
+
+  throw new Error(`relay turn timed out after ${timeoutMs}ms (session ${entry.sessionId})`);
+}
+
+// re-export for callers that type worker from turn
+export type { RelayWorker };

package/src/lib/relay/worker.ts

@@ -0,0 +1,141 @@
+// Ensure a durable tmux worker for a relay session. Spawns tokenmaxxing-
+// supervised claude/codex via PATH shims with pooled env intact.
+
+import { join } from "node:path";
+import { paths } from "../paths.ts";
+import { claudeArgvForMode, codexArgvForMode, type ClaudePermissionMode } from "./modes.ts";
+import { loadRelayConfig, type RelayWorker } from "./config.ts";
+import {
+  createEntry,
+  readEntry,
+  touchEntry,
+  withSessionLock,
+  type RelayRegistryEntry,
+} from "./registry.ts";
+import { getTmux } from "./tmux.ts";
+import { clearTurnDoneMarker } from "./markers.ts";
+
+export const RELAY_SESSION_ENV = "TOKENMAXXING_RELAY_SESSION";
+
+function shellQuote(input: { value: string }): string {
+  return `'${input.value.replaceAll("'", `'\\''`)}'`;
+}
+
+export function buildWorkerCommand(input: {
+  sessionId: string;
+  worker: RelayWorker;
+  permissionMode: ClaudePermissionMode;
+  binDir?: string;
+}): string {
+  const binDir = input.binDir ?? paths.binDir;
+  // Keep $PATH expandable: only quote the binDir segment.
+  const envPrefix = `TOKENMAXXING_RELAY_SESSION=${shellQuote({ value: input.sessionId })} PATH=${shellQuote({ value: binDir })}:"$PATH"`;
+  if (input.worker === "claude") {
+    const modeArgs = claudeArgvForMode({ mode: input.permissionMode }).map((a) => shellQuote({ value: a })).join(" ");
+    // Interactive durable session pinned to the relay UUID as Claude session id.
+    return `${envPrefix} claude --session-id ${shellQuote({ value: input.sessionId })} ${modeArgs}`;
+  }
+  const modeArgs = codexArgvForMode({ mode: input.permissionMode }).map((a) => shellQuote({ value: a })).join(" ");
+  return `${envPrefix} codex ${modeArgs}`;
+}
+
+export async function ensureSession(input: {
+  sessionId?: string;
+  worker?: RelayWorker;
+  permissionMode?: ClaudePermissionMode;
+  cwd: string;
+  now?: number;
+}): Promise<RelayRegistryEntry> {
+  const cfg = loadRelayConfig();
+  const sessionId = input.sessionId ?? crypto.randomUUID();
+  const worker = input.worker ?? cfg.defaultWorker;
+  const permissionMode = input.permissionMode ?? cfg.defaultPermissionMode;
+
+  return withSessionLock({
+    sessionId,
+    fn: () => {
+      const existing = readEntry({ sessionId });
+      const tmux = getTmux();
+      if (existing != null) {
+        if (!tmux.hasSession({ name: existing.tmuxName })) {
+          const command = buildWorkerCommand({
+            sessionId,
+            worker: existing.worker,
+            permissionMode: input.permissionMode ?? existing.permissionMode,
+          });
+          tmux.newSession({ name: existing.tmuxName, cwd: existing.cwd, command });
+        }
+        return touchEntry({
+          sessionId,
+          permissionMode: input.permissionMode,
+          state: "idle",
+          now: input.now,
+        });
+      }
+      const entry = createEntry({
+        sessionId,
+        worker,
+        permissionMode,
+        cwd: input.cwd,
+        now: input.now,
+      });
+      const command = buildWorkerCommand({ sessionId, worker, permissionMode });
+      tmux.newSession({ name: entry.tmuxName, cwd: input.cwd, command });
+      return entry;
+    },
+  });
+}
+
+export async function sendPrompt(input: {
+  sessionId: string;
+  prompt: string;
+}): Promise<void> {
+  await withSessionLock({
+    sessionId: input.sessionId,
+    fn: () => {
+      const entry = readEntry({ sessionId: input.sessionId });
+      if (entry == null) throw new Error(`relay session not found: ${input.sessionId}`);
+      clearTurnDoneMarker({ sessionId: input.sessionId });
+      getTmux().sendKeys({ name: entry.tmuxName, text: input.prompt, enter: true });
+      touchEntry({ sessionId: input.sessionId, state: "running" });
+    },
+  });
+}
+
+export async function setLivePermissionMode(input: {
+  sessionId: string;
+  permissionMode: ClaudePermissionMode;
+}): Promise<RelayRegistryEntry> {
+  return withSessionLock({
+    sessionId: input.sessionId,
+    fn: () => {
+      const entry = readEntry({ sessionId: input.sessionId });
+      if (entry == null) throw new Error(`relay session not found: ${input.sessionId}`);
+      // Best-effort: cycle Claude's Shift+Tab equivalent via a slash command when
+      // the worker is Claude. Codex needs a respawn for sandbox changes.
+      if (entry.worker === "claude" && getTmux().hasSession({ name: entry.tmuxName })) {
+        getTmux().sendKeys({
+          name: entry.tmuxName,
+          text: `/permissions ${input.permissionMode}`,
+          enter: true,
+        });
+      } else if (entry.worker === "codex") {
+        getTmux().killSession({ name: entry.tmuxName });
+        const command = buildWorkerCommand({
+          sessionId: input.sessionId,
+          worker: "codex",
+          permissionMode: input.permissionMode,
+        });
+        getTmux().newSession({ name: entry.tmuxName, cwd: entry.cwd, command });
+      }
+      return touchEntry({
+        sessionId: input.sessionId,
+        permissionMode: input.permissionMode,
+      });
+    },
+  });
+}
+
+export function workerBinHint(): string {
+  return join(paths.binDir, "claude");
+}

package/src/main.ts

@@ -27,6 +27,8 @@ import { cmdRename } from "./cli/rename.ts";
 import { cmdSwitch } from "./cli/switch.ts";
 import { cmdCheck } from "./cli/check.ts";
 import { cmdConfig } from "./cli/config.ts";
+import { cmdRelay } from "./cli/relay.ts";
+import { runRelayPermissionHook } from "./entries/relaypermission.ts";
 import { timerDeactivationHint, uninstallSupervisor } from "./lib/install.ts";
 import { c } from "./cli/render.ts";
 
@@ -47,6 +49,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing status --force")}  ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh; ${c.cyan("xx --force")} works too
   ${c.cyan("tokenmaxxing watch")} [seconds]  live status: re-render every N seconds (default 120, never pings)
   ${c.cyan("tokenmaxxing config")} [get|set|unset|tidy]  inspect and edit config.json (bare = effective config with sources)
+  ${c.cyan("tokenmaxxing relay")} …  durable tmux relay for host agents (turn/decide/status/…); see ${c.cyan("relay --help")}
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
   ${c.cyan("tokenmaxxing rename")} [--codex] <sel> <label>
   ${c.cyan("tokenmaxxing rm")} [--codex] <sel>
@@ -100,11 +103,13 @@ async function main(): Promise<number> {
     case "__stop-hook": return runStopHook();
     case "__session-start": return runSessionStart();
     case "__codex-stop-hook": return runCodexStopHook();
+    case "__relay-permission-hook": return runRelayPermissionHook();
     case undefined: return cmdStatus(); // bare `tokenmaxxing` / `xx` → status
     case "--force": return cmdStatus(true); // bare `xx --force` → status --force
     // --codex accepted anywhere, like init/add/status: the old args[1]-only
     // check made `xx switch <sel> --codex` silently run a real CLAUDE swap
     // (one email can hold both pools' accounts - closing-review catch).
+    case "relay": return cmdRelay(args.slice(1));
     case "switch": {
       const rest = args.slice(1).filter((a) => a !== "--codex");
       return args.includes("--codex") ? cmdCodexSwitch(rest[0]) : cmdSwitch(rest[0]);