@xfey/tutti 0.1.78 → 0.1.79

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

@@ -1,3 +1,5 @@
+import { type CodexAppServerLifecycleIncident } from "./invocation-lifecycle.js";
+import { type CodexAppServerInvocationCoordinator, type CodexAppServerInvocationLease } from "./invocation-coordinator.js";
 import { type CodexAppServerRuntimeTelemetryOptions } from "./runtime-telemetry.js";
 import { type CodexAppServerAgentContextRuntime, type CodexAppServerSkillSelectionName } from "./skills.js";
 import { type OpenAiTokenUsage } from "../token-usage.js";
@@ -25,6 +27,10 @@ export type CodexAppServerReadOnlyProcedureInput<TOutput> = {
     turnTimeoutMs?: number;
     baseEnv?: NodeJS.ProcessEnv;
     runtimeTelemetry?: CodexAppServerRuntimeTelemetryOptions;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    /** @internal Set only by the coordinator wrapper. */
+    invocationLease?: CodexAppServerInvocationLease;
 };
 export type CodexAppServerReadOnlyProcedureResult<TOutput> = {
     output: TOutput;
@@ -52,9 +58,9 @@ export type CodexAppServerReadOnlyProcedureErrorDetails = {
     stderr_excerpt?: string;
 };
 export declare class CodexAppServerReadOnlyProcedureError 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" | "write_detected" | "secret_leak_detected";
+    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" | "write_detected" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable";
     readonly details: CodexAppServerReadOnlyProcedureErrorDetails;
-    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" | "write_detected" | "secret_leak_detected", message: string, details?: CodexAppServerReadOnlyProcedureErrorDetails);
+    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" | "write_detected" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable", message: string, details?: CodexAppServerReadOnlyProcedureErrorDetails);
 }
 export declare function resolveReadOnlyWebSearchMode(input: {
     networkAccess?: boolean;

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

@@ -1,10 +1,12 @@
 import { execFileSync, spawn } from "node:child_process";
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { buildCodexAppServerProcessPlan } from "../codex-app-server.js";
 import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
 import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./json-rpc.js";
+import { CodexAppServerInvocation, CodexAppServerLifecycleError, createManagedProcess, } from "./invocation-lifecycle.js";
+import { CodexAppServerAdmissionError, } from "./invocation-coordinator.js";
 import { createCodexAppServerRuntimeObserver, } from "./runtime-telemetry.js";
 import { createReadOnlySandboxPolicy } from "./sandbox-policy.js";
 import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
@@ -76,6 +78,26 @@ export function parseCodexAppServerStructuredJson(text) {
     throw new CodexAppServerReadOnlyProcedureError("output_parse_failed", "Codex app-server returned malformed JSON.");
 }
 export async function runCodexAppServerReadOnlyProcedure(options) {
+    if (options.invocationCoordinator !== undefined && options.invocationLease === undefined) {
+        let lease;
+        try {
+            lease = await options.invocationCoordinator.acquire();
+        }
+        catch (error) {
+            throw new CodexAppServerReadOnlyProcedureError("admission_unavailable", error instanceof CodexAppServerAdmissionError
+                ? error.message
+                : "Codex app-server admission is unavailable.");
+        }
+        try {
+            return await runCodexAppServerReadOnlyProcedure({
+                ...options,
+                invocationLease: lease,
+            });
+        }
+        finally {
+            lease.release();
+        }
+    }
     let skillInputs;
     let contextRuntimeHint;
     try {
@@ -122,11 +144,13 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
         configOverrides: buildCodexAppServerProviderConfigOverrides(options),
         ...(options.codexCommand === undefined ? {} : { codexCommand: options.codexCommand }),
     });
-    const child = spawn(processPlan.command, processPlan.args, {
+    const managedProcess = createManagedProcess(spawn(processPlan.command, processPlan.args, {
         cwd: process.cwd(),
+        detached: process.platform !== "win32",
         env: createCodexSpawnEnv(codexHome, options.baseEnv ?? process.env),
         stdio: "pipe",
-    });
+    }));
+    const child = managedProcess.child;
     const runtimeObserver = options.runtimeTelemetry === undefined
         ? undefined
         : createCodexAppServerRuntimeObserver(options.runtimeTelemetry);
@@ -138,6 +162,15 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
                 onServerRequest: runtimeObserver.serverRequest,
             }),
     });
+    const invocation = new CodexAppServerInvocation({
+        managedProcess,
+        tempRoot,
+        closeProtocol: () => client.close(),
+        ...(options.onLifecycleIncident === undefined
+            ? {}
+            : { onIncident: options.onLifecycleIncident }),
+    });
+    options.invocationLease?.setCloser(() => invocation.close());
     const sensitiveValues = [
         options.apiKey,
         tempRoot,
@@ -155,6 +188,9 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
         options.apiKey,
         ...(contextRuntimeHint?.sensitiveValues ?? []),
     ];
+    let primaryError;
+    let procedureResult;
+    let lifecycleError;
     try {
         await client.request("initialize", {
             clientInfo: {
@@ -272,7 +308,7 @@ 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);
-        return {
+        procedureResult = {
             output: parsed,
             model,
             turn_status: "completed",
@@ -288,18 +324,34 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
     }
     catch (error) {
         if (error instanceof CodexAppServerReadOnlyProcedureError) {
-            throw error;
+            primaryError = error;
         }
-        if (error instanceof CodexAppServerProtocolError) {
-            throw new CodexAppServerReadOnlyProcedureError("app_server_protocol_error", redactWithKnownValues(error.message, sensitiveValues));
+        else if (error instanceof CodexAppServerProtocolError) {
+            primaryError = new CodexAppServerReadOnlyProcedureError("app_server_protocol_error", redactWithKnownValues(error.message, sensitiveValues));
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            primaryError = new CodexAppServerReadOnlyProcedureError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues));
         }
-        const message = error instanceof Error ? error.message : String(error);
-        throw new CodexAppServerReadOnlyProcedureError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues));
     }
     finally {
         runtimeObserver?.flush();
-        client.dispose();
-        rmSync(tempRoot, { recursive: true, force: true });
+        try {
+            await invocation.close();
+        }
+        catch (error) {
+            invocation.reportProcessTerminationFailure(error);
+            lifecycleError = error;
+        }
+    }
+    if (primaryError !== undefined) {
+        throw primaryError;
+    }
+    if (lifecycleError !== undefined) {
+        throw new CodexAppServerReadOnlyProcedureError("process_lifecycle_failed", lifecycleError instanceof CodexAppServerLifecycleError
+            ? lifecycleError.message
+            : "Codex app-server process lifecycle did not close cleanly.");
     }
+    return procedureResult;
 }
 //# sourceMappingURL=read-only-procedure.js.map

package/dist/providers/openai/app-server/smoke-types.d.ts

@@ -27,6 +27,7 @@ export type CodexAppServerNoWriteSmokeOptions = CodexAppServerSmokeProviderInput
     requestTimeoutMs?: number;
     turnTimeoutMs?: number;
     baseEnv?: NodeJS.ProcessEnv;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
 };
 export type CodexAppServerNoWriteSmokeResult = {
     status: "passed";
@@ -43,7 +44,8 @@ export type CodexAppServerNoWriteSmokeResult = {
     stderr_excerpt: string;
 };
 export declare class CodexAppServerSmokeError extends Error {
-    readonly code: "missing_provider_credential" | "credential_unavailable" | "app_server_protocol_error" | "auth_failed" | "model_unavailable" | "thread_start_failed" | "turn_failed" | "unexpected_server_request" | "sentinel_missing" | "write_detected" | "secret_leak_detected";
-    constructor(code: "missing_provider_credential" | "credential_unavailable" | "app_server_protocol_error" | "auth_failed" | "model_unavailable" | "thread_start_failed" | "turn_failed" | "unexpected_server_request" | "sentinel_missing" | "write_detected" | "secret_leak_detected", message: string);
+    readonly code: "missing_provider_credential" | "credential_unavailable" | "app_server_protocol_error" | "auth_failed" | "model_unavailable" | "thread_start_failed" | "turn_failed" | "unexpected_server_request" | "sentinel_missing" | "write_detected" | "secret_leak_detected" | "process_lifecycle_failed";
+    constructor(code: "missing_provider_credential" | "credential_unavailable" | "app_server_protocol_error" | "auth_failed" | "model_unavailable" | "thread_start_failed" | "turn_failed" | "unexpected_server_request" | "sentinel_missing" | "write_detected" | "secret_leak_detected" | "process_lifecycle_failed", message: string);
 }
+import type { CodexAppServerLifecycleIncident } from "./invocation-lifecycle.js";
 //# sourceMappingURL=smoke-types.d.ts.map

package/dist/providers/openai/app-server/smoke.js

@@ -1,10 +1,11 @@
 import { spawn } from "node:child_process";
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { CODEX_APP_SERVER_COMMAND, CODEX_APP_SERVER_LISTEN_URL, buildCodexAppServerProcessPlan, } from "../codex-app-server.js";
 import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
 import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./json-rpc.js";
+import { CodexAppServerInvocation, CodexAppServerLifecycleError, createManagedProcess, } from "./invocation-lifecycle.js";
 import { createReadOnlySandboxPolicy } from "./sandbox-policy.js";
 import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
 import { containsKnownSecret, countAvailableModels, createCodexSpawnEnv, createSmokeRepo, extractAgentText, extractNotificationMethod, isApiKeyAccount, modelListContains, readAccountType, readGitStatus, readThreadId, readTurnStatus, redactWithKnownValues, renderNoWriteSmokePrompt, } from "./smoke-helpers.js";
@@ -27,12 +28,26 @@ export async function runCodexAppServerNoWriteSmoke(options) {
         configOverrides: buildCodexAppServerProviderConfigOverrides(options),
         ...(options.codexCommand === undefined ? {} : { codexCommand: options.codexCommand }),
     });
-    const child = spawn(processPlan.command, processPlan.args, {
+    const managedProcess = createManagedProcess(spawn(processPlan.command, processPlan.args, {
         cwd: process.cwd(),
+        detached: process.platform !== "win32",
         env: createCodexSpawnEnv(codexHome, options.baseEnv ?? process.env),
         stdio: "pipe",
-    });
+    }));
+    const child = managedProcess.child;
     const client = new CodexAppServerJsonRpcClient(child);
+    const invocation = new CodexAppServerInvocation({
+        managedProcess,
+        tempRoot,
+        closeProtocol: () => client.close(),
+        ...(options.keepTemp === true ? { keepTemp: true } : {}),
+        ...(options.onLifecycleIncident === undefined
+            ? {}
+            : { onIncident: options.onLifecycleIncident }),
+    });
+    let primaryError;
+    let smokeResult;
+    let lifecycleError;
     try {
         await client.request("initialize", {
             clientInfo: {
@@ -121,7 +136,7 @@ export async function runCodexAppServerNoWriteSmoke(options) {
             throw new CodexAppServerSmokeError("secret_leak_detected", "Codex app-server output contained the provider API key.");
         }
         const stderrExcerpt = redactWithKnownValues(client.stderr, sensitiveValues).slice(0, 500);
-        return {
+        smokeResult = {
             status: "passed",
             model,
             account_type: "apiKey",
@@ -139,19 +154,33 @@ export async function runCodexAppServerNoWriteSmoke(options) {
     }
     catch (error) {
         if (error instanceof CodexAppServerSmokeError) {
-            throw error;
+            primaryError = error;
+        }
+        else if (error instanceof CodexAppServerProtocolError) {
+            primaryError = new CodexAppServerSmokeError("app_server_protocol_error", redactWithKnownValues(error.message, [options.apiKey, tempRoot, codexHome, repoRoot]));
         }
-        if (error instanceof CodexAppServerProtocolError) {
-            throw new CodexAppServerSmokeError("app_server_protocol_error", redactWithKnownValues(error.message, [options.apiKey, tempRoot, codexHome, repoRoot]));
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            primaryError = new CodexAppServerSmokeError("app_server_protocol_error", redactWithKnownValues(message, [options.apiKey, tempRoot, codexHome, repoRoot]));
         }
-        const message = error instanceof Error ? error.message : String(error);
-        throw new CodexAppServerSmokeError("app_server_protocol_error", redactWithKnownValues(message, [options.apiKey, tempRoot, codexHome, repoRoot]));
     }
     finally {
-        client.dispose();
-        if (options.keepTemp !== true) {
-            rmSync(tempRoot, { recursive: true, force: true });
+        try {
+            await invocation.close();
         }
+        catch (error) {
+            invocation.reportProcessTerminationFailure(error);
+            lifecycleError = error;
+        }
+    }
+    if (primaryError !== undefined) {
+        throw primaryError;
+    }
+    if (lifecycleError !== undefined) {
+        throw new CodexAppServerSmokeError("process_lifecycle_failed", lifecycleError instanceof CodexAppServerLifecycleError
+            ? lifecycleError.message
+            : "Codex app-server process lifecycle did not close cleanly.");
     }
+    return smokeResult;
 }
 //# sourceMappingURL=smoke.js.map

package/dist/providers/openai/app-server/stale-temp-cleanup.d.ts

@@ -0,0 +1,17 @@
+export type StaleCodexTempCleanupResult = {
+    scanned_count: number;
+    eligible_count: number;
+    removed_count: number;
+    failed_count: number;
+};
+export declare function cleanupStaleCodexAppServerTempRoots(options?: {
+    tempDirectory?: string;
+    minimumAgeMs?: number;
+    now?: () => Date;
+    removeTempRoot?: (root: string) => Promise<void>;
+    onIncident?: (incident: {
+        code: "stale_temp_cleanup_failed";
+        error_code: string;
+    }) => void;
+}): Promise<StaleCodexTempCleanupResult>;
+//# sourceMappingURL=stale-temp-cleanup.d.ts.map

package/dist/providers/openai/app-server/stale-temp-cleanup.js

@@ -0,0 +1,130 @@
+import { lstat, readFile, readdir, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { systemErrorCode } from "../../../process-tree.js";
+import { CODEX_APP_SERVER_OWNER_MARKER_FILE, CODEX_APP_SERVER_TEMP_PREFIXES, } from "./invocation-lifecycle.js";
+const DEFAULT_MINIMUM_AGE_MS = 24 * 60 * 60 * 1_000;
+const MAX_MARKER_BYTES = 4 * 1_024;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseMarker(value) {
+    if (!isRecord(value) ||
+        value.version !== 1 ||
+        typeof value.owner_pid !== "number" ||
+        !Number.isSafeInteger(value.owner_pid) ||
+        value.owner_pid <= 0 ||
+        !(value.process_group_id === null ||
+            (typeof value.process_group_id === "number" &&
+                Number.isSafeInteger(value.process_group_id) &&
+                value.process_group_id > 0)) ||
+        typeof value.created_at !== "string" ||
+        !Number.isFinite(new Date(value.created_at).getTime()) ||
+        !(value.keep_temp === undefined || typeof value.keep_temp === "boolean")) {
+        return null;
+    }
+    return value;
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return systemErrorCode(error) !== "ESRCH";
+    }
+}
+function processGroupIsAlive(processGroupId) {
+    if (process.platform === "win32") {
+        return false;
+    }
+    try {
+        process.kill(-processGroupId, 0);
+        return true;
+    }
+    catch (error) {
+        return systemErrorCode(error) !== "ESRCH";
+    }
+}
+function hasManagedPrefix(name) {
+    return CODEX_APP_SERVER_TEMP_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+async function readOwnerMarker(root) {
+    try {
+        const markerPath = join(root, CODEX_APP_SERVER_OWNER_MARKER_FILE);
+        const markerStat = await stat(markerPath);
+        if (!markerStat.isFile() || markerStat.size > MAX_MARKER_BYTES) {
+            return null;
+        }
+        return parseMarker(JSON.parse(await readFile(markerPath, "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+export async function cleanupStaleCodexAppServerTempRoots(options = {}) {
+    const tempDirectory = options.tempDirectory ?? tmpdir();
+    const nowMs = (options.now ?? (() => new Date()))().getTime();
+    const minimumAgeMs = options.minimumAgeMs ?? DEFAULT_MINIMUM_AGE_MS;
+    const result = {
+        scanned_count: 0,
+        eligible_count: 0,
+        removed_count: 0,
+        failed_count: 0,
+    };
+    let names;
+    try {
+        names = await readdir(tempDirectory);
+    }
+    catch (error) {
+        options.onIncident?.({
+            code: "stale_temp_cleanup_failed",
+            error_code: systemErrorCode(error),
+        });
+        return { ...result, failed_count: 1 };
+    }
+    for (const name of names) {
+        if (!hasManagedPrefix(name)) {
+            continue;
+        }
+        result.scanned_count += 1;
+        const root = join(tempDirectory, name);
+        let rootStat;
+        try {
+            rootStat = await lstat(root);
+        }
+        catch {
+            continue;
+        }
+        if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+            continue;
+        }
+        const marker = await readOwnerMarker(root);
+        if (marker === null || marker.keep_temp === true) {
+            continue;
+        }
+        const createdAtMs = new Date(marker.created_at).getTime();
+        const lastTouchedMs = Math.max(createdAtMs, rootStat.mtimeMs);
+        if (nowMs - lastTouchedMs < minimumAgeMs) {
+            continue;
+        }
+        if (processIsAlive(marker.owner_pid) ||
+            (marker.process_group_id !== null && processGroupIsAlive(marker.process_group_id))) {
+            continue;
+        }
+        result.eligible_count += 1;
+        try {
+            await (options.removeTempRoot ?? ((target) => rm(target, { recursive: true, force: true })))(root);
+            result.removed_count += 1;
+        }
+        catch (error) {
+            result.failed_count += 1;
+            options.onIncident?.({
+                code: "stale_temp_cleanup_failed",
+                error_code: systemErrorCode(error),
+            });
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=stale-temp-cleanup.js.map

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

@@ -1,6 +1,8 @@
 import type { ActivityRef, TaskId } from "@tutti/shared/ids";
 import type { CodexAppServerApprovalPolicy } from "../codex-app-server.js";
 import { type CodexAppServerJsonRpcError, type CodexAppServerJsonRpcServerRequest } from "./json-rpc.js";
+import { type CodexAppServerLifecycleIncident } from "./invocation-lifecycle.js";
+import { type CodexAppServerInvocationCoordinator, type CodexAppServerInvocationLease } from "./invocation-coordinator.js";
 import { type CodexAppServerRuntimeTelemetryOptions } from "./runtime-telemetry.js";
 import { type CodexAppServerAgentContextRuntime, type CodexAppServerSkillSelectionName } from "./skills.js";
 import { type OpenAiTokenUsage } from "../token-usage.js";
@@ -54,6 +56,10 @@ export type CodexAppServerWorkspaceWriteRunInput<TOutput> = {
     turnTimeoutMs?: number;
     baseEnv?: NodeJS.ProcessEnv;
     runtimeTelemetry?: CodexAppServerRuntimeTelemetryOptions;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    /** @internal Set only by the coordinator wrapper. */
+    invocationLease?: CodexAppServerInvocationLease;
 };
 export type CodexAppServerWorkspaceWriteRunResult<TOutput> = {
     output: TOutput;
@@ -80,9 +86,9 @@ export type CodexAppServerWorkspaceWriteRunErrorDetails = {
     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";
+    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 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", 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", message: string, details?: CodexAppServerWorkspaceWriteRunErrorDetails);
 }
 export declare function runCodexAppServerWorkspaceWriteRun<TOutput>(options: CodexAppServerWorkspaceWriteRunInput<TOutput>): Promise<CodexAppServerWorkspaceWriteRunResult<TOutput>>;
 //# sourceMappingURL=workspace-write-run.d.ts.map

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

@@ -1,10 +1,12 @@
 import { spawn } from "node:child_process";
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { buildCodexAppServerProcessPlan } from "../codex-app-server.js";
 import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
 import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./json-rpc.js";
+import { CodexAppServerInvocation, CodexAppServerLifecycleError, createManagedProcess, } from "./invocation-lifecycle.js";
+import { CodexAppServerAdmissionError, } from "./invocation-coordinator.js";
 import { createCodexAppServerRuntimeObserver, } from "./runtime-telemetry.js";
 import { createWorkspaceWriteSandboxPolicy } from "./sandbox-policy.js";
 import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
@@ -147,6 +149,26 @@ function parseWorkspaceWriteStructuredJson(text) {
     throw new CodexAppServerWorkspaceWriteRunError("output_parse_failed", "Codex app-server returned malformed JSON.");
 }
 export async function runCodexAppServerWorkspaceWriteRun(options) {
+    if (options.invocationCoordinator !== undefined && options.invocationLease === undefined) {
+        let lease;
+        try {
+            lease = await options.invocationCoordinator.acquire();
+        }
+        catch (error) {
+            throw new CodexAppServerWorkspaceWriteRunError("admission_unavailable", error instanceof CodexAppServerAdmissionError
+                ? error.message
+                : "Codex app-server admission is unavailable.");
+        }
+        try {
+            return await runCodexAppServerWorkspaceWriteRun({
+                ...options,
+                invocationLease: lease,
+            });
+        }
+        finally {
+            lease.release();
+        }
+    }
     let skillInputs;
     let skillsListWarmup;
     let contextRuntimeHint;
@@ -198,11 +220,13 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
         configOverrides: buildCodexAppServerProviderConfigOverrides(options),
         ...(options.codexCommand === undefined ? {} : { codexCommand: options.codexCommand }),
     });
-    const child = spawn(processPlan.command, processPlan.args, {
+    const managedProcess = createManagedProcess(spawn(processPlan.command, processPlan.args, {
         cwd: process.cwd(),
+        detached: process.platform !== "win32",
         env: createCodexSpawnEnv(codexHome, options.baseEnv ?? process.env),
         stdio: "pipe",
-    });
+    }));
+    const child = managedProcess.child;
     const runtimeObserver = options.runtimeTelemetry === undefined
         ? undefined
         : createCodexAppServerRuntimeObserver(options.runtimeTelemetry);
@@ -214,6 +238,15 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
                 onServerRequest: runtimeObserver.serverRequest,
             }),
     });
+    const invocation = new CodexAppServerInvocation({
+        managedProcess,
+        tempRoot,
+        closeProtocol: () => client.close(),
+        ...(options.onLifecycleIncident === undefined
+            ? {}
+            : { onIncident: options.onLifecycleIncident }),
+    });
+    options.invocationLease?.setCloser(() => invocation.close());
     const sensitiveValues = [
         options.apiKey,
         tempRoot,
@@ -233,6 +266,9 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
         options.apiKey,
         ...(contextRuntimeHint?.sensitiveValues ?? []),
     ];
+    let primaryError;
+    let runResult;
+    let lifecycleError;
     try {
         await client.request("initialize", {
             clientInfo: {
@@ -358,7 +394,7 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
             throw new CodexAppServerWorkspaceWriteRunError("secret_leak_detected", "Codex app-server output contained a sensitive runtime value.");
         }
         const usage = extractCodexAppServerTokenUsage(client.notifications);
-        return {
+        runResult = {
             output: parsed,
             model,
             turn_status: "completed",
@@ -373,18 +409,34 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
     }
     catch (error) {
         if (error instanceof CodexAppServerWorkspaceWriteRunError) {
-            throw error;
+            primaryError = error;
         }
-        if (error instanceof CodexAppServerProtocolError) {
-            throw new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(error.message, sensitiveValues));
+        else if (error instanceof CodexAppServerProtocolError) {
+            primaryError = new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(error.message, sensitiveValues));
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            primaryError = new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues));
         }
-        const message = error instanceof Error ? error.message : String(error);
-        throw new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues));
     }
     finally {
         runtimeObserver?.flush();
-        client.dispose();
-        rmSync(tempRoot, { recursive: true, force: true });
+        try {
+            await invocation.close();
+        }
+        catch (error) {
+            invocation.reportProcessTerminationFailure(error);
+            lifecycleError = error;
+        }
+    }
+    if (primaryError !== undefined) {
+        throw primaryError;
+    }
+    if (lifecycleError !== undefined) {
+        throw new CodexAppServerWorkspaceWriteRunError("process_lifecycle_failed", lifecycleError instanceof CodexAppServerLifecycleError
+            ? lifecycleError.message
+            : "Codex app-server process lifecycle did not close cleanly.");
     }
+    return runResult;
 }
 //# sourceMappingURL=workspace-write-run.js.map

package/dist/providers/openai/chat-assistant.d.ts

@@ -2,6 +2,8 @@ import type { ProjectId } from "@tutti/shared/ids";
 import { type ReadOnlyChatAssistantModel } from "../../chat-assistant/index.js";
 import { type OpenAiProviderConfig } from "./provider-config.js";
 import type { CodexAppServerAgentContextRuntime } from "./app-server/skills.js";
+import type { CodexAppServerInvocationCoordinator } from "./app-server/invocation-coordinator.js";
+import type { CodexAppServerLifecycleIncident } from "./app-server/invocation-lifecycle.js";
 import type { ProviderUsageRecorder } from "../../provider-usage/index.js";
 export type OpenAiReadOnlyChatAssistantModelOptions = {
     config: OpenAiProviderConfig;
@@ -16,6 +18,8 @@ export type OpenAiReadOnlyChatAssistantModelOptions = {
     turnTimeoutMs?: number;
     baseEnv?: NodeJS.ProcessEnv;
     recordUsage?: ProviderUsageRecorder;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
 };
 export type ProjectOpenAiReadOnlyChatAssistantModelOptions = {
     tuttiHome: string;
@@ -23,6 +27,8 @@ export type ProjectOpenAiReadOnlyChatAssistantModelOptions = {
     workspaceRoot: string;
     agentContext?: CodexAppServerAgentContextRuntime;
     recordUsage?: ProviderUsageRecorder;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
 };
 export type ReadOnlyChatAssistantModelResolution = {
     kind: "ready";

package/dist/providers/openai/chat-assistant.js

@@ -31,6 +31,12 @@ export function createOpenAiReadOnlyChatAssistantModel(options) {
                     : { requestTimeoutMs: options.requestTimeoutMs }),
                 ...(options.turnTimeoutMs === undefined ? {} : { turnTimeoutMs: options.turnTimeoutMs }),
                 ...(options.baseEnv === undefined ? {} : { baseEnv: options.baseEnv }),
+                ...(options.invocationCoordinator === undefined
+                    ? {}
+                    : { invocationCoordinator: options.invocationCoordinator }),
+                ...(options.onLifecycleIncident === undefined
+                    ? {}
+                    : { onLifecycleIncident: options.onLifecycleIncident }),
             });
             if (options.recordUsage !== undefined && result.usage !== undefined) {
                 options.recordUsage({
@@ -65,6 +71,12 @@ export function resolveProjectOpenAiReadOnlyChatAssistantModel(options) {
                 userSkillsRoot: getProjectUserSkillsRoot(options.tuttiHome, options.projectId),
                 ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
                 ...(options.recordUsage === undefined ? {} : { recordUsage: options.recordUsage }),
+                ...(options.invocationCoordinator === undefined
+                    ? {}
+                    : { invocationCoordinator: options.invocationCoordinator }),
+                ...(options.onLifecycleIncident === undefined
+                    ? {}
+                    : { onLifecycleIncident: options.onLifecycleIncident }),
             }),
         };
     }

package/dist/run-engine/index.js

@@ -1,4 +1,5 @@
 import { createActivityRef } from "@tutti/shared/ids";
+import { safeRuntimeFailureSummary } from "../runtime-failures.js";
 export class RunEngine {
     active = null;
     lastConclusion = null;
@@ -43,7 +44,7 @@ export class RunEngine {
             catch (error) {
                 this.finishActive(activityRef, {
                     kind: "failed",
-                    summary: error instanceof Error ? error.message : "Run failed",
+                    summary: safeRuntimeFailureSummary("Run", error, "run_failed"),
                 }, options.onTransition);
             }
         };