agentplane 0.3.7 → 0.3.9

package/dist/runner/adapters/custom.js

@@ -0,0 +1,512 @@
+import { readFile } from "node:fs/promises";
+import { exitCodeForError } from "../../cli/exit-codes.js";
+import { CliError } from "../../shared/errors.js";
+import { evolveRunnerRunState } from "../artifacts.js";
+import { runnerArtifactsFromSpecs, runnerAdapterCancelledResult, runnerAdapterFailureResult, runnerAdapterSuccessResult, } from "./shared.js";
+import { exitCodeForSignal, runSupervisedProcess, } from "../process-supervision.js";
+import { InvalidRunnerResultManifestError, 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 CUSTOM_SANDBOX_WRAPPER_SUPPORTED_VALUES = ["workspace-write"];
+function normalizeCustomEnforcement(config) {
+    return {
+        mode: config?.enforcement?.mode ?? "none",
+        platform: config?.enforcement?.platform ?? "auto",
+    };
+}
+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 durationMs(startedAt, endedAt) {
+    const started = Date.parse(startedAt);
+    const ended = Date.parse(endedAt);
+    if (Number.isNaN(started) || Number.isNaN(ended))
+        return undefined;
+    return Math.max(0, ended - started);
+}
+function buildInvocationEventData(invocation) {
+    return {
+        executable: invocation.argv[0] ?? null,
+        argv_count: invocation.argv.length,
+        cwd: invocation.run_dir,
+        env_keys: Object.keys(invocation.env).toSorted(),
+        trace_policy: invocation.trace_policy,
+        timeout_policy: invocation.timeout_policy,
+        has_bootstrap_path: typeof invocation.bootstrap_path === "string" && invocation.bootstrap_path.trim().length > 0,
+    };
+}
+function normalizeCustomCommand(value) {
+    return Array.isArray(value)
+        ? value.map((entry) => entry.trim()).filter((entry) => entry.length > 0)
+        : [];
+}
+function assertCustomBundle(bundle) {
+    if (bundle.execution.adapter_id !== "custom") {
+        throw new Error(`Custom adapter cannot prepare bundle for adapter_id=${JSON.stringify(bundle.execution.adapter_id)}`);
+    }
+    if (!bundle.execution.artifact_paths.bundle_path.trim()) {
+        throw new Error("Custom adapter requires a non-empty bundle path");
+    }
+    if (!bundle.execution.artifact_paths.run_dir.trim()) {
+        throw new Error("Custom adapter requires a non-empty run dir");
+    }
+}
+function buildCustomArtifacts(opts) {
+    return (runnerArtifactsFromSpecs([
+        { path: opts.invocation.bundle_path, label: "bundle" },
+        { path: opts.invocation.bootstrap_path, label: "bootstrap" },
+        { path: opts.trace_artifact_path, label: "raw-trace" },
+        { path: opts.trace_archive_path, label: "raw-trace-gzip" },
+        { path: opts.stderr_artifact_path, label: "stderr-log" },
+        { path: opts.stderr_archive_path, label: "stderr-log-gzip" },
+        { path: opts.source_manifest_path, label: "source-result-manifest" },
+        { path: opts.invalid_manifest_path, label: "invalid-result-manifest" },
+        { path: opts.invocation.result_path, label: "result-manifest" },
+    ]) ?? []);
+}
+function mergeRunnerArtifacts(base, extra) {
+    const merged = [];
+    const seen = new Set();
+    for (const artifact of [...(base ?? []), ...(extra ?? [])]) {
+        const key = `${artifact.path}::${artifact.label ?? ""}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(artifact);
+    }
+    return merged.length > 0 ? merged : undefined;
+}
+function applyCustomRunnerResultManifest(opts) {
+    if (!opts.manifest)
+        return opts.base;
+    const merged = {
+        ...opts.base,
+        status: opts.base.status === "cancelled" ? "cancelled" : (opts.manifest.status ?? opts.base.status),
+        exit_code: opts.base.status === "cancelled"
+            ? opts.base.exit_code
+            : (opts.manifest.exit_code ?? opts.base.exit_code),
+        artifacts: mergeRunnerArtifacts(opts.base.artifacts, opts.manifest.artifacts),
+        capabilities_used: opts.manifest.capabilities_used ?? opts.base.capabilities_used,
+        metrics: {
+            ...opts.base.metrics,
+            ...opts.manifest.metrics,
+        },
+        evidence: opts.manifest.evidence ?? opts.base.evidence,
+    };
+    if (merged.artifacts && merged.artifacts.length > 0) {
+        merged.output_paths = merged.artifacts.map((artifact) => artifact.path);
+    }
+    return merged;
+}
+function assertCustomInvocation(invocation) {
+    if (invocation.adapter_id !== "custom") {
+        throw new Error(`Custom adapter cannot execute invocation for adapter_id=${JSON.stringify(invocation.adapter_id)}`);
+    }
+    if (!invocation.bundle_path.trim()) {
+        throw new Error("Custom adapter invocation is missing bundle_path");
+    }
+    if (!invocation.run_dir.trim()) {
+        throw new Error("Custom adapter invocation is missing run_dir");
+    }
+    if (!invocation.state_path.trim()) {
+        throw new Error("Custom adapter invocation is missing state_path");
+    }
+    if (!invocation.events_path.trim()) {
+        throw new Error("Custom adapter invocation is missing events_path");
+    }
+    if (!invocation.result_path.trim()) {
+        throw new Error("Custom adapter invocation is missing result_path");
+    }
+    if (!invocation.trace_path.trim()) {
+        throw new Error("Custom adapter invocation is missing trace_path");
+    }
+    if (!invocation.stderr_path.trim()) {
+        throw new Error("Custom adapter invocation is missing stderr_path");
+    }
+}
+export class CustomRunnerAdapter {
+    config;
+    id = "custom";
+    constructor(config) {
+        this.config = config;
+    }
+    describeCapabilities(_bundle) {
+        return structuredClone(buildCustomCapabilities(this.config));
+    }
+    prepare(bundle) {
+        assertCustomBundle(bundle);
+        const command = normalizeCustomCommand(this.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 } = bundle;
+        const recipeEnv = buildRecipeRunnerEnv(bundle.recipe);
+        const enforcement = normalizeCustomEnforcement(this.config);
+        const preparedCommand = buildCustomCommand({
+            config: this.config,
+            bundle,
+            command,
+        });
+        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: null,
+            argv: preparedCommand,
+            env: {
+                ...this.config?.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_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",
+        });
+    }
+    execute(invocation) {
+        const started_at = new Date().toISOString();
+        let processResult = null;
+        return (async () => {
+            try {
+                assertCustomInvocation(invocation);
+                const repository = RunnerRunRepository.fromInvocation(invocation);
+                const bootstrapText = invocation.bootstrap_path
+                    ? await readFile(invocation.bootstrap_path, "utf8")
+                    : "";
+                processResult = await runSupervisedProcess({
+                    invocation,
+                    stdin_text: bootstrapText,
+                    start_message: "custom runner started",
+                });
+                const manifest = await readRunnerResultManifest(invocation.result_path);
+                const sourceManifestPath = manifest
+                    ? await preserveRunnerResultManifestSource(invocation.result_path)
+                    : null;
+                assertRunnerManifestArtifactPolicy({
+                    adapter_id: invocation.adapter_id,
+                    allowed_prefixes: readRecipeArtifactPrefixesFromRunnerEnv(invocation.env),
+                    manifest,
+                });
+                const artifacts = buildCustomArtifacts({
+                    invocation,
+                    trace_artifact_path: processResult?.trace_artifact_path,
+                    trace_archive_path: processResult?.trace_archive_path,
+                    stderr_artifact_path: processResult?.stderr_artifact_path,
+                    stderr_archive_path: processResult?.stderr_archive_path,
+                    source_manifest_path: sourceManifestPath,
+                });
+                const output_paths = artifacts.map((artifact) => artifact.path);
+                const success = processResult.exit_code === 0;
+                const ended_at = processResult.ended_at;
+                const timedOut = processResult.timeout_reason !== null;
+                const resultMetrics = {
+                    duration_ms: durationMs(processResult.started_at, ended_at),
+                    stdout_bytes: processResult.stdout_bytes,
+                    stderr_bytes: processResult.stderr_bytes,
+                };
+                const baseResult = timedOut
+                    ? runnerAdapterFailureResult({
+                        err: new Error(`Custom runner execution timed out (${processResult.timeout_reason}).`),
+                        summary: `Custom runner execution timed out (${processResult.timeout_reason}).`,
+                        stderr_summary: "Timeout details were captured in stderr.log and agent-trace.jsonl.",
+                        started_at: processResult.started_at,
+                        ended_at,
+                        exit_code: 124,
+                        output_paths,
+                        metrics: resultMetrics,
+                        timeout_reason: processResult.timeout_reason,
+                    })
+                    : processResult.cancel_requested_at
+                        ? runnerAdapterCancelledResult({
+                            reason: processResult.cancel_signal
+                                ? `Custom runner cancelled via ${processResult.cancel_signal}.`
+                                : "Custom runner cancelled.",
+                            summary: "Custom runner execution was cancelled.",
+                            stderr_summary: "Cancellation details were recorded in stderr.log and agent-trace.jsonl.",
+                            started_at: processResult.started_at,
+                            ended_at,
+                            exit_code: processResult.exit_code ?? exitCodeForSignal(processResult.exit_signal) ?? null,
+                            output_paths,
+                            metrics: resultMetrics,
+                        })
+                        : success
+                            ? runnerAdapterSuccessResult({
+                                summary: "Custom runner execution completed successfully.",
+                                started_at: processResult.started_at,
+                                ended_at,
+                                exit_code: processResult.exit_code ?? 0,
+                                stdout_summary: "Raw execution trace was captured in agent-trace.jsonl.",
+                                output_paths,
+                                metrics: resultMetrics,
+                            })
+                            : runnerAdapterFailureResult({
+                                err: new Error(`Custom runner exited with code ${processResult.exit_code ?? "unknown"}`),
+                                summary: "Custom runner execution failed.",
+                                stderr_summary: "Failure details were captured in stderr.log and agent-trace.jsonl.",
+                                started_at: processResult.started_at,
+                                ended_at,
+                                exit_code: processResult.exit_code ?? exitCodeForSignal(processResult.exit_signal) ?? 1,
+                                output_paths,
+                                metrics: resultMetrics,
+                                timeout_reason: processResult.timeout_reason,
+                            });
+                const result = applyCustomRunnerResultManifest({
+                    base: {
+                        ...baseResult,
+                        artifacts,
+                        capabilities_used: [`custom:${invocation.argv[0] ?? "runner"}`],
+                    },
+                    manifest,
+                });
+                await writeRunnerResultManifest({
+                    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",
+                    message: `custom runner 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,
+                    },
+                });
+                return result;
+            }
+            catch (err) {
+                const sourceManifestPath = await preserveRunnerResultManifestSource(invocation.result_path);
+                const ended_at = new Date().toISOString();
+                const invalidManifestPath = err instanceof InvalidRunnerResultManifestError
+                    ? await preserveInvalidRunnerResultManifest({
+                        result_path: invocation.result_path,
+                        error: err,
+                    })
+                    : null;
+                const artifacts = buildCustomArtifacts({
+                    invocation,
+                    trace_artifact_path: processResult?.trace_artifact_path,
+                    trace_archive_path: processResult?.trace_archive_path,
+                    stderr_artifact_path: processResult?.stderr_artifact_path,
+                    stderr_archive_path: processResult?.stderr_archive_path,
+                    source_manifest_path: sourceManifestPath,
+                    invalid_manifest_path: invalidManifestPath,
+                });
+                const output_paths = artifacts.map((artifact) => artifact.path);
+                const result = runnerAdapterFailureResult({
+                    err,
+                    summary: "Custom runner execution failed before producing a valid result manifest.",
+                    started_at,
+                    ended_at,
+                    exit_code: err instanceof CliError ? err.exitCode : undefined,
+                    output_paths,
+                });
+                await writeRunnerResultManifest({
+                    result_path: invocation.result_path,
+                    manifest: manifestFromRunnerResult({
+                        ...result,
+                        artifacts,
+                        capabilities_used: [`custom:${invocation.argv[0] ?? "runner"}`],
+                    }),
+                });
+                const repository = RunnerRunRepository.fromInvocation(invocation);
+                const stateAfter = await repository.readState();
+                if (stateAfter) {
+                    await repository.writeState(evolveRunnerRunState({
+                        state: stateAfter,
+                        status: result.status,
+                        result,
+                    }));
+                }
+                await repository.appendEvent({
+                    at: result.ended_at,
+                    type: "runner_execute_finish",
+                    message: `custom runner failed with status=${result.status}`,
+                    data: {
+                        ...buildInvocationEventData(invocation),
+                        exit_code: result.exit_code,
+                        output_paths,
+                        metrics: result.metrics,
+                    },
+                });
+                return result;
+            }
+        })();
+    }
+}

package/dist/runner/adapters/index.d.ts

@@ -0,0 +1,8 @@
+import type { AgentplaneConfig } from "@agentplaneorg/core";
+import type { RunnerAdapter } from "./shared.js";
+export declare function createRunnerAdapter(config: Pick<AgentplaneConfig, "runner">): RunnerAdapter;
+export { CodexRunnerAdapter } from "./codex.js";
+export { CustomRunnerAdapter } from "./custom.js";
+export type { RunnerAdapter } from "./shared.js";
+export { runnerAdapterFailureResult, runnerAdapterSuccessResult } from "./shared.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runner/adapters/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAI5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,GAAG,aAAa,CAS3F;AAED,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC"}

package/dist/runner/adapters/index.js

@@ -0,0 +1,15 @@
+import { CodexRunnerAdapter } from "./codex.js";
+import { CustomRunnerAdapter } from "./custom.js";
+export function createRunnerAdapter(config) {
+    switch (config.runner.default_adapter) {
+        case "codex": {
+            return new CodexRunnerAdapter();
+        }
+        case "custom": {
+            return new CustomRunnerAdapter(config.runner.custom);
+        }
+    }
+}
+export { CodexRunnerAdapter } from "./codex.js";
+export { CustomRunnerAdapter } from "./custom.js";
+export { runnerAdapterFailureResult, runnerAdapterSuccessResult } from "./shared.js";

package/dist/runner/adapters/recipe-run-profile.d.ts

@@ -0,0 +1,8 @@
+import type { RunnerRecipeContext } from "../types.js";
+export type RecipeRunProfileMetadata = {
+    sandbox?: string;
+    writes_artifacts_to?: string[];
+};
+export declare function readRecipeRunProfile(recipe: RunnerRecipeContext | undefined): RecipeRunProfileMetadata | null;
+export declare function buildRecipeRunnerEnv(recipe: RunnerRecipeContext | undefined): Record<string, string>;
+//# sourceMappingURL=recipe-run-profile.d.ts.map

package/dist/runner/adapters/recipe-run-profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipe-run-profile.d.ts","sourceRoot":"","sources":["../../../src/runner/adapters/recipe-run-profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC,CAAC;AA4BF,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,mBAAmB,GAAG,SAAS,GACtC,wBAAwB,GAAG,IAAI,CAQjC;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,mBAAmB,GAAG,SAAS,GACtC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmBxB"}

package/dist/runner/adapters/recipe-run-profile.js

@@ -0,0 +1,53 @@
+import { normalizeRecipeArtifactPrefixes } from "../result-manifest-policy.js";
+function normalizeOptionalString(value) {
+    const normalized = typeof value === "string" ? value.trim() : "";
+    return normalized.length > 0 ? normalized : undefined;
+}
+function normalizeStringList(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+function setStringEnv(env, key, value) {
+    if (value)
+        env[key] = value;
+}
+function setJsonEnv(env, key, value) {
+    if (value === undefined)
+        return;
+    env[key] = JSON.stringify(value);
+}
+export function readRecipeRunProfile(recipe) {
+    const profile = recipe?.run_profile;
+    if (!profile || typeof profile !== "object")
+        return null;
+    const candidate = profile;
+    return {
+        sandbox: normalizeOptionalString(candidate.sandbox),
+        writes_artifacts_to: normalizeStringList(candidate.writes_artifacts_to),
+    };
+}
+export function buildRecipeRunnerEnv(recipe) {
+    const env = {};
+    const recipeId = normalizeOptionalString(recipe?.recipe_id);
+    const scenarioId = normalizeOptionalString(recipe?.scenario_id);
+    if (recipeId)
+        env.AGENTPLANE_RECIPE_ID = recipeId;
+    if (scenarioId)
+        env.AGENTPLANE_SCENARIO_ID = scenarioId;
+    const profile = readRecipeRunProfile(recipe);
+    if (!profile)
+        return env;
+    setStringEnv(env, "AGENTPLANE_RECIPE_SANDBOX", profile.sandbox);
+    const normalizedArtifactPrefixes = normalizeRecipeArtifactPrefixes(profile.writes_artifacts_to);
+    const normalizedProfile = {
+        ...profile,
+        writes_artifacts_to: normalizedArtifactPrefixes,
+    };
+    setJsonEnv(env, "AGENTPLANE_RECIPE_WRITES_ARTIFACTS_TO", normalizedArtifactPrefixes);
+    setJsonEnv(env, "AGENTPLANE_RECIPE_RUN_PROFILE", normalizedProfile);
+    return env;
+}

package/dist/runner/adapters/shared.d.ts

@@ -0,0 +1,45 @@
+import type { RunnerAdapterId } from "@agentplaneorg/core";
+import type { RunnerAdapterCapabilities, RunnerContextBundle, RunnerExecutionMetrics, RunnerInvocation, RunnerResultArtifact, RunnerResult, RunnerTimeoutReason } from "../types.js";
+export type RunnerAdapter = {
+    id: RunnerAdapterId;
+    describeCapabilities(bundle: RunnerContextBundle): RunnerAdapterCapabilities;
+    prepare(bundle: RunnerContextBundle): Promise<RunnerInvocation>;
+    execute(invocation: RunnerInvocation): Promise<RunnerResult>;
+};
+export declare function runnerAdapterSuccessResult(opts: {
+    started_at?: string;
+    ended_at?: string;
+    exit_code?: number;
+    summary?: string;
+    stdout_summary: string;
+    output_paths?: string[];
+    metrics?: RunnerExecutionMetrics;
+    timeout_reason?: RunnerTimeoutReason | null;
+}): RunnerResult;
+export declare function runnerAdapterFailureResult(opts: {
+    err: unknown;
+    started_at?: string;
+    ended_at?: string;
+    exit_code?: number | null;
+    summary?: string;
+    stderr_summary?: string;
+    output_paths?: string[];
+    metrics?: RunnerExecutionMetrics;
+    timeout_reason?: RunnerTimeoutReason | null;
+}): RunnerResult;
+export declare function runnerAdapterCancelledResult(opts: {
+    reason: string;
+    started_at?: string;
+    ended_at?: string;
+    exit_code?: number | null;
+    summary?: string;
+    stderr_summary?: string;
+    output_paths?: string[];
+    metrics?: RunnerExecutionMetrics;
+    timeout_reason?: RunnerTimeoutReason | null;
+}): RunnerResult;
+export declare function runnerArtifactsFromSpecs(specs: {
+    path: string | null | undefined;
+    label?: string;
+}[]): RunnerResultArtifact[] | undefined;
+//# sourceMappingURL=shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/runner/adapters/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EACV,yBAAyB,EACzB,mBAAmB,EACnB,sBAAsB,EACtB,gBAAgB,EAChB,oBAAoB,EACpB,YAAY,EACZ,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAMrB,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,eAAe,CAAC;IACpB,oBAAoB,CAAC,MAAM,EAAE,mBAAmB,GAAG,yBAAyB,CAAC;IAC7E,OAAO,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAChE,OAAO,CAAC,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CAC9D,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,cAAc,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;CAC7C,GAAG,YAAY,CAcf;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,GAAG,EAAE,OAAO,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,cAAc,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;CAC7C,GAAG,YAAY,CAgBf;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,cAAc,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;CAC7C,GAAG,YAAY,CAcf;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,GAC3D,oBAAoB,EAAE,GAAG,SAAS,CAWpC"}