@prohost/cli 0.16.3 → 0.16.5

package/dist/codehost/ready.js

@@ -9,7 +9,7 @@
  * up or about to be drawn, and an Enter would answer it. The mark is a file,
  * so it outlives a daemon restart.
  */
-import { closeSync, openSync, readdirSync, readSync, realpathSync, statSync } from 'node:fs';
+import { closeSync, openSync, readdirSync, readSync, realpathSync, rmSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { codeHostDir, writePrivateJson } from './settings.js';
 import { isValidId } from './tmux.js';
@@ -35,6 +35,21 @@ export function markReady(terminalId, env = process.env) {
         return false;
     }
 }
+/**
+ * Forget the mark: the window's Claude Code was replaced (a restart), and the new one is past its
+ * dialog only once its own first hook runs. Returns whether no mark is left.
+ */
+export function clearReady(terminalId, env = process.env) {
+    if (!isValidId(terminalId))
+        return false;
+    try {
+        rmSync(readyPath(terminalId, env), { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /** How much of a transcript is read looking for its folder (its first entries carry `cwd`). */
 const TRANSCRIPT_HEAD_BYTES = 256 * 1024;
 /**
@@ -48,22 +63,39 @@ const TRANSCRIPT_HEAD_BYTES = 256 * 1024;
  * owns, that this window's Claude Code got past its dialog. Used only for a window an older build
  * started, which never had a ready mark.
  */
-export function claudeSessionSince(cwd, configDir, sinceMs) {
-    let real;
+/** Claude Code's transcripts dir for `cwd` under `configDir` (`projects/<dash-encoded real path>`), or `undefined`. */
+function projectDir(cwd, configDir) {
     try {
-        real = realpathSync(cwd);
+        const real = realpathSync(cwd);
+        return { real, dir: path.join(configDir, 'projects', real.replace(/[^a-zA-Z0-9]/g, '-')) };
     }
     catch {
-        return false;
+        return undefined;
     }
-    const dir = path.join(configDir, 'projects', real.replace(/[^a-zA-Z0-9]/g, '-'));
-    let names;
+}
+/**
+ * The transcript files (`<session>.jsonl`) Claude Code keeps for `cwd` under `configDir`: one exists
+ * for a session only once its first prompt ran. Empty when there are none or they can't be read.
+ */
+export function claudeTranscripts(cwd, configDir) {
+    const project = projectDir(cwd, configDir);
+    if (!project)
+        return [];
     try {
-        names = readdirSync(dir).filter((name) => name.endsWith('.jsonl'));
+        return readdirSync(project.dir).filter((name) => name.endsWith('.jsonl'));
     }
     catch {
-        return false;
+        return [];
     }
+}
+export function claudeSessionSince(cwd, configDir, sinceMs) {
+    const project = projectDir(cwd, configDir);
+    if (!project)
+        return false;
+    const { real, dir } = project;
+    const names = claudeTranscripts(cwd, configDir);
+    if (names.length === 0)
+        return false;
     return names.some((name) => {
         const file = path.join(dir, name);
         let fd;

package/dist/codehost/session.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Which agent session a terminal's window runs, and on which login: Claude Code's `session_id`
+ * (every hook's input) or Codex's `thread-id` (its `notify` payload), with the window's
+ * `CLAUDE_CONFIG_DIR` / `CODEX_HOME` (`null`: the agent's default login), written by the window's own
+ * hooks to `<state>/<terminal>.session`. A restart (`CodeTerminals.restart`) resumes exactly that
+ * session on that login: a folder thread runs in place in a folder of the owner's, where other
+ * sessions of the same agent may be newer, so "the folder's latest" is not this terminal's.
+ */
+/** What a recorded id may be: a UUID or a similar token, never anything a shell would read. */
+export declare const SESSION_ID_PATTERN: RegExp;
+export interface RecordedSession {
+    id: string;
+    /** The login's config dir the session lives under; `null` for the agent's default. */
+    login: string | null;
+}
+export declare function sessionPath(terminalId: string, env?: NodeJS.ProcessEnv): string;
+/** The login dir an agent's window runs on, from its environment (`null`: the default login). */
+export declare function loginOf(agent: string, env: NodeJS.ProcessEnv): string | null;
+/** The session the terminal's agent last reported, or `undefined`. */
+export declare function readSession(terminalId: string, env?: NodeJS.ProcessEnv): RecordedSession | undefined;
+/**
+ * Record `sessionId` for the terminal, on the login its hook's environment names (best effort: a hook
+ * never fails for it). `env` is the hook's own environment, which its window gave it.
+ */
+export declare function recordSession(terminalId: string | undefined, agent: string, sessionId: unknown, env?: NodeJS.ProcessEnv): void;

package/dist/codehost/session.js

@@ -0,0 +1,61 @@
+/**
+ * Which agent session a terminal's window runs, and on which login: Claude Code's `session_id`
+ * (every hook's input) or Codex's `thread-id` (its `notify` payload), with the window's
+ * `CLAUDE_CONFIG_DIR` / `CODEX_HOME` (`null`: the agent's default login), written by the window's own
+ * hooks to `<state>/<terminal>.session`. A restart (`CodeTerminals.restart`) resumes exactly that
+ * session on that login: a folder thread runs in place in a folder of the owner's, where other
+ * sessions of the same agent may be newer, so "the folder's latest" is not this terminal's.
+ */
+import { readFileSync, renameSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { codeHostDir, ensurePrivateDir } from './settings.js';
+import { isValidId } from './tmux.js';
+/** What a recorded id may be: a UUID or a similar token, never anything a shell would read. */
+export const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{8,128}$/;
+export function sessionPath(terminalId, env = process.env) {
+    if (!isValidId(terminalId))
+        throw new Error('invalid terminal id');
+    return path.join(codeHostDir(env), 'state', `${terminalId}.session`);
+}
+/** The login dir an agent's window runs on, from its environment (`null`: the default login). */
+export function loginOf(agent, env) {
+    const value = agent === 'codex' ? env.CODEX_HOME : env.CLAUDE_CONFIG_DIR;
+    return value?.trim() ? path.resolve(value.trim()) : null;
+}
+/** The session the terminal's agent last reported, or `undefined`. */
+export function readSession(terminalId, env = process.env) {
+    if (!isValidId(terminalId))
+        return undefined;
+    try {
+        const raw = JSON.parse(readFileSync(sessionPath(terminalId, env), 'utf8'));
+        if (typeof raw.id !== 'string' || !SESSION_ID_PATTERN.test(raw.id))
+            return undefined;
+        return { id: raw.id, login: typeof raw.login === 'string' && raw.login ? raw.login : null };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Record `sessionId` for the terminal, on the login its hook's environment names (best effort: a hook
+ * never fails for it). `env` is the hook's own environment, which its window gave it.
+ */
+export function recordSession(terminalId, agent, sessionId, env = process.env) {
+    if (!isValidId(terminalId) || typeof sessionId !== 'string' || !SESSION_ID_PATTERN.test(sessionId))
+        return;
+    const next = { id: sessionId, login: loginOf(agent, env) };
+    try {
+        const current = readSession(terminalId, env);
+        if (current?.id === next.id && current.login === next.login)
+            return;
+        const file = sessionPath(terminalId, env);
+        ensurePrivateDir(path.dirname(file));
+        // A temp file and a rename: a restart never reads half a record.
+        const temp = `${file}.${process.pid}.tmp`;
+        writeFileSync(temp, JSON.stringify(next), { mode: 0o600 });
+        renameSync(temp, file);
+    }
+    catch {
+        /* the restart then says it can't tell which session */
+    }
+}

package/dist/codehost/terminals.d.ts

@@ -33,6 +33,8 @@ export type CodeAgent = (typeof CODE_AGENTS)[number];
 export declare const GOAL_ENV = "PROHOST_CODE_THREAD_GOAL";
 /** Window option set when the agent exits and its window becomes a shell. */
 export declare const EXITED_OPTION = "@prohost_exited";
+/** Window option a relaunched pane stamps with its relaunch's token (`CodeTerminals.restart`). */
+export declare const RELAUNCH_OPTION = "@prohost_relaunch";
 /**
  * Window option that marks a relayed reply as possibly sitting in the agent's
  * input unsubmitted. It is set before the reply's first keystroke reaches the
@@ -101,7 +103,7 @@ export interface TypingOutcome {
      * `shell_window`: the thread's window is a shell (a shell thread, or an agent that exited into
      * one), which composer text is never typed into: it would run as a command.
      */
-    refused?: 'remote_terminal_disabled' | 'reply_interrupted' | 'terminal_gone' | 'trust_prompt' | 'shell_window';
+    refused?: 'remote_terminal_disabled' | 'reply_interrupted' | 'terminal_gone' | 'trust_prompt' | 'shell_window' | 'session_unknown' | 'login_changed' | 'login_unavailable' | 'restart_expired';
     /**
      * Nothing reached the pane, and the failure was local and may pass (a tmux
      * command failed): the delivery is worth sending again, not handing back.
@@ -113,6 +115,53 @@ export interface InputRequest {
     terminalId: string;
     text: string;
 }
+/** What a restart that found no conversation to resume says on its thread. */
+export declare function freshConversationNote(agent: CodeAgent): string;
+/** What a restart's caller ties to it (`CodeHost.handleRestart`: its delivery ledger). */
+export interface RestartHooks {
+    /**
+     * Called right before the relaunch, past every refusal; `false`: an earlier attempt has this one;
+     * `'unsaved'`: the claim could not be recorded, so nothing is touched and it is retried later.
+     */
+    claim?: () => boolean | 'unsaved';
+    /** Called once the window is seen running the new process. */
+    confirmed?: () => void;
+}
+/** What a restart says back beyond {@link TypingOutcome}. */
+export interface RestartOutcome extends Omit<TypingOutcome, 'refused'> {
+    refused?: NonNullable<TypingOutcome['refused']> | 'restart_unconfirmed' | 'agent_exited';
+    /** Its delivery was claimed by an earlier attempt: answered as that one was. */
+    repeat?: boolean;
+    /** Claimed, then nothing was replaced (a clean tmux failure): the claim goes, so it runs when sent again. */
+    release?: boolean;
+}
+/** Whether a pane's current command is a shell (a login shell's `-zsh` too). */
+export declare function isShellCommand(command: string): boolean;
+/**
+ * How long a relaunched agent is watched for quitting at once before its restart is confirmed: a
+ * missing binary or a failed resume exits within a second or two.
+ */
+export declare const RESTART_SETTLE_POLLS = 6;
+/** How long a relaunched pane may take to stamp its token (wall clock, from the relaunch). */
+export declare const RESTART_STAMP_WAIT_MS = 10000;
+export declare const RESTART_SETTLE_POLL_MS = 500;
+/** How many times a restart's `stop` is posted, and the first pause between tries (doubling). */
+export declare const RESTART_STOP_ATTEMPTS = 3;
+export declare const RESTART_STOP_BACKOFF_MS = 500;
+/** Then, in the background, this many more rounds, the n-th after n × the pause. */
+export declare const RESTART_STOP_LATER_ATTEMPTS = 4;
+export declare const RESTART_STOP_LATER_PAUSE_MS = 15000;
+/** How old a restart may be when it reaches this Mac (the server's `RESTART_MAX_AGE`). */
+export declare const RESTART_MAX_AGE_MS: number;
+/** `code_thread.restart_requested`: relaunch the thread's agent, continuing its conversation. */
+export interface RestartRequest {
+    codeThreadId: string;
+    terminalId: string;
+    /** When the owner asked (server clock): refused past {@link RESTART_MAX_AGE_MS}. Absent: never stale. */
+    requestedAtMs?: number;
+    /** Relaunched without its permission prompts (only an explicit `true`; see {@link agentCommandLine}). */
+    skipPermissions: boolean;
+}
 export interface ApprovalRequest {
     codeThreadId: string;
     terminalId: string;
@@ -190,6 +239,13 @@ export declare const CLAUDE_SKIP_PERMISSIONS_FLAG = "--dangerously-skip-permissi
  * `-a never` alone would keep the sandbox, where a command needing the network fails instead of asking.
  */
 export declare const CODEX_SKIP_PERMISSIONS_FLAG = "--dangerously-bypass-approvals-and-sandbox";
+/** Claude Code's (`claude --help`, 2.1.318): "Continue the most recent conversation in the current directory". */
+export declare const CLAUDE_CONTINUE_FLAG = "--continue";
+/**
+ * Codex's (`codex resume --help`, 0.146): the most recent session without the picker, filtered to
+ * the current folder (`--all` would lift that). Its own options (`-c`, the skip flag) follow it.
+ */
+export declare const CODEX_RESUME_ARGS = "resume --last";
 /** The shell command line a thread's agent window runs. */
 export declare function agentCommandLine(agent: CodeAgent, options: {
     claudeSettings: string;
@@ -205,6 +261,13 @@ export declare function agentCommandLine(agent: CodeAgent, options: {
     hasGoal: boolean;
     /** Start the agent without its permission prompts (a shell has none). */
     skipPermissions?: boolean;
+    /**
+     * Continue a conversation instead of starting one (a restart: {@link CodeTerminals.restart}):
+     * a session id resumes exactly it (Claude Code `--resume <id>`, Codex `resume <id>`); `'latest'`
+     * the window folder's most recent one (`--continue`, `resume --last`), only for a folder that
+     * is the thread's own. Never with a goal.
+     */
+    resume?: string;
 }): string;
 export interface CodeTerminalsOptions {
     /** `$PROHOST_HOME` for this host; exported to every window. */
@@ -296,6 +359,10 @@ export declare class CodeTerminals {
     /** Per terminal: the tail of its typing queue (see {@link serialize}). */
     private readonly typing;
     private openPtys;
+    /** The last `adopt` look timed out (`TmuxResult.uncertain`): records were kept, not re-read. */
+    private lastListUncertain;
+    /** Each agent window's pane process at the last `adopt`: a restart is confirmed by its changing. */
+    private panePids;
     /** Who sizes each window, and what its viewers are told (`sizing.ts`). */
     readonly sizing: TerminalSizing;
     private readonly log;
@@ -378,6 +445,57 @@ export declare class CodeTerminals {
      * reply types: the ready mark does.
      */
     private watchTrustPrompt;
+    /**
+     * Relaunch a thread's Claude Code or Codex in its own window and folder, continuing its
+     * conversation (`code_thread.restart_requested`): the process in the agent window is replaced
+     * (`respawn-pane -k`), so the window, its viewers and its size stay. Run with
+     * {@link RestartRequest.skipPermissions}, it no longer asks before running commands, as a start
+     * that skips prompts (the same flags and `--settings` documents). Whatever the old one was doing
+     * stops: the person asked for that, from the thread they own.
+     *
+     * It resumes the session the window's hooks recorded (`session.ts`); a worktree of the thread's
+     * own may fall back to its latest session.
+     *
+     * Refused (nothing is touched, the server says so on the thread) with remote control off
+     * (`remote_terminal_disabled`: as for a start, nothing from ProhostAI starts an agent that runs
+     * commands unasked then), for a thread whose window is gone (`terminal_gone`), for a shell
+     * thread (`shell_window`), or while its session isn't known in a folder it shares
+     * (`session_unknown`). An agent that exited into its shell is relaunched all the same.
+     * Serialized with the thread's replies, so it never lands between a paste and its Enter.
+     */
+    restart(request: RestartRequest, outcome?: RestartOutcome, hooks?: RestartHooks): Promise<boolean>;
+    /** Once every typing job and restart already queued for the terminal has finished (never rejects). */
+    settled(terminalId: string): Promise<void>;
+    /** The agent window's pane process as tmux says now; `undefined` when it didn't answer or has none. */
+    private panePidNow;
+    /** Whether the thread's folder is a worktree this host made for threads (never one of the owner's own). */
+    private ownsFolder;
+    private restartNow;
+    /**
+     * Whether a just-relaunched agent quits within a moment. First waits (until {@link RESTART_STAMP_WAIT_MS}
+     * have passed) for the window to carry this relaunch's `token` ({@link RELAUNCH_OPTION}, stamped by the new
+     * process's own pane after it lifted the old exited mark); only then is {@link EXITED_OPTION} read as
+     * the new agent's, over {@link RESTART_SETTLE_POLLS} more looks from that moment. `exited` only when that mark and the pane running a shell (`#{pane_current_command}`)
+     * agree; `running` only when the token was seen and the last look was answered without the mark;
+     * anything else (never seen, a look unanswered, the signals disagreeing) is `unclear`.
+     */
+    private exitsAtOnce;
+    /**
+     * The restart's `stop` (the person's turn), tried {@link RESTART_STOP_ATTEMPTS} times with a
+     * growing pause: whether ProhostAI took it (2xx). A restart is acknowledged done only after that.
+     */
+    private postRestartStop;
+    /** The same `stop`, sent again a few times over a few minutes, in the background; never throws. */
+    private postRestartStopLater;
+    /**
+     * What a restart resumes (`agentCommandLine`'s `resume`): the recorded session when its
+     * conversation exists; `'latest'` in a worktree of the thread's own; `undefined` (a fresh start)
+     * when there is no conversation yet; `null` when it can't be told (a folder of the owner's, its
+     * session never reported). Claude Code writes a session's transcript only once its first prompt
+     * runs (`ready.ts`), so a session id from `SessionStart` alone has nothing to resume. Codex reports
+     * its id only after a turn (`notify`), so a recorded one has.
+     */
+    private resumeTarget;
     private known;
     /**
      * Whether the thread's agent window runs an agent that composer text and