@xfey/tutti 0.1.93 → 0.1.95

package/dist/providers/openai/app-server/read-only-procedure.js

@@ -128,7 +128,7 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
     }
     const model = options.defaultModel ?? DEFAULT_OPENAI_MODEL;
     const tempRoot = mkdtempSync(join(tmpdir(), "tutti-codex-readonly-procedure-"));
-    const codexHome = join(tempRoot, "codex-home");
+    const codexHome = options.session?.codexHome ?? join(tempRoot, "codex-home");
     mkdirSync(codexHome, { recursive: true, mode: 0o700 });
     const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     const turnTimeoutMs = options.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS;
@@ -210,21 +210,40 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
         if (!isApiKeyAccount(loginResponse)) {
             throw new CodexAppServerReadOnlyProcedureError("auth_failed", "Codex app-server did not accept API key auth.");
         }
-        const threadStartResponse = await client.request("thread/start", {
-            cwd: appServerCwd,
-            model,
-            modelProvider,
-            approvalPolicy: "never",
-            sandbox: "read-only",
-            config: buildReadOnlyThreadConfig(options),
-            ephemeral: true,
-            experimentalRawEvents: false,
-            persistExtendedHistory: false,
-        }, requestTimeoutMs);
-        const threadId = readThreadId(threadStartResponse);
+        let threadId;
+        if (options.session?.threadId === undefined) {
+            const threadStartResponse = await client.request("thread/start", {
+                cwd: appServerCwd,
+                model,
+                modelProvider,
+                approvalPolicy: "never",
+                sandbox: "read-only",
+                config: buildReadOnlyThreadConfig(options),
+                ephemeral: options.session === undefined,
+                experimentalRawEvents: false,
+                persistExtendedHistory: false,
+            }, requestTimeoutMs);
+            threadId = readThreadId(threadStartResponse);
+        }
+        else {
+            if (options.session.unarchive === true) {
+                await client.request("thread/unarchive", { threadId: options.session.threadId }, requestTimeoutMs);
+            }
+            const threadResumeResponse = await client.request("thread/resume", {
+                threadId: options.session.threadId,
+                cwd: appServerCwd,
+                model,
+                modelProvider,
+                approvalPolicy: "never",
+                sandbox: "read-only",
+                config: buildReadOnlyThreadConfig(options),
+            }, requestTimeoutMs);
+            threadId = readThreadId(threadResumeResponse) ?? options.session.threadId;
+        }
         if (threadId === null) {
             throw new CodexAppServerReadOnlyProcedureError("thread_start_failed", "Codex app-server did not return a thread id.");
         }
+        await options.session?.onThreadReady?.(threadId);
         await client.request("turn/start", {
             threadId,
             input: buildCodexAppServerTurnInput({
@@ -308,8 +327,18 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
             throw new CodexAppServerReadOnlyProcedureError("secret_leak_detected", "Codex app-server output contained a sensitive runtime value.");
         }
         const usage = extractCodexAppServerTokenUsage(client.notifications);
+        if (options.session?.archiveAfterTurn?.(parsed) === true) {
+            try {
+                await client.request("thread/archive", { threadId }, requestTimeoutMs);
+                await options.session.onThreadArchived?.();
+            }
+            catch {
+                await options.session.onThreadArchiveFailure?.();
+            }
+        }
         procedureResult = {
             output: parsed,
+            thread_id: threadId,
             model,
             turn_status: "completed",
             notification_count: client.notifications.length,

package/dist/providers/openai/app-server/session-store.d.ts

@@ -0,0 +1,74 @@
+import type { ActivityRef, ProjectId, TaskId } from "@tutti/shared/ids";
+export type CodexSessionLifecycle = "active" | "archived" | "incompatible";
+export type CodexSessionKind = "formal_task_run" | "task_compile" | "project_context_bootstrap" | "context_sync";
+export type CodexSessionMetadata = {
+    version: 1;
+    session_ref: string;
+    kind: CodexSessionKind;
+    owner_ref: string;
+    thread_id?: string;
+    codex_version: string;
+    model: string;
+    provider_fingerprint: string;
+    lifecycle: CodexSessionLifecycle;
+    created_at: string;
+    last_used_at: string;
+};
+export type CodexDurableSession = {
+    root: string;
+    codexHome: string;
+    metadataPath: string;
+    metadata: CodexSessionMetadata;
+    disposition: "created" | "resumed" | "replaced_incompatible";
+};
+export type CodexTaskSession = CodexDurableSession;
+export type CodexTaskSessionCompatibility = {
+    codexVersion: string;
+    model: string;
+    providerFingerprint: string;
+};
+export declare function createProviderFingerprint(input: {
+    providerKind: "openai";
+    apiBaseUrl?: string;
+}): string;
+export declare function openCodexDurableSession(input: {
+    tuttiHome: string;
+    projectId: ProjectId;
+    kind: CodexSessionKind;
+    ownerRef: string;
+    compatibility: CodexTaskSessionCompatibility;
+    now?: Date;
+}): CodexDurableSession;
+export declare function openCodexTaskSession(input: {
+    tuttiHome: string;
+    projectId: ProjectId;
+    taskId: TaskId;
+    compatibility: CodexTaskSessionCompatibility;
+    now?: Date;
+}): CodexTaskSession;
+export type CodexSessionRecoveryEvidence = {
+    version: 1;
+    owner_activity_ref: ActivityRef;
+    updated_at: string;
+    truncated: boolean;
+    evidence: Record<string, unknown>;
+};
+export declare function writeCodexSessionRecoveryEvidence(input: {
+    session: CodexDurableSession;
+    ownerActivityRef: ActivityRef;
+    evidence: Record<string, unknown>;
+    now?: Date;
+}): CodexSessionRecoveryEvidence;
+export declare function readCodexSessionRecoveryEvidence(session: CodexDurableSession): CodexSessionRecoveryEvidence | null;
+export declare function updateCodexTaskSession(session: CodexDurableSession, update: (metadata: CodexSessionMetadata) => CodexSessionMetadata): CodexDurableSession;
+export declare function recordCodexTaskSessionThread(session: CodexDurableSession, threadId: string, now?: Date): CodexDurableSession;
+export declare function markCodexTaskSessionArchived(session: CodexDurableSession, now?: Date): CodexDurableSession;
+export type CodexSessionArchiveIncident = {
+    version: 1;
+    kind: "thread_archive_failed";
+    occurred_at: string;
+};
+export declare function recordCodexSessionArchiveFailure(session: CodexDurableSession, now?: Date): CodexSessionArchiveIncident;
+export declare function readCodexSessionArchiveIncident(session: CodexDurableSession): CodexSessionArchiveIncident | null;
+export declare function acquireCodexTaskSessionLock(session: CodexDurableSession): () => void;
+//# sourceMappingURL=session-store.d.ts.map

package/dist/providers/openai/app-server/session-store.js

@@ -0,0 +1,305 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, openSync, closeSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+const SESSION_METADATA_FILE = "metadata.json";
+const SESSION_RECOVERY_EVIDENCE_FILE = "recovery-evidence.json";
+const SESSION_ARCHIVE_INCIDENT_FILE = "archive-incident.json";
+const SESSION_CODEX_HOME_DIRECTORY = "codex-home";
+const SESSION_LOCK_FILE = ".turn.lock";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function ensurePrivateDirectory(path) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    chmodSync(path, 0o700);
+}
+function writePrivateJson(path, value) {
+    ensurePrivateDirectory(dirname(path));
+    const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    chmodSync(temporaryPath, 0o600);
+    renameSync(temporaryPath, path);
+    chmodSync(path, 0o600);
+}
+function readJson(path) {
+    if (!existsSync(path)) {
+        return null;
+    }
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function parseMetadata(value) {
+    if (!isRecord(value) ||
+        value.version !== 1 ||
+        typeof value.session_ref !== "string" ||
+        (value.kind !== "formal_task_run" &&
+            value.kind !== "task_compile" &&
+            value.kind !== "project_context_bootstrap" &&
+            value.kind !== "context_sync") ||
+        typeof value.owner_ref !== "string" ||
+        (value.thread_id !== undefined && typeof value.thread_id !== "string") ||
+        typeof value.codex_version !== "string" ||
+        typeof value.model !== "string" ||
+        typeof value.provider_fingerprint !== "string" ||
+        (value.lifecycle !== "active" &&
+            value.lifecycle !== "archived" &&
+            value.lifecycle !== "incompatible") ||
+        typeof value.created_at !== "string" ||
+        typeof value.last_used_at !== "string") {
+        return null;
+    }
+    return value;
+}
+function codexSessionsRoot(tuttiHome, projectId) {
+    return join(tuttiHome, "projects", projectId, "codex-sessions");
+}
+function ownerIndexPath(tuttiHome, projectId, kind, ownerRef) {
+    return kind === "formal_task_run"
+        ? join(codexSessionsRoot(tuttiHome, projectId), "task-index", `${ownerRef}.json`)
+        : join(codexSessionsRoot(tuttiHome, projectId), "procedure-index", kind, `${ownerRef}.json`);
+}
+function sessionRoot(tuttiHome, projectId, sessionRef) {
+    return join(codexSessionsRoot(tuttiHome, projectId), sessionRef);
+}
+function compatible(metadata, expected) {
+    return (metadata.lifecycle !== "incompatible" &&
+        metadata.codex_version === expected.codexVersion &&
+        metadata.model === expected.model &&
+        metadata.provider_fingerprint === expected.providerFingerprint);
+}
+function createSession(input) {
+    const sessionRef = `codex-session-${randomUUID()}`;
+    const root = sessionRoot(input.tuttiHome, input.projectId, sessionRef);
+    const codexHome = join(root, SESSION_CODEX_HOME_DIRECTORY);
+    ensurePrivateDirectory(codexSessionsRoot(input.tuttiHome, input.projectId));
+    ensurePrivateDirectory(root);
+    ensurePrivateDirectory(codexHome);
+    const timestamp = input.now.toISOString();
+    const metadata = {
+        version: 1,
+        session_ref: sessionRef,
+        kind: input.kind,
+        owner_ref: input.ownerRef,
+        codex_version: input.compatibility.codexVersion,
+        model: input.compatibility.model,
+        provider_fingerprint: input.compatibility.providerFingerprint,
+        lifecycle: "active",
+        created_at: timestamp,
+        last_used_at: timestamp,
+    };
+    const metadataPath = join(root, SESSION_METADATA_FILE);
+    writePrivateJson(metadataPath, metadata);
+    writePrivateJson(ownerIndexPath(input.tuttiHome, input.projectId, input.kind, input.ownerRef), {
+        version: 1,
+        kind: input.kind,
+        owner_ref: input.ownerRef,
+        session_ref: sessionRef,
+    });
+    return {
+        root,
+        codexHome,
+        metadataPath,
+        metadata,
+        disposition: input.disposition,
+    };
+}
+export function createProviderFingerprint(input) {
+    const canonical = JSON.stringify({
+        provider_kind: input.providerKind,
+        api_base_url: input.apiBaseUrl?.trim() || "https://api.openai.com/v1",
+    });
+    return `sha256:${createHash("sha256").update(canonical, "utf8").digest("hex")}`;
+}
+export function openCodexDurableSession(input) {
+    const now = input.now ?? new Date();
+    const indexValue = readJson(ownerIndexPath(input.tuttiHome, input.projectId, input.kind, input.ownerRef));
+    if (isRecord(indexValue) &&
+        indexValue.version === 1 &&
+        indexValue.kind === input.kind &&
+        indexValue.owner_ref === input.ownerRef &&
+        typeof indexValue.session_ref === "string") {
+        const root = sessionRoot(input.tuttiHome, input.projectId, indexValue.session_ref);
+        const metadataPath = join(root, SESSION_METADATA_FILE);
+        const metadata = parseMetadata(readJson(metadataPath));
+        if (metadata !== null &&
+            metadata.kind === input.kind &&
+            metadata.owner_ref === input.ownerRef) {
+            if (compatible(metadata, input.compatibility)) {
+                ensurePrivateDirectory(root);
+                const codexHome = join(root, SESSION_CODEX_HOME_DIRECTORY);
+                ensurePrivateDirectory(codexHome);
+                const updatedMetadata = {
+                    ...metadata,
+                    last_used_at: now.toISOString(),
+                };
+                writePrivateJson(metadataPath, updatedMetadata);
+                return {
+                    root,
+                    codexHome,
+                    metadataPath,
+                    metadata: updatedMetadata,
+                    disposition: "resumed",
+                };
+            }
+            writePrivateJson(metadataPath, {
+                ...metadata,
+                lifecycle: "incompatible",
+                last_used_at: now.toISOString(),
+            });
+            return createSession({
+                ...input,
+                now,
+                disposition: "replaced_incompatible",
+            });
+        }
+    }
+    return createSession({ ...input, now, disposition: "created" });
+}
+export function openCodexTaskSession(input) {
+    return openCodexDurableSession({
+        tuttiHome: input.tuttiHome,
+        projectId: input.projectId,
+        kind: "formal_task_run",
+        ownerRef: input.taskId,
+        compatibility: input.compatibility,
+        ...(input.now === undefined ? {} : { now: input.now }),
+    });
+}
+const MAX_RECOVERY_EVIDENCE_BYTES = 64 * 1024;
+function recoveryEvidencePath(session) {
+    return join(session.root, SESSION_RECOVERY_EVIDENCE_FILE);
+}
+export function writeCodexSessionRecoveryEvidence(input) {
+    const serialized = JSON.stringify(input.evidence);
+    const exceedsLimit = Buffer.byteLength(serialized, "utf8") > MAX_RECOVERY_EVIDENCE_BYTES;
+    const record = {
+        version: 1,
+        owner_activity_ref: input.ownerActivityRef,
+        updated_at: (input.now ?? new Date()).toISOString(),
+        truncated: exceedsLimit,
+        evidence: exceedsLimit
+            ? {
+                bounded_original_json: Buffer.from(serialized, "utf8")
+                    .subarray(0, MAX_RECOVERY_EVIDENCE_BYTES)
+                    .toString("utf8"),
+                truncation_notice: "Recovery evidence exceeded the machine-local byte limit.",
+            }
+            : input.evidence,
+    };
+    writePrivateJson(recoveryEvidencePath(input.session), record);
+    return record;
+}
+export function readCodexSessionRecoveryEvidence(session) {
+    const value = readJson(recoveryEvidencePath(session));
+    if (!isRecord(value) ||
+        value.version !== 1 ||
+        typeof value.owner_activity_ref !== "string" ||
+        typeof value.updated_at !== "string" ||
+        typeof value.truncated !== "boolean" ||
+        !isRecord(value.evidence)) {
+        return null;
+    }
+    return value;
+}
+export function updateCodexTaskSession(session, update) {
+    const current = parseMetadata(readJson(session.metadataPath));
+    if (current === null || current.session_ref !== session.metadata.session_ref) {
+        throw new Error("Codex task session metadata is unavailable or invalid.");
+    }
+    const next = update(current);
+    if (next.session_ref !== current.session_ref ||
+        next.kind !== current.kind ||
+        next.owner_ref !== current.owner_ref) {
+        throw new Error("Codex task session identity cannot change.");
+    }
+    writePrivateJson(session.metadataPath, next);
+    return { ...session, metadata: next };
+}
+export function recordCodexTaskSessionThread(session, threadId, now = new Date()) {
+    return updateCodexTaskSession(session, (metadata) => {
+        if (metadata.thread_id !== undefined && metadata.thread_id !== threadId) {
+            throw new Error("Codex task session thread identity cannot change.");
+        }
+        return {
+            ...metadata,
+            thread_id: threadId,
+            lifecycle: "active",
+            last_used_at: now.toISOString(),
+        };
+    });
+}
+export function markCodexTaskSessionArchived(session, now = new Date()) {
+    return updateCodexTaskSession(session, (metadata) => ({
+        ...metadata,
+        lifecycle: "archived",
+        last_used_at: now.toISOString(),
+    }));
+}
+export function recordCodexSessionArchiveFailure(session, now = new Date()) {
+    const incident = {
+        version: 1,
+        kind: "thread_archive_failed",
+        occurred_at: now.toISOString(),
+    };
+    writePrivateJson(join(session.root, SESSION_ARCHIVE_INCIDENT_FILE), incident);
+    return incident;
+}
+export function readCodexSessionArchiveIncident(session) {
+    const value = readJson(join(session.root, SESSION_ARCHIVE_INCIDENT_FILE));
+    if (!isRecord(value) ||
+        value.version !== 1 ||
+        value.kind !== "thread_archive_failed" ||
+        typeof value.occurred_at !== "string") {
+        return null;
+    }
+    return value;
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function acquireCodexTaskSessionLock(session) {
+    const lockPath = join(session.root, SESSION_LOCK_FILE);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            const descriptor = openSync(lockPath, "wx", 0o600);
+            writeFileSync(descriptor, `${JSON.stringify({ version: 1, owner_pid: process.pid, created_at: new Date().toISOString() })}\n`, "utf8");
+            closeSync(descriptor);
+            let released = false;
+            return () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                try {
+                    unlinkSync(lockPath);
+                }
+                catch {
+                    // Releasing a process-local safety lock is best effort during shutdown.
+                }
+            };
+        }
+        catch (error) {
+            if (!existsSync(lockPath)) {
+                throw error;
+            }
+            const lockValue = readJson(lockPath);
+            const ownerPid = isRecord(lockValue) && typeof lockValue.owner_pid === "number"
+                ? lockValue.owner_pid
+                : null;
+            if (ownerPid !== null && isProcessAlive(ownerPid)) {
+                throw new Error("Codex task session already has an active turn owner.");
+            }
+            unlinkSync(lockPath);
+        }
+    }
+    throw new Error("Codex task session lock could not be acquired.");
+}
+//# sourceMappingURL=session-store.js.map

package/dist/providers/openai/app-server/workspace-write-run.d.ts

@@ -33,8 +33,18 @@ export type CodexAppServerWorkspaceWriteRunInput<TOutput> = {
     defaultModel?: string;
     workspaceRoot: string;
     prompt: string;
-    outputSchema: unknown;
-    validateOutput: (value: unknown) => value is TOutput;
+    outputSchema?: unknown;
+    validateOutput?: (value: unknown) => value is TOutput;
+    sandboxMode?: "workspace-write" | "read-only";
+    session?: {
+        codexHome: string;
+        threadId?: string;
+        unarchive?: boolean;
+        onThreadReady?: (threadId: string) => void | Promise<void>;
+        archiveAfterTurn?: (output: TOutput) => boolean;
+        onThreadArchived?: () => void | Promise<void>;
+        onThreadArchiveFailure?: () => void | Promise<void>;
+    };
     networkAccess?: boolean;
     webSearchMode?: "disabled" | "cached" | "live";
     approvalPolicy?: CodexAppServerApprovalPolicy;
@@ -63,6 +73,7 @@ export type CodexAppServerWorkspaceWriteRunInput<TOutput> = {
 };
 export type CodexAppServerWorkspaceWriteRunResult<TOutput> = {
     output: TOutput;
+    thread_id: string;
     model: string;
     turn_status: "completed";
     notification_count: number;
@@ -73,6 +84,7 @@ export type CodexAppServerWorkspaceWriteRunResult<TOutput> = {
     usage?: OpenAiTokenUsage;
 };
 export type CodexAppServerWorkspaceWriteRunErrorDetails = {
+    turn_start_state?: "not_started" | "start_requested" | "terminal";
     turn_status?: string;
     turn_error_message?: string;
     turn_error_code?: string;
@@ -83,12 +95,13 @@ export type CodexAppServerWorkspaceWriteRunErrorDetails = {
     server_request_methods?: string[];
     notification_methods?: string[];
     agent_message_excerpt?: string;
+    agent_output?: string;
     stderr_excerpt?: string;
 };
 export declare class CodexAppServerWorkspaceWriteRunError extends Error {
-    readonly code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable";
+    readonly code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable" | "session_unavailable";
     readonly details: CodexAppServerWorkspaceWriteRunErrorDetails;
-    constructor(code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable", message: string, details?: CodexAppServerWorkspaceWriteRunErrorDetails);
+    constructor(code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable" | "session_unavailable", message: string, details?: CodexAppServerWorkspaceWriteRunErrorDetails);
 }
 export declare function runCodexAppServerWorkspaceWriteRun<TOutput>(options: CodexAppServerWorkspaceWriteRunInput<TOutput>): Promise<CodexAppServerWorkspaceWriteRunResult<TOutput>>;
 //# sourceMappingURL=workspace-write-run.d.ts.map