@nyxa/automation 0.1.0

package/dist/events.d.ts

@@ -0,0 +1,55 @@
+import { AutomationError, type AutomationErrorDetails } from "./errors.js";
+import type { RunJournalContent } from "./run-journal.js";
+export interface AutomationEventBase {
+    readonly sequence: number;
+    readonly timestamp: string;
+    readonly workflowId: string;
+}
+export interface WorkflowStartedEvent extends AutomationEventBase {
+    readonly type: "workflow.started";
+}
+export interface WorkflowCompletedEvent extends AutomationEventBase {
+    readonly type: "workflow.completed";
+    readonly result: unknown;
+}
+export interface RunEventBase extends AutomationEventBase {
+    readonly harness: string | undefined;
+    readonly runId: string;
+    readonly runName: string | undefined;
+    readonly sessionId: string;
+    readonly sessionName: string | undefined;
+}
+export interface RunStartedEvent extends RunEventBase {
+    readonly type: "run.started";
+}
+export interface RunNativeEvent extends RunEventBase {
+    readonly type: "run.native";
+    readonly harness: string;
+    readonly native: {
+        readonly portable: false;
+        readonly event: unknown;
+    };
+}
+export interface RunCompletedEvent extends RunEventBase {
+    readonly type: "run.completed";
+    readonly harness: string;
+}
+export interface RunFailedEvent extends RunEventBase {
+    readonly type: "run.failed";
+    readonly error: AutomationErrorDetails;
+}
+export interface WorkflowFailedEvent extends AutomationEventBase {
+    readonly type: "workflow.failed";
+    readonly error: AutomationErrorDetails;
+}
+export type AutomationEvent = RunCompletedEvent | RunFailedEvent | RunNativeEvent | RunStartedEvent | WorkflowCompletedEvent | WorkflowFailedEvent | WorkflowStartedEvent;
+export type AutomationEventObserver = (event: AutomationEvent) => PromiseLike<void> | void;
+type PendingAutomationEvent = AutomationEvent extends infer TEvent ? TEvent extends AutomationEvent ? Omit<TEvent, "sequence" | "timestamp"> : never : never;
+export type AutomationEventSink = (event: AutomationEvent, content: RunJournalContent | undefined) => PromiseLike<void> | void;
+export declare class AutomationEventDispatcher {
+    #private;
+    constructor(observer: AutomationEventObserver | undefined, sink?: AutomationEventSink, observerFailure?: (error: AutomationError) => void);
+    get failed(): boolean;
+    emit(event: PendingAutomationEvent, content?: RunJournalContent): Promise<void>;
+}
+export {};

package/dist/events.js

@@ -0,0 +1,51 @@
+import { AutomationError } from "./errors.js";
+export class AutomationEventDispatcher {
+    #observerFailure;
+    #observer;
+    #sink;
+    #delivery = Promise.resolve();
+    #sequence = 0;
+    #failure;
+    constructor(observer, sink, observerFailure) {
+        this.#observer = observer;
+        this.#sink = sink;
+        this.#observerFailure = observerFailure;
+    }
+    get failed() {
+        return this.#failure !== undefined;
+    }
+    async emit(event, content) {
+        if (this.#observer === undefined && this.#sink === undefined) {
+            return;
+        }
+        const observableEvent = Object.freeze({
+            ...event,
+            sequence: this.#sequence,
+            timestamp: new Date().toISOString(),
+        });
+        this.#sequence += 1;
+        const delivery = this.#delivery.then(async () => {
+            if (this.#failure !== undefined) {
+                throw this.#failure;
+            }
+            const sinkDelivery = Promise.resolve(this.#sink?.(observableEvent, content));
+            try {
+                await this.#observer?.(observableEvent);
+            }
+            catch (cause) {
+                this.#failure = new AutomationError("EVENT_OBSERVER_FAILED", "The Automation Event observer failed.", {
+                    cause,
+                    runId: "runId" in event ? event.runId : undefined,
+                    sessionId: "sessionId" in event ? event.sessionId : undefined,
+                    workflowId: event.workflowId,
+                });
+                this.#observerFailure?.(this.#failure);
+                await sinkDelivery;
+                throw this.#failure;
+            }
+            await sinkDelivery;
+        });
+        this.#delivery = delivery.catch(() => undefined);
+        await delivery;
+    }
+}

package/dist/filesystem.d.ts

@@ -0,0 +1,2 @@
+export declare function isMissingFileError(error: unknown): boolean;
+export declare function isWithinDirectory(parent: string, candidate: string): boolean;

package/dist/filesystem.js

@@ -0,0 +1,13 @@
+import path from "node:path";
+export function isMissingFileError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
+export function isWithinDirectory(parent, candidate) {
+    const relative = path.relative(parent, candidate);
+    return (relative === "" ||
+        (relative !== ".." &&
+            !relative.startsWith(`..${path.sep}`) &&
+            !path.isAbsolute(relative)));
+}

package/dist/harness-process.d.ts

@@ -0,0 +1,39 @@
+import type { Readable, Writable } from "node:stream";
+import { AutomationError } from "./errors.js";
+export interface HarnessProcessResult {
+    readonly exitCode: number | null;
+    readonly stderr: string;
+    readonly stdout: string;
+}
+export interface HarnessProcessOptions {
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly forceSignal?: AbortSignal;
+    readonly onStdoutLine?: (line: string) => Promise<void>;
+    readonly signal?: AbortSignal;
+}
+export interface HarnessProtocolProcess {
+    readonly input: Writable;
+    readonly output: Readable;
+    onInterrupt(handler: () => PromiseLike<void> | void): void;
+}
+export interface HarnessProtocolProcessResult<TValue> {
+    readonly exitCode: number | null;
+    readonly stderr: string;
+    readonly value: TValue;
+}
+export interface HarnessPreflightOptions {
+    readonly harnessName: string;
+    readonly minimumVersion: readonly [number, number, number];
+    readonly unsupportedVersionMessage: string;
+    readonly versionPattern: RegExp;
+}
+export interface HarnessExecutableInspection {
+    readonly executable: string;
+    readonly version: string;
+}
+export declare function createHarnessPreflight(options: HarnessPreflightOptions): (executable: string, environment?: NodeJS.ProcessEnv, processOptions?: Pick<HarnessProcessOptions, "forceSignal" | "signal">) => Promise<string>;
+export declare function inspectHarnessExecutable(executable: string, options: HarnessPreflightOptions, environment?: NodeJS.ProcessEnv, processOptions?: Pick<HarnessProcessOptions, "forceSignal" | "signal">): Promise<HarnessExecutableInspection>;
+export declare function runHarnessProcess(executable: string, arguments_: readonly string[], workingDirectory: string, harnessName: string, options?: HarnessProcessOptions): Promise<HarnessProcessResult>;
+export declare function runHarnessProtocolProcess<TValue>(executable: string, arguments_: readonly string[], workingDirectory: string, harnessName: string, interact: (process: HarnessProtocolProcess) => Promise<TValue>, options?: Pick<HarnessProcessOptions, "environment" | "forceSignal" | "signal">): Promise<HarnessProtocolProcessResult<TValue>>;
+export declare function harnessProcessFailureCause(stderr: string): Error | undefined;
+export declare function harnessProcessExitError(harnessName: string, result: HarnessProcessResult): AutomationError;

package/dist/harness-process.js

@@ -0,0 +1,359 @@
+import { spawn, } from "node:child_process";
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { throwIfAborted } from "./cancellation.js";
+import { AutomationError } from "./errors.js";
+export function createHarnessPreflight(options) {
+    const cache = new Map();
+    return async (executable, environment = process.env, processOptions = {}) => {
+        const resolvedExecutable = await resolveHarnessExecutable(executable, options.harnessName, environment);
+        const cachedExecutable = cache.get(resolvedExecutable);
+        if (cachedExecutable !== undefined) {
+            return cachedExecutable;
+        }
+        const inspection = await inspectResolvedHarness(resolvedExecutable, options, environment, processOptions);
+        cache.set(resolvedExecutable, inspection.executable);
+        return inspection.executable;
+    };
+}
+export async function inspectHarnessExecutable(executable, options, environment = process.env, processOptions = {}) {
+    const resolvedExecutable = await resolveHarnessExecutable(executable, options.harnessName, environment);
+    return inspectResolvedHarness(resolvedExecutable, options, environment, processOptions);
+}
+async function inspectResolvedHarness(resolvedExecutable, options, environment, processOptions) {
+    const versionProcess = await runHarnessProcess(resolvedExecutable, ["--version"], process.cwd(), options.harnessName, { environment, ...processOptions });
+    if (versionProcess.exitCode !== 0) {
+        throw new AutomationError("HARNESS_PROCESS_FAILED", `${options.harnessName} version check exited with status ${String(versionProcess.exitCode)}.`, { cause: harnessProcessFailureCause(versionProcess.stderr) });
+    }
+    const version = parseHarnessVersion(versionProcess.stdout, options.versionPattern);
+    if (version === undefined ||
+        !supportsMinimumVersion(version.parts, options.minimumVersion)) {
+        throw new AutomationError("HARNESS_VERSION_UNSUPPORTED", version === undefined
+            ? options.unsupportedVersionMessage
+            : `${options.unsupportedVersionMessage} Found ${version.display}.`);
+    }
+    return {
+        executable: resolvedExecutable,
+        version: version.display,
+    };
+}
+async function resolveHarnessExecutable(executable, harnessName, environment) {
+    const candidates = executable.includes(path.sep)
+        ? [path.resolve(executable)]
+        : (environment.PATH ?? "")
+            .split(path.delimiter)
+            .filter((entry) => entry.length > 0)
+            .map((entry) => path.join(entry, executable));
+    let resolutionCause;
+    for (const candidate of candidates) {
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch (cause) {
+            resolutionCause = cause;
+        }
+    }
+    throw new AutomationError("HARNESS_NOT_FOUND", `Could not resolve the ${harnessName} executable: ${executable}`, { cause: resolutionCause });
+}
+export async function runHarnessProcess(executable, arguments_, workingDirectory, harnessName, options = {}) {
+    throwIfAborted(options.signal);
+    const lifecycle = createHarnessProcessLifecycle(executable, arguments_, workingDirectory, harnessName, "ignore", options);
+    const stdout = consumeStandardOutput(lifecycle.child.stdout, options.onStdoutLine);
+    try {
+        const [exitCode, stdoutValue, stderrValue] = await Promise.all([
+            lifecycle.completion,
+            stdout,
+            lifecycle.stderr,
+        ]);
+        lifecycle.throwIfInterrupted();
+        return { exitCode, stderr: stderrValue, stdout: stdoutValue };
+    }
+    catch (cause) {
+        lifecycle.terminate();
+        await Promise.allSettled([
+            lifecycle.completion,
+            stdout,
+            lifecycle.stderr,
+        ]);
+        lifecycle.forceTerminate();
+        await lifecycle.waitForTreeTerminations();
+        lifecycle.throwIfInterrupted();
+        throw cause;
+    }
+    finally {
+        lifecycle.dispose();
+    }
+}
+export async function runHarnessProtocolProcess(executable, arguments_, workingDirectory, harnessName, interact, options = {}) {
+    throwIfAborted(options.signal);
+    const lifecycle = createHarnessProcessLifecycle(executable, arguments_, workingDirectory, harnessName, "pipe", options);
+    const inputStream = lifecycle.child.stdin;
+    let interruptHandler;
+    lifecycle.setInterruptHandler(() => interruptHandler?.());
+    const interaction = Promise.resolve().then(() => interact({
+        input: inputStream,
+        output: lifecycle.child.stdout,
+        onInterrupt(handler) {
+            interruptHandler = handler;
+        },
+    }));
+    try {
+        const value = await interaction;
+        await closeWritableStream(inputStream);
+        const [exitCode, stderr] = await Promise.all([
+            lifecycle.completion,
+            lifecycle.stderr,
+        ]);
+        lifecycle.throwIfInterrupted();
+        return { exitCode, stderr, value };
+    }
+    catch (cause) {
+        lifecycle.terminate();
+        const [, processOutcome, stderrOutcome] = await Promise.allSettled([
+            interaction,
+            lifecycle.completion,
+            lifecycle.stderr,
+        ]);
+        lifecycle.forceTerminate();
+        await lifecycle.waitForTreeTerminations();
+        lifecycle.throwIfInterrupted();
+        if (processOutcome?.status === "rejected") {
+            throw processOutcome.reason;
+        }
+        if (processOutcome?.status === "fulfilled" &&
+            processOutcome.value !== null &&
+            processOutcome.value !== 0) {
+            throw harnessProcessExitError(harnessName, {
+                exitCode: processOutcome.value,
+                stderr: stderrOutcome?.status === "fulfilled" ? stderrOutcome.value : "",
+                stdout: "",
+            });
+        }
+        throw cause;
+    }
+    finally {
+        lifecycle.dispose();
+    }
+}
+function createHarnessProcessLifecycle(executable, arguments_, workingDirectory, harnessName, input, options) {
+    const detached = process.platform !== "win32";
+    const child = spawn(executable, arguments_, {
+        cwd: workingDirectory,
+        detached,
+        env: options.environment,
+        stdio: [input, "pipe", "pipe"],
+    });
+    let interruption;
+    let interruptHandler;
+    let forceTimer;
+    const treeTerminations = [];
+    const terminate = (signal) => {
+        if (child.pid === undefined) {
+            return;
+        }
+        if (process.platform === "win32") {
+            const taskkill = spawn("taskkill", [
+                "/PID",
+                String(child.pid),
+                "/T",
+                ...(signal === "SIGKILL" ? ["/F"] : []),
+            ], { stdio: "ignore", windowsHide: true });
+            treeTerminations.push(new Promise((resolve) => {
+                taskkill.once("error", () => {
+                    if (child.exitCode === null && child.signalCode === null) {
+                        child.kill(signal);
+                    }
+                    resolve();
+                });
+                taskkill.once("close", () => resolve());
+            }));
+            return;
+        }
+        try {
+            process.kill(-child.pid, signal);
+        }
+        catch (cause) {
+            if (!isMissingProcess(cause)) {
+                throw cause;
+            }
+        }
+    };
+    const scheduleForcedTermination = () => {
+        if (forceTimer !== undefined) {
+            return;
+        }
+        forceTimer = setTimeout(() => terminate("SIGKILL"), 5_000);
+        forceTimer.unref();
+    };
+    const interrupt = () => {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            return;
+        }
+        interruption = options.signal?.reason;
+        scheduleForcedTermination();
+        if (interruptHandler === undefined) {
+            terminate("SIGTERM");
+            return;
+        }
+        void Promise.resolve().then(interruptHandler).then(() => terminate("SIGTERM"), () => terminate("SIGTERM"));
+    };
+    const force = () => {
+        if (child.exitCode === null && child.signalCode === null) {
+            interruption ??= options.forceSignal?.reason ?? options.signal?.reason;
+            terminate("SIGKILL");
+        }
+    };
+    options.signal?.addEventListener("abort", interrupt, { once: true });
+    options.forceSignal?.addEventListener("abort", force, { once: true });
+    if (options.signal?.aborted === true) {
+        interrupt();
+    }
+    if (options.forceSignal?.aborted === true) {
+        force();
+    }
+    const completion = new Promise((resolve, reject) => {
+        child.once("error", (cause) => {
+            reject(new AutomationError("HARNESS_PROCESS_FAILED", `Could not start the ${harnessName} process.`, { cause }));
+        });
+        child.once("close", resolve);
+    });
+    const stderr = consumeStream(child.stderr);
+    return {
+        child,
+        completion,
+        dispose() {
+            if (forceTimer !== undefined) {
+                clearTimeout(forceTimer);
+            }
+            options.signal?.removeEventListener("abort", interrupt);
+            options.forceSignal?.removeEventListener("abort", force);
+        },
+        forceTerminate() {
+            terminate("SIGKILL");
+        },
+        setInterruptHandler(handler) {
+            interruptHandler = handler;
+        },
+        terminate() {
+            if (child.exitCode === null && child.signalCode === null) {
+                terminate("SIGTERM");
+                scheduleForcedTermination();
+            }
+        },
+        throwIfInterrupted() {
+            if (interruption !== undefined) {
+                throw interruption;
+            }
+        },
+        async waitForTreeTerminations() {
+            await Promise.allSettled(treeTerminations);
+        },
+        stderr,
+    };
+}
+async function closeWritableStream(stream) {
+    if (stream.destroyed || stream.writableEnded) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        stream.end((error) => {
+            if (error === undefined || error === null) {
+                resolve();
+                return;
+            }
+            reject(error);
+        });
+    });
+}
+function isMissingProcess(cause) {
+    return (typeof cause === "object" &&
+        cause !== null &&
+        cause.code === "ESRCH");
+}
+async function consumeStandardOutput(stream, onLine) {
+    const chunks = [];
+    const decoder = new StringDecoder("utf8");
+    let pending = "";
+    for await (const chunk of stream) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        chunks.push(buffer);
+        if (onLine === undefined) {
+            continue;
+        }
+        pending += decoder.write(buffer);
+        let newline = pending.indexOf("\n");
+        while (newline !== -1) {
+            const line = pending.slice(0, newline).replace(/\r$/u, "");
+            pending = pending.slice(newline + 1);
+            await onLine(line);
+            newline = pending.indexOf("\n");
+        }
+    }
+    pending += decoder.end();
+    if (onLine !== undefined && pending.length > 0) {
+        await onLine(pending.replace(/\r$/u, ""));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function consumeStream(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function supportsMinimumVersion(version, minimum) {
+    const numericVersion = version.slice(0, 3);
+    for (const [index, minimumPart] of minimum.entries()) {
+        const difference = (numericVersion[index] ?? 0) - minimumPart;
+        if (difference !== 0) {
+            return difference > 0;
+        }
+    }
+    return version[3] === undefined;
+}
+function parseHarnessVersion(output, pattern) {
+    const match = pattern.exec(output);
+    if (match === null ||
+        match[1] === undefined ||
+        match[2] === undefined ||
+        match[3] === undefined) {
+        return undefined;
+    }
+    const parts = [
+        Number(match[1]),
+        Number(match[2]),
+        Number(match[3]),
+        match[4],
+    ];
+    return {
+        display: `${String(parts[0])}.${String(parts[1])}.${String(parts[2])}${parts[3] === undefined ? "" : `-${parts[3]}`}`,
+        parts,
+    };
+}
+export function harnessProcessFailureCause(stderr) {
+    const diagnostic = stderr.trim();
+    return diagnostic.length === 0 ? undefined : new Error(diagnostic);
+}
+export function harnessProcessExitError(harnessName, result) {
+    const diagnostic = result.stderr;
+    const nativeCause = harnessProcessFailureCause(diagnostic);
+    if (isAuthenticationFailure(diagnostic)) {
+        return new AutomationError("HARNESS_NOT_AUTHENTICATED", `${harnessName} is not authenticated.`, { cause: nativeCause });
+    }
+    if (isModelEffortCapabilityFailure(diagnostic)) {
+        return new AutomationError("HARNESS_CAPABILITY_UNSUPPORTED", `${harnessName} does not support the requested model and effort combination.`, { cause: nativeCause });
+    }
+    return new AutomationError("HARNESS_PROCESS_FAILED", `${harnessName} exited with status ${String(result.exitCode)}.`, { cause: harnessProcessFailureCause(result.stderr) });
+}
+function isAuthenticationFailure(diagnostic) {
+    return /\b(?:authentication required|not authenticated|not logged in|unauthenticated|unauthorized)\b|\bplease (?:run )?(?:\/?login|log in)\b/iu.test(diagnostic);
+}
+function isModelEffortCapabilityFailure(diagnostic) {
+    return (/\bmodel\b/iu.test(diagnostic) &&
+        /\b(?:effort|reasoning|variant)\b/iu.test(diagnostic) &&
+        /\b(?:invalid|not support(?:ed)?|unavailable|unsupported)\b/iu.test(diagnostic));
+}

package/dist/harness-prompt.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessRunRequest } from "./harness.js";
+export declare function promptWithOutputContract(request: Pick<HarnessRunRequest, "output" | "prompt">): string;

package/dist/harness-prompt.js

@@ -0,0 +1,14 @@
+export function promptWithOutputContract(request) {
+    if (request.output === undefined) {
+        return request.prompt;
+    }
+    return [
+        request.prompt,
+        "",
+        "<automation_output_contract>",
+        "Return exactly one JSON value and no Markdown, commentary, or code fences.",
+        "The JSON value must satisfy this JSON Schema:",
+        JSON.stringify(request.output.toJSONSchema()),
+        "</automation_output_contract>",
+    ].join("\n");
+}

package/dist/harness.d.ts

@@ -0,0 +1,44 @@
+import type { InferSchema, Schema } from "./schema.js";
+declare const harnessBrand: unique symbol;
+export interface Harness {
+    readonly [harnessBrand]: true;
+}
+export type AccessPolicy = "read" | "write-workspace" | "full";
+export type ApprovalPolicy = "deny" | "auto";
+export type EnvironmentOverrides = Readonly<Record<string, string | undefined>>;
+export interface HarnessRunRequest {
+    readonly access: AccessPolicy;
+    readonly approval: ApprovalPolicy;
+    readonly emitNativeEvent: (event: unknown) => Promise<void>;
+    readonly environment: NodeJS.ProcessEnv;
+    readonly prompt: string;
+    readonly runId: string;
+    readonly signal: AbortSignal;
+    readonly forceSignal?: AbortSignal;
+    readonly nativeSessionId?: string;
+    readonly sessionReady?: (nativeSessionId: string) => void;
+    readonly start: () => Promise<void>;
+    readonly workingDirectory: string;
+    readonly output?: Schema<any, boolean>;
+}
+export declare function harnessProcessControls(request: HarnessRunRequest): {
+    readonly forceSignal?: AbortSignal;
+    readonly signal: AbortSignal;
+};
+export interface HarnessRunResult {
+    readonly nativeSessionId: string;
+    readonly value: unknown;
+}
+export declare function harnessName(harness: Harness | undefined): string | undefined;
+interface HarnessAdapter {
+    readonly name: string;
+    run(request: HarnessRunRequest): Promise<HarnessRunResult>;
+}
+export declare function createHarness(adapter: HarnessAdapter): Harness;
+export declare function runHarness<TOutputSchema extends Schema<any, boolean>>(harness: Harness | undefined, request: HarnessRunRequest & {
+    readonly output: TOutputSchema;
+}): Promise<InferSchema<TOutputSchema>>;
+export declare function runHarness(harness: Harness | undefined, request: HarnessRunRequest & {
+    readonly output?: undefined;
+}): Promise<string>;
+export {};

package/dist/harness.js

@@ -0,0 +1,68 @@
+import { AutomationError, contextualizeAutomationError, } from "./errors.js";
+const harnessBrand = Symbol.for("@nyxa/automation/harness");
+const harnessAdapter = Symbol.for("@nyxa/automation/harness-adapter");
+const headlessRunInstruction = [
+    "<automation_headless_run>",
+    "This Run is headless. Do not ask the user questions or invoke tools that request interactive input.",
+    "If more information is required, express that need only in the final response and, when one is declared, according to the Output Contract.",
+    "</automation_headless_run>",
+].join("\n");
+export function harnessProcessControls(request) {
+    return {
+        ...(request.forceSignal === undefined
+            ? {}
+            : { forceSignal: request.forceSignal }),
+        signal: request.signal,
+    };
+}
+export function harnessName(harness) {
+    return isInternalHarness(harness) ? harness[harnessAdapter].name : undefined;
+}
+export function createHarness(adapter) {
+    return Object.freeze({
+        [harnessBrand]: true,
+        [harnessAdapter]: adapter,
+    });
+}
+export function runHarness(harness, request) {
+    if (!isInternalHarness(harness)) {
+        throw new AutomationError("HARNESS_REQUIRED", "A Run requires an explicit Harness or a Workflow default Harness.", { runId: request.runId });
+    }
+    return runAndValidate(harness[harnessAdapter], request);
+}
+async function runAndValidate(adapter, request) {
+    let result;
+    try {
+        result = await adapter.run({
+            ...request,
+            prompt: `${request.prompt}\n\n${headlessRunInstruction}`,
+        });
+    }
+    catch (cause) {
+        throw contextualizeAutomationError(cause, "HARNESS_PROCESS_FAILED", `The ${adapter.name} Run failed unexpectedly.`, {
+            harness: adapter.name,
+            runId: request.runId,
+        });
+    }
+    request.sessionReady?.(result.nativeSessionId);
+    if (request.output === undefined) {
+        return result.value;
+    }
+    const parsedOutput = request.output.safeParse(result.value);
+    if (!parsedOutput.success) {
+        throw new AutomationError("RUN_OUTPUT_INVALID", `The ${adapter.name} Run output does not satisfy its contract.`, {
+            cause: parsedOutput.error,
+            harness: adapter.name,
+            runId: request.runId,
+        });
+    }
+    return parsedOutput.data;
+}
+function isInternalHarness(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (candidate[harnessBrand] === true &&
+        typeof candidate[harnessAdapter]?.run === "function");
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { codex, type CodexEffort, type CodexOptions, } from "./codex.js";
+export { claudeCode, type ClaudeCodeEffort, type ClaudeCodeOptions, } from "./claude-code.js";
+export { kimiCode, type KimiCodeOptions } from "./kimi-code.js";
+export { opencode, type OpenCodeOptions } from "./opencode.js";
+export { AutomationError, isAutomationError, type AutomationErrorCode, type AutomationErrorDetails, type AutomationErrorOptions, } from "./errors.js";
+export { type AutomationEvent, type AutomationEventBase, type AutomationEventObserver, type RunCompletedEvent, type RunEventBase, type RunFailedEvent, type RunNativeEvent, type RunStartedEvent, type WorkflowCompletedEvent, type WorkflowFailedEvent, type WorkflowStartedEvent, } from "./events.js";
+export { type InferSchema, type JSONSchema, type SafeParseResult, type Schema, type SchemaIssueCode, type SchemaIssue, type SchemaPathSegment, SchemaValidationError, schema, } from "./schema.js";
+export { type AccessPolicy, type ApprovalPolicy, type EnvironmentOverrides, type Harness, } from "./harness.js";
+export { defineWorkflow, executeWorkflow, type ExecuteWorkflowOptions, type ExecuteWorkflowWithoutInputOptions, type JsonPrimitive, type JsonValue, type RunOptions, type Session, type SessionOptions, type SessionRunOptions, type StructuredSessionRunOptions, type StructuredRunOptions, type WorkflowDefinition, type WorkflowDefinitionOptions, type WorkflowContext, type WorkflowResult, } from "./workflow.js";
+export type { RunJournalMode } from "./run-journal.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { codex, } from "./codex.js";
+export { claudeCode, } from "./claude-code.js";
+export { kimiCode } from "./kimi-code.js";
+export { opencode } from "./opencode.js";
+export { AutomationError, isAutomationError, } from "./errors.js";
+export {} from "./events.js";
+export { SchemaValidationError, schema, } from "./schema.js";
+export {} from "./harness.js";
+export { defineWorkflow, executeWorkflow, } from "./workflow.js";