agentplane 0.3.14 → 0.3.16

package/dist/runner/adapters/codex.js

@@ -1,34 +1,14 @@
 import { readFile } from "node:fs/promises";
-import path from "node:path";
 import { exitCodeForError } from "../../cli/exit-codes.js";
 import { CliError } from "../../shared/errors.js";
-import { evolveRunnerRunState } from "../artifacts.js";
 import { runnerAdapterCancelledResult, runnerAdapterFailureResult, runnerAdapterSuccessResult, } from "./shared.js";
-import { buildInvocationEventData, buildRunnerExecutionArtifacts, durationMs, } from "./runtime-shared.js";
+import { buildRunnerExecutionArtifacts, durationMs } from "./runtime-shared.js";
 import { exitCodeForSignal, runSupervisedProcess, } from "../process-supervision.js";
 import { InvalidRunnerResultManifestError, applyRunnerResultManifest, manifestFromRunnerResult, preserveRunnerResultManifestSource, preserveInvalidRunnerResultManifest, readRunnerResultManifest, writeRunnerResultManifest, } from "../result-manifest.js";
 import { RunnerRunRepository } from "../run-repository.js";
 import { assertRunnerManifestArtifactPolicy, readRecipeArtifactPrefixesFromRunnerEnv, } from "../result-manifest-policy.js";
-import { buildRecipeRunnerEnv, readRecipeRunProfile } from "./recipe-run-profile.js";
-const CODEX_LAST_MESSAGE_FILENAME = "codex-last-message.md";
-const CODEX_SANDBOX_VALUES = new Set(["read-only", "workspace-write", "danger-full-access"]);
-const SUPPORTED_CODEX_SANDBOXES = [...CODEX_SANDBOX_VALUES];
-const CODEX_RUN_PROFILE_CAPABILITIES = {
-    adapter_id: "codex",
-    fields: {
-        sandbox: {
-            level: "native",
-            channel: "argv",
-            supported_values: SUPPORTED_CODEX_SANDBOXES,
-            note: "Recipe sandbox is enforced through codex --sandbox argv mapping.",
-        },
-        writes_artifacts_to: {
-            level: "advisory",
-            channel: "env",
-            note: "Recipe artifact prefixes are exported through env and enforced post-run against external manifest artifacts and evidence paths.",
-        },
-    },
-};
+import { appendRunnerExecutionEvent, appendRunnerResultEvent, assertAdapterBundle, assertAdapterInvocation, writeRunnerExecutionState, writeRunnerResultState, } from "./base.js";
+import { buildCodexInvocation, CODEX_RUN_PROFILE_CAPABILITIES } from "./codex-preparation.js";
 function byteLength(text) {
     return Buffer.byteLength(text ?? "", "utf8");
 }
@@ -46,64 +26,15 @@ function buildCodexArtifacts(opts) {
     return buildRunnerExecutionArtifacts({ ...opts, include_output_last_message: true });
 }
 function assertCodexBundle(bundle) {
-    if (bundle.execution.adapter_id !== "codex") {
-        throw new Error(`Codex adapter cannot prepare bundle for adapter_id=${JSON.stringify(bundle.execution.adapter_id)}`);
-    }
-    if (!bundle.execution.artifact_paths.bundle_path.trim()) {
-        throw new Error("Codex adapter requires a non-empty bundle path");
-    }
-    if (!bundle.execution.artifact_paths.run_dir.trim()) {
-        throw new Error("Codex adapter requires a non-empty run dir");
-    }
+    assertAdapterBundle({ adapterId: "codex", label: "Codex", bundle });
 }
 function assertCodexInvocation(invocation) {
-    if (invocation.adapter_id !== "codex") {
-        throw new Error(`Codex adapter cannot execute invocation for adapter_id=${JSON.stringify(invocation.adapter_id)}`);
-    }
-    if (!invocation.bundle_path.trim()) {
-        throw new Error("Codex adapter invocation is missing bundle_path");
-    }
-    if (!invocation.run_dir.trim()) {
-        throw new Error("Codex adapter invocation is missing run_dir");
-    }
-    if (!invocation.state_path.trim()) {
-        throw new Error("Codex adapter invocation is missing state_path");
-    }
-    if (!invocation.events_path.trim()) {
-        throw new Error("Codex adapter invocation is missing events_path");
-    }
-    if (!invocation.result_path.trim()) {
-        throw new Error("Codex adapter invocation is missing result_path");
-    }
-    if (!invocation.trace_path.trim()) {
-        throw new Error("Codex adapter invocation is missing trace_path");
-    }
-    if (!invocation.stderr_path.trim()) {
-        throw new Error("Codex adapter invocation is missing stderr_path");
-    }
-    if (!invocation.bootstrap_path?.trim()) {
-        throw new Error("Codex adapter invocation is missing bootstrap_path");
-    }
-    if (invocation.argv.length < 5) {
-        throw new Error("Codex adapter invocation is missing normalized argv metadata");
-    }
-}
-function resolveCodexSandbox(value) {
-    const normalized = typeof value === "string" ? value.trim() : "";
-    if (!normalized)
-        return "danger-full-access";
-    if (CODEX_SANDBOX_VALUES.has(normalized))
-        return normalized;
-    throw new CliError({
-        exitCode: 8,
-        code: "E_RUNTIME",
-        message: `Codex runner does not support recipe sandbox ${JSON.stringify(normalized)}; ` +
-            `supported values: ${SUPPORTED_CODEX_SANDBOXES.join(", ")}.`,
-        context: {
-            adapter_id: "codex",
-            requested_sandbox: normalized,
-            supported_sandboxes: SUPPORTED_CODEX_SANDBOXES,
-        },
+    assertAdapterInvocation({
+        adapterId: "codex",
+        label: "Codex",
+        invocation,
+        requireBootstrap: true,
+        minArgvLength: 5,
     });
 }
 function assertExecuteModeManifest(opts) {
@@ -136,48 +67,7 @@ export class CodexRunnerAdapter {
     }
     prepare(bundle) {
         assertCodexBundle(bundle);
-        const { execution } = bundle;
-        const runProfile = readRecipeRunProfile(bundle.recipe);
-        const sandbox = resolveCodexSandbox(runProfile?.sandbox);
-        const recipeEnv = buildRecipeRunnerEnv(bundle.recipe);
-        return Promise.resolve({
-            adapter_id: this.id,
-            run_id: execution.run_id,
-            run_dir: execution.artifact_paths.run_dir,
-            bundle_path: execution.artifact_paths.bundle_path,
-            state_path: execution.artifact_paths.state_path,
-            events_path: execution.artifact_paths.events_path,
-            result_path: execution.artifact_paths.result_path,
-            trace_path: execution.artifact_paths.trace_path,
-            stderr_path: execution.artifact_paths.stderr_path,
-            trace_policy: execution.trace_policy,
-            timeout_policy: execution.timeout_policy,
-            bootstrap_path: execution.artifact_paths.bootstrap_path,
-            output_last_message_path: path.join(execution.artifact_paths.run_dir, CODEX_LAST_MESSAGE_FILENAME),
-            argv: [
-                "codex",
-                "-a",
-                "never",
-                "exec",
-                "--json",
-                "--output-last-message",
-                path.join(execution.artifact_paths.run_dir, CODEX_LAST_MESSAGE_FILENAME),
-                "-C",
-                bundle.repository.git_root,
-                "-s",
-                sandbox,
-                "-",
-            ],
-            env: {
-                AGENTPLANE_RUNNER_ADAPTER: this.id,
-                AGENTPLANE_RUNNER_MODE: execution.mode,
-                AGENTPLANE_RUNNER_API_VERSION: bundle.runner_api_version,
-                AGENTPLANE_RUNNER_TARGET: bundle.target.kind,
-                AGENTPLANE_RUNNER_RESULT_PATH: execution.artifact_paths.result_path,
-                ...recipeEnv,
-            },
-            dry_run: execution.mode === "dry_run",
-        });
+        return Promise.resolve(buildCodexInvocation({ adapterId: this.id, bundle }));
     }
     execute(invocation) {
         const started_at = new Date().toISOString();
@@ -281,46 +171,19 @@ export class CodexRunnerAdapter {
                     result_path: invocation.result_path,
                     manifest: manifestFromRunnerResult(result),
                 });
-                const stateAfter = await repository.readState();
-                if (stateAfter) {
-                    await repository.writeState(evolveRunnerRunState({
-                        state: stateAfter,
-                        status: result.status,
-                        result,
-                        supervision: {
-                            ...stateAfter.supervision,
-                            pid: processResult.pid,
-                            command: invocation.argv.join(" "),
-                            started_at: processResult.started_at,
-                            heartbeat_at: processResult.heartbeat_at,
-                            exit_signal: processResult.exit_signal,
-                            timeout_reason: processResult.timeout_reason,
-                            timeout_requested_at: processResult.timeout_requested_at,
-                            terminate_sent_at: processResult.terminate_sent_at,
-                            kill_sent_at: processResult.kill_sent_at,
-                            force_killed: processResult.force_killed,
-                        },
-                    }));
-                }
-                await repository.appendEvent({
-                    at: result.ended_at,
-                    type: "runner_execute_finish",
+                await writeRunnerExecutionState({
+                    repository,
+                    result,
+                    processResult,
+                    command: invocation.argv.join(" "),
+                });
+                await appendRunnerExecutionEvent({
+                    repository,
+                    invocation,
+                    result,
+                    processResult,
                     message: `codex exec finished with status=${result.status}`,
-                    data: {
-                        ...buildInvocationEventData(invocation),
-                        pid: processResult.pid,
-                        exit_signal: processResult.exit_signal,
-                        cancel_requested_at: processResult.cancel_requested_at,
-                        cancel_signal: processResult.cancel_signal,
-                        timeout_reason: processResult.timeout_reason,
-                        timeout_requested_at: processResult.timeout_requested_at,
-                        terminate_sent_at: processResult.terminate_sent_at,
-                        kill_sent_at: processResult.kill_sent_at,
-                        force_killed: processResult.force_killed,
-                        exit_code: result.exit_code,
-                        output_paths,
-                        metrics: result.metrics,
-                    },
+                    outputPaths: output_paths,
                 });
                 return result;
             }
@@ -359,23 +222,15 @@ export class CodexRunnerAdapter {
                         capabilities_used: ["codex.exec"],
                     }),
                 });
-                const stateAfter = await RunnerRunRepository.fromInvocation(invocation).readState();
-                if (stateAfter) {
-                    await RunnerRunRepository.fromInvocation(invocation).writeState(evolveRunnerRunState({
-                        state: stateAfter,
-                        status: result.status,
-                        result,
-                    }));
-                }
-                await RunnerRunRepository.fromInvocation(invocation).appendEvent({
-                    at: result.ended_at,
+                const repository = RunnerRunRepository.fromInvocation(invocation);
+                await writeRunnerResultState({ repository, result });
+                await appendRunnerResultEvent({
+                    repository,
+                    invocation,
+                    result,
                     type: "runner_execute_error",
                     message: result.stderr_summary ?? "codex exec failed",
-                    data: {
-                        ...buildInvocationEventData(invocation),
-                        output_paths,
-                        metrics: result.metrics,
-                    },
+                    outputPaths: output_paths,
                 });
                 return result;
             }

package/dist/runner/adapters/custom-preparation.d.ts

@@ -0,0 +1,9 @@
+import type { RunnerCustomConfig } from "@agentplaneorg/core";
+import type { RunnerAdapterCapabilities, RunnerContextBundle, RunnerInvocation } from "../types.js";
+export declare function buildCustomCapabilities(config: RunnerCustomConfig | undefined): RunnerAdapterCapabilities;
+export declare function buildCustomInvocation(opts: {
+    adapterId: "custom";
+    config: RunnerCustomConfig | undefined;
+    bundle: RunnerContextBundle;
+}): RunnerInvocation;
+//# sourceMappingURL=custom-preparation.d.ts.map

package/dist/runner/adapters/custom-preparation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-preparation.d.ts","sourceRoot":"","sources":["../../../src/runner/adapters/custom-preparation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAI9D,OAAO,KAAK,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAepG,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,kBAAkB,GAAG,SAAS,GACrC,yBAAyB,CAiC3B;AA0HD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,QAAQ,CAAC;IACpB,MAAM,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACvC,MAAM,EAAE,mBAAmB,CAAC;CAC7B,GAAG,gBAAgB,CAgDnB"}

package/dist/runner/adapters/custom-preparation.js

@@ -0,0 +1,191 @@
+import { exitCodeForError } from "../../cli/exit-codes.js";
+import { CliError } from "../../shared/errors.js";
+import { buildRecipeRunnerEnv, readRecipeRunProfile } from "./recipe-run-profile.js";
+const CUSTOM_SANDBOX_WRAPPER_SUPPORTED_VALUES = ["workspace-write"];
+function normalizeCustomEnforcement(config) {
+    return {
+        mode: config?.enforcement?.mode ?? "none",
+        platform: config?.enforcement?.platform ?? "auto",
+    };
+}
+export function buildCustomCapabilities(config) {
+    const enforcement = normalizeCustomEnforcement(config);
+    const configuredModeNote = `Configured via runner.custom.enforcement.mode=${JSON.stringify(enforcement.mode)} ` +
+        `(platform=${JSON.stringify(enforcement.platform)}).`;
+    return {
+        adapter_id: "custom",
+        fields: {
+            sandbox: enforcement.mode === "codex_sandbox_full_auto"
+                ? {
+                    level: "wrapper",
+                    channel: "argv",
+                    supported_values: [...CUSTOM_SANDBOX_WRAPPER_SUPPORTED_VALUES],
+                    note: `${configuredModeNote} Custom runner sandbox is enforced through ` +
+                        "`codex sandbox <platform> --full-auto` and currently supports workspace-write only, " +
+                        "because the shared runner contract requires writable result and trace artifacts inside run_dir.",
+                }
+                : {
+                    level: "advisory",
+                    channel: "env",
+                    note: `${configuredModeNote} Custom runner receives sandbox intent through env only; ` +
+                        "the adapter does not enforce it.",
+                },
+            writes_artifacts_to: {
+                level: "advisory",
+                channel: "env",
+                note: "Recipe artifact prefixes are exported through env and enforced post-run against external manifest artifacts and evidence paths.",
+            },
+        },
+    };
+}
+function resolveCodexSandboxPlatform(value) {
+    const currentPlatform = (() => {
+        switch (process.platform) {
+            case "darwin": {
+                return "macos";
+            }
+            case "linux": {
+                return "linux";
+            }
+            case "win32": {
+                return "windows";
+            }
+            default: {
+                return null;
+            }
+        }
+    })();
+    if (!currentPlatform) {
+        throw new CliError({
+            exitCode: exitCodeForError("E_RUNTIME"),
+            code: "E_RUNTIME",
+            message: `Custom runner codex sandbox wrapper does not support current platform ${JSON.stringify(process.platform)}.`,
+            context: {
+                adapter_id: "custom",
+                wrapper_mode: "codex_sandbox_full_auto",
+                platform: process.platform,
+                policy_field: "sandbox",
+            },
+        });
+    }
+    if (value && value !== "auto") {
+        if (value !== currentPlatform) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_RUNTIME"),
+                code: "E_RUNTIME",
+                message: `Custom runner codex sandbox wrapper is configured for ${JSON.stringify(value)} but current platform is ` +
+                    `${JSON.stringify(currentPlatform)}.`,
+                context: {
+                    adapter_id: "custom",
+                    wrapper_mode: "codex_sandbox_full_auto",
+                    configured_platform: value,
+                    platform: currentPlatform,
+                    policy_field: "sandbox",
+                },
+            });
+        }
+        return value;
+    }
+    return currentPlatform;
+}
+function unsupportedCustomSandboxError(opts) {
+    const baseContext = {
+        adapter_id: "custom",
+        wrapper_mode: opts.enforcementMode,
+        policy_field: "sandbox",
+        declared_value: opts.requestedSandbox,
+        supported_values: CUSTOM_SANDBOX_WRAPPER_SUPPORTED_VALUES,
+    };
+    if (opts.requestedSandbox === "read-only") {
+        return new CliError({
+            exitCode: exitCodeForError("E_RUNTIME"),
+            code: "E_RUNTIME",
+            message: `Custom runner wrapper mode ${JSON.stringify(opts.enforcementMode)} cannot support recipe sandbox ` +
+                `${JSON.stringify(opts.requestedSandbox)} because the shared runner contract requires write access ` +
+                "to result.json and trace artifacts inside run_dir, while the default codex sandbox blocks writes " +
+                "to cwd and TMPDIR. Supported values: workspace-write.",
+            context: baseContext,
+        });
+    }
+    return new CliError({
+        exitCode: exitCodeForError("E_RUNTIME"),
+        code: "E_RUNTIME",
+        message: `Custom runner wrapper mode ${JSON.stringify(opts.enforcementMode)} does not support recipe sandbox ` +
+            `${JSON.stringify(opts.requestedSandbox)}; supported values: ${CUSTOM_SANDBOX_WRAPPER_SUPPORTED_VALUES.join(", ")}.`,
+        context: baseContext,
+    });
+}
+function buildCustomCommand(opts) {
+    const enforcement = normalizeCustomEnforcement(opts.config);
+    if (enforcement.mode !== "codex_sandbox_full_auto")
+        return opts.command;
+    const runProfile = readRecipeRunProfile(opts.bundle.recipe);
+    const requestedSandbox = typeof runProfile?.sandbox === "string" ? runProfile.sandbox.trim() : "";
+    if (!requestedSandbox)
+        return opts.command;
+    if (!CUSTOM_SANDBOX_WRAPPER_SUPPORTED_VALUES.includes(requestedSandbox)) {
+        throw unsupportedCustomSandboxError({
+            enforcementMode: enforcement.mode,
+            requestedSandbox,
+        });
+    }
+    return [
+        "codex",
+        "sandbox",
+        resolveCodexSandboxPlatform(enforcement.platform),
+        "--full-auto",
+        ...opts.command,
+    ];
+}
+function normalizeCustomCommand(value) {
+    return Array.isArray(value)
+        ? value.map((entry) => entry.trim()).filter((entry) => entry.length > 0)
+        : [];
+}
+export function buildCustomInvocation(opts) {
+    const command = normalizeCustomCommand(opts.config?.command);
+    if (command.length === 0) {
+        throw new Error("Custom runner adapter requires config.runner.custom.command to contain at least one argv element");
+    }
+    const { execution } = opts.bundle;
+    const recipeEnv = buildRecipeRunnerEnv(opts.bundle.recipe);
+    const enforcement = normalizeCustomEnforcement(opts.config);
+    const preparedCommand = buildCustomCommand({
+        config: opts.config,
+        bundle: opts.bundle,
+        command,
+    });
+    return {
+        adapter_id: opts.adapterId,
+        run_id: execution.run_id,
+        run_dir: execution.artifact_paths.run_dir,
+        bundle_path: execution.artifact_paths.bundle_path,
+        state_path: execution.artifact_paths.state_path,
+        events_path: execution.artifact_paths.events_path,
+        result_path: execution.artifact_paths.result_path,
+        trace_path: execution.artifact_paths.trace_path,
+        stderr_path: execution.artifact_paths.stderr_path,
+        trace_policy: execution.trace_policy,
+        timeout_policy: execution.timeout_policy,
+        bootstrap_path: execution.artifact_paths.bootstrap_path,
+        output_last_message_path: null,
+        argv: preparedCommand,
+        env: {
+            ...opts.config?.env,
+            AGENTPLANE_RUNNER_ADAPTER: opts.adapterId,
+            AGENTPLANE_RUNNER_MODE: execution.mode,
+            AGENTPLANE_RUNNER_API_VERSION: opts.bundle.runner_api_version,
+            AGENTPLANE_RUNNER_TARGET: opts.bundle.target.kind,
+            AGENTPLANE_RUNNER_BUNDLE_PATH: execution.artifact_paths.bundle_path,
+            AGENTPLANE_RUNNER_RUN_DIR: execution.artifact_paths.run_dir,
+            AGENTPLANE_RUNNER_BOOTSTRAP_PATH: execution.artifact_paths.bootstrap_path,
+            AGENTPLANE_RUNNER_STATE_PATH: execution.artifact_paths.state_path,
+            AGENTPLANE_RUNNER_EVENTS_PATH: execution.artifact_paths.events_path,
+            AGENTPLANE_RUNNER_RESULT_PATH: execution.artifact_paths.result_path,
+            AGENTPLANE_RUNNER_ENFORCEMENT_MODE: enforcement.mode ?? "none",
+            AGENTPLANE_RUNNER_ENFORCEMENT_PLATFORM: enforcement.platform ?? "auto",
+            ...recipeEnv,
+        },
+        dry_run: execution.mode === "dry_run",
+    };
+}

package/dist/runner/adapters/custom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../../src/runner/adapters/custom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAI9D,OAAO,KAAK,EACV,yBAAyB,EACzB,mBAAmB,EACnB,gBAAgB,EAEhB,YAAY,EACb,MAAM,aAAa,CAAC;AAErB,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AAoSrB,qBAAa,mBAAoB,YAAW,aAAa;IAG3C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,QAAQ,CAAC,EAAE,EAAG,QAAQ,CAAU;gBAEH,MAAM,EAAE,kBAAkB,GAAG,SAAS;IAEnE,oBAAoB,CAAC,OAAO,EAAE,mBAAmB,GAAG,yBAAyB;IAI7E,OAAO,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmD/D,OAAO,CAAC,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC;CAqN7D"}
+{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../../src/runner/adapters/custom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D,OAAO,KAAK,EACV,yBAAyB,EACzB,mBAAmB,EACnB,gBAAgB,EAEhB,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AAwFrB,qBAAa,mBAAoB,YAAW,aAAa;IAG3C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,QAAQ,CAAC,EAAE,EAAG,QAAQ,CAAU;gBAEH,MAAM,EAAE,kBAAkB,GAAG,SAAS;IAEnE,oBAAoB,CAAC,OAAO,EAAE,mBAAmB,GAAG,yBAAyB;IAI7E,OAAO,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAW/D,OAAO,CAAC,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC;CA4K7D"}