handmux 0.26.0 → 0.27.2

package/dist/src/agents/codexActivationReceipt.js

@@ -0,0 +1,149 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { fsyncDirectorySync, PrivateStateStore } from '../privateStateStore.js';
+import { isSessionUuid } from './scanUtils.js';
+const CODEX_AGENT_ID = 'codex';
+const MAX_RECEIPTS = 128;
+const OPERATION_ID_RE = /^[0-9a-f]{64}$/;
+const PANE_ID_RE = /^%\d+$/;
+const WINDOW_ID_RE = /^@\d+$/;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function validReceipt(value) {
+    if (!isRecord(value) || !isRecord(value.pane) || !isRecord(value.process))
+        return false;
+    const pane = value.pane;
+    const process = value.process;
+    return typeof value.operationId === 'string' && OPERATION_ID_RE.test(value.operationId)
+        && value.agentId === CODEX_AGENT_ID
+        && typeof pane.paneId === 'string' && PANE_ID_RE.test(pane.paneId)
+        && typeof pane.sessionName === 'string' && pane.sessionName.length > 0 && pane.sessionName.length <= 1_024
+        && typeof pane.windowId === 'string' && WINDOW_ID_RE.test(pane.windowId)
+        && typeof pane.tmuxEpoch === 'string' && pane.tmuxEpoch.length > 0 && pane.tmuxEpoch.length <= 1_024
+        && typeof process.pid === 'number' && Number.isSafeInteger(process.pid) && process.pid > 0
+        && typeof process.startedAt === 'number' && Number.isSafeInteger(process.startedAt) && process.startedAt > 0
+        && typeof process.tty === 'string' && process.tty.length > 0 && process.tty.length <= 1_024
+        && typeof process.executable === 'string' && process.executable.length > 0 && process.executable.length <= 8_192
+        && typeof value.sessionId === 'string' && isSessionUuid(value.sessionId)
+        && value.command === `handmux codex resume ${value.sessionId}`
+        && (value.phase === 'prepared' || value.phase === 'interrupted' || value.phase === 'resuming')
+        && typeof value.createdAt === 'number' && Number.isSafeInteger(value.createdAt) && value.createdAt > 0
+        && typeof value.updatedAt === 'number' && Number.isSafeInteger(value.updatedAt)
+        && value.updatedAt >= value.createdAt;
+}
+function parseState(value) {
+    if (value === null)
+        return { version: 1, receipts: [] };
+    if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.receipts)
+        || value.receipts.length > MAX_RECEIPTS || !value.receipts.every(validReceipt)) {
+        throw new Error('Invalid Codex activation recovery state');
+    }
+    return { version: 1, receipts: structuredClone(value.receipts) };
+}
+function operationId(input) {
+    return crypto.createHash('sha256').update(JSON.stringify({
+        agentId: CODEX_AGENT_ID,
+        ...input,
+    })).digest('hex');
+}
+function sameProcess(first, second) {
+    return first.pid === second.pid && first.startedAt === second.startedAt
+        && first.tty === second.tty && first.executable === second.executable;
+}
+export class CodexActivationReceiptStore {
+    #store;
+    #now;
+    #write;
+    #fsyncDirectory;
+    #state;
+    #available = true;
+    constructor(file, { now = Date.now, write, fsyncDirectory = fsyncDirectorySync, } = {}) {
+        this.#store = new PrivateStateStore(file);
+        try {
+            this.#state = parseState(this.#store.readStrict());
+        }
+        catch {
+            this.#state = { version: 1, receipts: [] };
+            this.#available = false;
+        }
+        this.#now = now;
+        this.#write = write ?? ((state) => this.#store.write(state));
+        this.#fsyncDirectory = fsyncDirectory;
+    }
+    list() {
+        this.#assertAvailable();
+        return structuredClone(this.#state.receipts);
+    }
+    latestForPane(paneId) {
+        this.#assertAvailable();
+        return structuredClone([...this.#state.receipts].reverse().find((receipt) => (receipt.pane.paneId === paneId)) ?? null);
+    }
+    get(operationId) {
+        this.#assertAvailable();
+        return structuredClone(this.#state.receipts.find((receipt) => (receipt.operationId === operationId)) ?? null);
+    }
+    prepare(input) {
+        this.#assertAvailable();
+        const id = operationId(input);
+        const existing = this.#state.receipts.find((receipt) => receipt.operationId === id);
+        if (existing)
+            return structuredClone(existing);
+        const now = Math.trunc(this.#now());
+        const receipt = {
+            operationId: id,
+            agentId: CODEX_AGENT_ID,
+            ...structuredClone(input),
+            phase: 'prepared',
+            createdAt: now,
+            updatedAt: now,
+        };
+        if (!validReceipt(receipt))
+            throw new Error('Invalid Codex activation recovery receipt');
+        const next = {
+            version: 1,
+            receipts: [...this.#state.receipts, receipt].slice(-MAX_RECEIPTS),
+        };
+        this.#flush(next);
+        this.#state = next;
+        return structuredClone(receipt);
+    }
+    transition(id, expected, phase) {
+        this.#assertAvailable();
+        const index = this.#state.receipts.findIndex((candidate) => candidate.operationId === id);
+        const receipt = this.#state.receipts[index];
+        const allowed = Array.isArray(expected) ? expected : [expected];
+        if (!receipt || !allowed.includes(receipt.phase)) {
+            throw new Error('Codex activation recovery receipt changed');
+        }
+        if (receipt.phase === phase)
+            return structuredClone(receipt);
+        const updated = { ...receipt, phase, updatedAt: Math.trunc(this.#now()) };
+        const next = {
+            version: 1,
+            receipts: this.#state.receipts.map((candidate, candidateIndex) => (candidateIndex === index ? updated : candidate)),
+        };
+        this.#flush(next);
+        this.#state = next;
+        return structuredClone(updated);
+    }
+    clearManaged(paneId, sessionId, process) {
+        this.#assertAvailable();
+        const receipts = this.#state.receipts.filter((receipt) => !(receipt.pane.paneId === paneId && receipt.sessionId === sessionId
+            && (process === undefined || sameProcess(receipt.process, process))));
+        if (receipts.length === this.#state.receipts.length)
+            return false;
+        const next = { version: 1, receipts };
+        this.#flush(next);
+        this.#state = next;
+        return true;
+    }
+    #flush(next) {
+        this.#write(next);
+        this.#fsyncDirectory(path.dirname(this.#store.file));
+    }
+    #assertAvailable() {
+        if (!this.#available)
+            throw new Error('Codex activation recovery state is unavailable');
+    }
+}

package/dist/src/agents/codexConversation.js

@@ -307,7 +307,16 @@ function itemBase(message, sessionId, id = stableId(message)) {
             ? { correlationId: message.correlationId } : {}),
     };
 }
-function projectDurableMessage(message, sessionId) {
+function compactorItemKey(message) {
+    return typeof message.turnId === 'string' && message.turnId
+        && typeof message.itemId === 'string' && message.itemId
+        ? `${message.turnId}\0${message.itemId}` : null;
+}
+function projectDurableMessage(message, sessionId, suppressedCompactorItems) {
+    const sourceKey = compactorItemKey(message);
+    if (message.type === 'text' && message.role === 'assistant'
+        && sourceKey && suppressedCompactorItems.has(sourceKey))
+        return [];
     if (message.type === 'text' && message.role && typeof message.text === 'string') {
         const output = clipConversationText(message.text);
         return [{
@@ -342,17 +351,15 @@ function projectDurableMessage(message, sessionId) {
         const diffProjection = message.tool.diff === undefined
             ? undefined : sanitizeToolInputWithMetadata(message.tool.diff);
         const safeDiff = diffProjection?.value;
-        const toolProjectionBytes = inputProjection.originalBytes + (diffProjection?.originalBytes ?? 0);
-        const toolProjectionTruncated = inputProjection.truncated || diffProjection?.truncated === true;
         const outcomes = ['running', 'success', 'failed', 'declined', 'completed'];
         const outcome = typeof message.tool.outcome === 'string' && outcomes.includes(message.tool.outcome)
             ? message.tool.outcome : undefined;
         const items = [{
                 ...itemBase(message, sessionId, callId), kind: 'tool_call', callId,
                 name, ...(input === undefined ? {} : { input }),
-                ...(toolProjectionTruncated ? {
+                ...(inputProjection.truncated ? {
                     status: 'truncated',
-                    truncation: { reason: 'size_limit', originalBytes: toolProjectionBytes },
+                    truncation: { reason: 'size_limit', originalBytes: inputProjection.originalBytes },
                 } : {}),
                 extensions: {
                     'conversation.tool': {
@@ -512,6 +519,7 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
     // read at the same byte cutoff as the adapter baseline so later rollout suffixes cannot appear in both
     // the page and the already-buffered native stream.
     const openingSnapshots = new Map();
+    const suppressedCompactorItemsBySession = new Map();
     function cloneCheckpoint(checkpoint) {
         return {
             ...checkpoint,
@@ -520,6 +528,19 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
             snapshot: { ...checkpoint.snapshot, items: [...checkpoint.snapshot.items] },
         };
     }
+    const suppressionKeyOf = (values) => [...values].sort().join('\n');
+    async function readCompactorItemKeys(paneId, sessionId) {
+        const values = new Set((await app.compactorItemKeys(paneId, sessionId)).filter((value) => (typeof value === 'string' && value.includes('\0'))));
+        suppressedCompactorItemsBySession.delete(sessionId);
+        suppressedCompactorItemsBySession.set(sessionId, values);
+        while (suppressedCompactorItemsBySession.size > MAX_DURABLE_CHECKPOINTS) {
+            const oldest = suppressedCompactorItemsBySession.keys().next().value;
+            if (typeof oldest !== 'string')
+                break;
+            suppressedCompactorItemsBySession.delete(oldest);
+        }
+        return values;
+    }
     function rememberCheckpoint(sessionId, checkpoint) {
         durableCheckpoints.delete(sessionId);
         durableCheckpoints.set(sessionId, checkpoint);
@@ -530,17 +551,20 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
             durableCheckpoints.delete(oldest);
         }
     }
-    function snapshotFromMessages(session, parsed, file, version, readerGeneration, changedFrom, checkpoint) {
+    function snapshotFromMessages(session, parsed, file, version, readerGeneration, changedFrom, checkpoint, suppressedCompactorItems) {
+        const suppressionKey = suppressionKeyOf(suppressedCompactorItems);
         const sameReader = readerGeneration === undefined || checkpoint?.readerGeneration === undefined
             || checkpoint.readerGeneration === readerGeneration;
         const reusable = checkpoint?.file === file && sameReader && changedFrom !== null
+            && checkpoint.suppressionKey === suppressionKey
             && changedFrom >= 0 && changedFrom <= checkpoint.messageCount
             && changedFrom <= parsed.length;
         // Build transactionally. A backwards/truncated read must not corrupt the last readable checkpoint
         // before the floor check rejects it.
         const next = reusable && checkpoint ? cloneCheckpoint(checkpoint) : undefined;
         const from = next ? changedFrom : 0;
-        const durableFloor = checkpoint?.snapshot.items.length ?? 0;
+        const durableFloor = checkpoint?.suppressionKey === suppressionKey
+            ? checkpoint.snapshot.items.length : 0;
         const items = next?.snapshot.items ?? [];
         const itemOffsets = next?.itemOffsets ?? [0];
         const historyHashes = next?.historyHashes ?? [];
@@ -550,14 +574,18 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
         historyHashes.length = from;
         let historyHash = historyHashes.at(-1) ?? HISTORY_HASH_SEED;
         for (let index = from; index < parsed.length; index++) {
-            const projected = projectDurableMessage(parsed[index], session.sessionId);
+            const projected = projectDurableMessage(parsed[index], session.sessionId, suppressedCompactorItems);
             items.push(...projected);
             itemOffsets.push(items.length);
-            historyHash = createHash('sha256')
-                .update(historyHash)
-                .update('\0')
-                .update(JSON.stringify(projected))
-                .digest('hex');
+            // A suppressed compactor record is not a visible history revision. Keep the token unchanged until
+            // the parser replaces it with the durable compact marker, avoiding an identical-page refresh.
+            if (projected.length > 0) {
+                historyHash = createHash('sha256')
+                    .update(historyHash)
+                    .update('\0')
+                    .update(JSON.stringify(projected))
+                    .digest('hex');
+            }
             historyHashes.push(historyHash);
         }
         if (items.length < durableFloor) {
@@ -567,6 +595,7 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
             file,
             ...(version === undefined ? {} : { version }),
             ...(readerGeneration === undefined ? {} : { readerGeneration }),
+            suppressionKey,
             messageCount: parsed.length,
             itemOffsets,
             historyHashes,
@@ -578,7 +607,7 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
             },
         };
     }
-    async function readDurableSnapshot(session) {
+    async function readDurableSnapshot(session, suppressionProvider) {
         const file = await findRollout(sessionsRoot, session.sessionId);
         const read = file && reader.readSnapshot
             ? await reader.readSnapshot(file, createCodexTranscriptParser)
@@ -588,8 +617,13 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
                 changedFrom: 0,
                 generation: undefined,
             };
+        const suppressedCompactorItems = suppressionProvider
+            ? await suppressionProvider()
+            : suppressedCompactorItemsBySession.get(session.sessionId) ?? new Set();
+        const suppressionKey = suppressionKeyOf(suppressedCompactorItems);
         const known = durableCheckpoints.get(session.sessionId);
-        if (known && known.file === file && read.version !== undefined && known.version === read.version) {
+        if (known && known.file === file && known.suppressionKey === suppressionKey
+            && read.version !== undefined && known.version === read.version) {
             rememberCheckpoint(session.sessionId, known);
             return known.snapshot;
         }
@@ -603,7 +637,7 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
             rememberCheckpoint(session.sessionId, known);
             return known.snapshot;
         }
-        const checkpoint = snapshotFromMessages(session, read.messages, file, read.version, read.generation, read.changedFrom, known);
+        const checkpoint = snapshotFromMessages(session, read.messages, file, read.version, read.generation, read.changedFrom, known, suppressedCompactorItems);
         rememberCheckpoint(session.sessionId, checkpoint);
         return checkpoint.snapshot;
     }
@@ -616,7 +650,7 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
             ? { file, endExclusive }
             : { file: null, endExclusive: 0 };
     }
-    async function readDurablePrefix(session, cutoff) {
+    async function readDurablePrefix(session, cutoff, suppressionProvider) {
         const known = durableCheckpoints.get(session.sessionId);
         const working = known ? cloneCheckpoint(known) : undefined;
         const read = cutoff.file && reader.readPrefixSnapshot
@@ -628,10 +662,15 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
                 changedFrom: 0,
                 generation: undefined,
             };
+        const suppressedCompactorItems = suppressionProvider
+            ? await suppressionProvider()
+            : suppressedCompactorItemsBySession.get(session.sessionId) ?? new Set();
+        const suppressionKey = suppressionKeyOf(suppressedCompactorItems);
         const checkpoint = working && working.file === cutoff.file
+            && working.suppressionKey === suppressionKey
             && read.version !== undefined && working.version === read.version
             ? working
-            : snapshotFromMessages(session, read.messages, cutoff.file, read.version, read.generation, read.changedFrom, working);
+            : snapshotFromMessages(session, read.messages, cutoff.file, read.version, read.generation, read.changedFrom, working, suppressedCompactorItems);
         return {
             checkpoint,
             snapshot: { ...checkpoint.snapshot, items: [...checkpoint.snapshot.items] },
@@ -751,7 +790,7 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
                     : now - pending.settledAt >= durableSettleTimeoutMs);
                 let page;
                 try {
-                    page = await readDurableSnapshot({ agentId: 'codex', sessionId });
+                    page = await readDurableSnapshot({ agentId: 'codex', sessionId }, () => readCompactorItemKeys(run.ref.paneId, sessionId));
                 }
                 catch (error) {
                     // A writer can transiently rotate or replace the rollout. Periodic reconciliation retries
@@ -1022,7 +1061,7 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
                 // Capture the append-only byte boundary only after the observer owns the native suffix. Anything
                 // appended later belongs to that buffered suffix or the first post-open durable reconciliation.
                 const cutoff = await captureDurableCutoff(sessionId);
-                const openingRead = await readDurablePrefix({ agentId: 'codex', sessionId }, cutoff);
+                const openingRead = await readDurablePrefix({ agentId: 'codex', sessionId }, cutoff, () => readCompactorItemKeys(run.ref.paneId, sessionId));
                 const baseline = openingRead.snapshot;
                 live.durableToken = baseline.sourceHistoryToken;
                 live.durableItems = [...baseline.items];