@nyxa/automation 0.1.0

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function initializeProject(arguments_: readonly string[], invocationDirectory?: string): Promise<string>;

package/dist/init.js

@@ -0,0 +1,305 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { diagnoseEnvironment } from "./doctor.js";
+import { isMissingFileError } from "./filesystem.js";
+import { readStandardInput } from "./standard-input.js";
+export async function initializeProject(arguments_, invocationDirectory = process.cwd()) {
+    const parsed = parseInitArguments(arguments_);
+    const prompt = !parsed.yes && (parsed.harness === undefined || parsed.install)
+        ? await createPrompt()
+        : undefined;
+    const manifestPath = path.join(invocationDirectory, "package.json");
+    try {
+        try {
+            JSON.parse(await readFile(manifestPath, "utf8"));
+        }
+        catch (error) {
+            if (isMissingFileError(error)) {
+                throw new Error("init requires a package.json from an existing npm project.");
+            }
+            throw error;
+        }
+        const harness = await resolveHarness(parsed, invocationDirectory, prompt);
+        const install = await resolveInstall(parsed, prompt);
+        const workflowPath = path.resolve(invocationDirectory, parsed.workflowPath);
+        if (await pathExists(workflowPath)) {
+            throw workflowExistsError(parsed.workflowPath);
+        }
+        const packageManager = install
+            ? await detectPackageManager(invocationDirectory)
+            : undefined;
+        if (packageManager !== undefined) {
+            await installAutomationDependency(packageManager, invocationDirectory);
+        }
+        await mkdir(path.dirname(workflowPath), { recursive: true });
+        try {
+            await writeFile(workflowPath, workflowExample(harness), {
+                encoding: "utf8",
+                flag: "wx",
+            });
+        }
+        catch (error) {
+            if (isExistingFileError(error)) {
+                throw workflowExistsError(parsed.workflowPath);
+            }
+            throw error;
+        }
+        let output = `Created ${parsed.workflowPath}.\n`;
+        if (packageManager !== undefined) {
+            output += `Installed @nyxa/automation with ${packageManager.displayName}.\n`;
+        }
+        return output;
+    }
+    finally {
+        prompt?.close();
+    }
+}
+async function resolveHarness(arguments_, invocationDirectory, prompt) {
+    if (arguments_.harness !== undefined) {
+        return arguments_.harness;
+    }
+    if (!arguments_.yes) {
+        const choice = await requirePrompt(prompt).question("Choose a Harness:\n  1) Codex\n  2) Claude Code\n  3) Kimi Code\n  4) OpenCode\nHarness [1/2/3/4]: ");
+        if (choice === "1" || choice === "codex") {
+            return "codex";
+        }
+        if (choice === "2" || choice === "claude-code") {
+            return "claude-code";
+        }
+        if (choice === "3" || choice === "kimi-code") {
+            return "kimi-code";
+        }
+        if (choice === "4" || choice === "opencode") {
+            return "opencode";
+        }
+        throw new Error("Choose Codex, Claude Code, Kimi Code, or OpenCode, or pass --harness explicitly.");
+    }
+    const candidates = [
+        "codex",
+        "claude-code",
+        "kimi-code",
+        "opencode",
+    ];
+    const diagnoses = await Promise.all(candidates.map(async (harness) => ({
+        harness,
+        result: await diagnoseEnvironment({
+            environment: process.env,
+            harness,
+            invocationDirectory,
+            localPackage: { binaryAvailable: true, version: "current" },
+        }),
+    })));
+    const operational = diagnoses
+        .filter(({ result }) => result.ready)
+        .map(({ harness }) => harness);
+    if (operational.length !== 1) {
+        throw new Error(`Automatic Harness selection requires exactly one operational Harness; found ${String(operational.length)}. Pass --harness codex, --harness claude-code, --harness kimi-code, or --harness opencode.`);
+    }
+    return operational[0];
+}
+async function resolveInstall(arguments_, prompt) {
+    if (!arguments_.install || arguments_.yes) {
+        return arguments_.install;
+    }
+    const answer = await requirePrompt(prompt).question("Install @nyxa/automation as a development dependency? [Y/n] ");
+    if (answer === "" || answer === "y" || answer === "yes") {
+        return true;
+    }
+    if (answer === "n" || answer === "no") {
+        return false;
+    }
+    throw new Error("Answer yes or no to the dependency installation prompt.");
+}
+async function createPrompt() {
+    if (process.stdin.isTTY !== true) {
+        const answers = (await readStandardInput()).split(/\r?\n/u);
+        return {
+            close() { },
+            async question(message) {
+                process.stdout.write(message);
+                const answer = answers.shift();
+                if (answer === undefined) {
+                    throw new Error("Interactive input ended. Pass --yes, --no-install, and --harness for non-interactive use.");
+                }
+                return answer.trim().toLowerCase();
+            },
+        };
+    }
+    const { createInterface } = await import("node:readline/promises");
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return {
+        close() {
+            readline.close();
+        },
+        async question(message) {
+            return (await readline.question(message)).trim().toLowerCase();
+        },
+    };
+}
+function requirePrompt(prompt) {
+    if (prompt === undefined) {
+        throw new Error("Interactive input is unavailable.");
+    }
+    return prompt;
+}
+const PACKAGE_MANAGERS = [
+    {
+        displayName: "npm",
+        executable: "npm",
+        installArguments: ["install", "--save-dev", "@nyxa/automation"],
+        lockfile: "package-lock.json",
+    },
+    {
+        displayName: "pnpm",
+        executable: "pnpm",
+        installArguments: ["add", "--save-dev", "@nyxa/automation"],
+        lockfile: "pnpm-lock.yaml",
+    },
+    {
+        displayName: "Yarn",
+        executable: "yarn",
+        installArguments: ["add", "--dev", "@nyxa/automation"],
+        lockfile: "yarn.lock",
+    },
+];
+async function detectPackageManager(invocationDirectory) {
+    for (const packageManager of PACKAGE_MANAGERS) {
+        if (await pathExists(path.join(invocationDirectory, packageManager.lockfile))) {
+            return packageManager;
+        }
+    }
+    throw new Error("Could not detect npm, pnpm, or Yarn. Add the package manager lockfile first.");
+}
+async function installAutomationDependency(packageManager, invocationDirectory) {
+    const { spawn } = await import("node:child_process");
+    const exitCode = await new Promise((resolve, reject) => {
+        const child = spawn(packageManager.executable, packageManager.installArguments, {
+            cwd: invocationDirectory,
+            env: process.env,
+            stdio: "inherit",
+        });
+        child.once("error", reject);
+        child.once("exit", (code) => resolve(code ?? 1));
+    });
+    if (exitCode !== 0) {
+        throw new Error(`${packageManager.displayName} could not install @nyxa/automation (exit ${String(exitCode)}).`);
+    }
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+function parseInitArguments(arguments_) {
+    const workflowPath = arguments_[0];
+    if (workflowPath === undefined || workflowPath.startsWith("-")) {
+        throw new Error("init requires a Workflow path.");
+    }
+    let harness;
+    let install = true;
+    let yes = false;
+    let index = 1;
+    while (index < arguments_.length) {
+        const option = arguments_[index];
+        if (option === "--no-install") {
+            if (!install) {
+                throw new Error("The --no-install option may only be provided once.");
+            }
+            install = false;
+            index += 1;
+            continue;
+        }
+        if (option === "--yes") {
+            if (yes) {
+                throw new Error("The --yes option may only be provided once.");
+            }
+            yes = true;
+            index += 1;
+            continue;
+        }
+        if (option === "--harness") {
+            if (harness !== undefined) {
+                throw new Error("The --harness option may only be provided once.");
+            }
+            const value = arguments_[index + 1];
+            if (value !== "codex" &&
+                value !== "claude-code" &&
+                value !== "kimi-code" &&
+                value !== "opencode") {
+                throw new Error("The --harness option requires codex, claude-code, kimi-code, or opencode.");
+            }
+            harness = value;
+            index += 2;
+            continue;
+        }
+        throw new Error(`Unexpected init argument: ${String(option)}`);
+    }
+    return {
+        ...(harness === undefined ? {} : { harness }),
+        install,
+        workflowPath,
+        yes,
+    };
+}
+function workflowExample(harness) {
+    const factory = harness === "codex"
+        ? "codex"
+        : harness === "claude-code"
+            ? "claudeCode"
+            : harness === "kimi-code"
+                ? "kimiCode"
+                : "opencode";
+    const runPolicy = harness === "kimi-code" || harness === "opencode"
+        ? '{ access: "full", approval: "deny", output: outcome }'
+        : '{ access: "read", output: outcome }';
+    const accessWarning = harness === "opencode"
+        ? "    // OpenCode requires full access because its CLI does not sandbox shell commands to the Workspace.\n"
+        : "";
+    return `import { ${factory}, defineWorkflow, schema } from "@nyxa/automation";
+
+const outcome = schema.union([
+  schema.object({
+    status: schema.literal("completed").describe("The request was completed."),
+    summary: schema.string().describe("A concise summary of the result."),
+  }).describe("A completed request."),
+  schema.object({
+    status: schema.literal("needs_input").describe("More information is required."),
+    question: schema.string().describe("The question the user must answer."),
+  }).describe("A request that needs user input."),
+]).describe("The structured outcome of the Run.");
+
+const workflow = defineWorkflow({
+  harness: ${factory}(),
+  async run(context) {
+${accessWarning}    const result = await context.run(
+      "Inspect this project and summarize its purpose. Ask one question when essential context is missing.",
+      ${runPolicy},
+    );
+
+    if (result.status === "needs_input") {
+      return { status: "needs_input", question: result.question };
+    }
+
+    return { status: "completed", summary: result.summary };
+  },
+});
+
+export default workflow;
+`;
+}
+function isExistingFileError(error) {
+    return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+function workflowExistsError(workflowPath) {
+    return new Error(`Refusing to overwrite the existing Workflow at ${workflowPath}.`);
+}

package/dist/json.d.ts

@@ -0,0 +1,4 @@
+export type JsonPrimitive = boolean | null | number | string;
+export type JsonValue = JsonPrimitive | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};

package/dist/json.js

@@ -0,0 +1 @@
+export {};

package/dist/kimi-code.d.ts

@@ -0,0 +1,16 @@
+import { type Harness } from "./harness.js";
+import type { NoExtraKeys } from "./type-utils.js";
+export declare const KIMI_CODE_HARNESS_PREFLIGHT: {
+    readonly harnessName: "Kimi Code";
+    readonly minimumVersion: readonly [0, 28, 1];
+    readonly unsupportedVersionMessage: "Kimi Code CLI 0.28.1 or later is required.";
+    readonly versionPattern: RegExp;
+};
+export interface KimiCodeOptions {
+    readonly executable?: string;
+    readonly model?: string;
+    readonly effort?: string;
+}
+export declare function kimiCode(): Harness;
+export declare function kimiCode<const TOptions extends KimiCodeOptions>(options: TOptions & NoExtraKeys<TOptions, KimiCodeOptions>): Harness;
+export declare function verifyKimiCodeAuthentication(executable: string, workingDirectory: string, environment: NodeJS.ProcessEnv): Promise<void>;

package/dist/kimi-code.js

@@ -0,0 +1,299 @@
+import { Readable, Writable } from "node:stream";
+import { ClientSideConnection, PROTOCOL_VERSION, RequestError, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { AutomationError, isAutomationError } from "./errors.js";
+import { createHarnessPreflight, harnessProcessExitError, runHarnessProtocolProcess, } from "./harness-process.js";
+import { createHarness, harnessProcessControls, } from "./harness.js";
+import { promptWithOutputContract } from "./harness-prompt.js";
+const HARNESS_NAME = "Kimi Code";
+export const KIMI_CODE_HARNESS_PREFLIGHT = {
+    harnessName: HARNESS_NAME,
+    minimumVersion: [0, 28, 1],
+    unsupportedVersionMessage: "Kimi Code CLI 0.28.1 or later is required.",
+    versionPattern: /(?:\bkimi(?:[ -]code)?\s+)?(\d+)\.(\d+)\.(\d+)(?:-([0-9a-z.-]+))?(?:\+[0-9a-z.-]+)?(?:\s|$)/iu,
+};
+const preflightKimiCode = createHarnessPreflight(KIMI_CODE_HARNESS_PREFLIGHT);
+export function kimiCode(options = {}) {
+    const configuredOptions = Object.freeze({ ...options });
+    return createHarness({
+        name: HARNESS_NAME,
+        async run(request) {
+            if (request.access !== "full") {
+                throw new AutomationError("HARNESS_CAPABILITY_UNSUPPORTED", "Kimi Code cannot guarantee read or write-workspace Access Policies.");
+            }
+            const executable = await preflightKimiCode(configuredOptions.executable ?? "kimi", request.environment, harnessProcessControls(request));
+            return executeKimiCode(executable, configuredOptions, request);
+        },
+    });
+}
+export async function verifyKimiCodeAuthentication(executable, workingDirectory, environment) {
+    try {
+        const result = await runHarnessProtocolProcess(executable, ["acp"], workingDirectory, HARNESS_NAME, async (process) => {
+            const connection = createKimiConnection(process.input, process.output, {
+                approval: "deny",
+                async sessionUpdate() { },
+            });
+            await initializeAndAuthenticate(connection);
+        }, { environment });
+        if (result.exitCode !== 0) {
+            throw harnessProcessExitError(HARNESS_NAME, {
+                exitCode: result.exitCode,
+                stderr: result.stderr,
+                stdout: "",
+            });
+        }
+    }
+    catch (cause) {
+        throw mapKimiCodeError(cause, "authentication");
+    }
+}
+async function executeKimiCode(executable, options, request) {
+    await request.start();
+    try {
+        const result = await runHarnessProtocolProcess(executable, ["acp"], request.workingDirectory, HARNESS_NAME, async (process) => {
+            let activeSessionId;
+            let callbackFailure;
+            const pendingUpdates = new Set();
+            let receivedAgentMessage = false;
+            let response = "";
+            const connection = createKimiConnection(process.input, process.output, {
+                approval: request.approval,
+                sessionUpdate(notification) {
+                    const update = processKimiCodeUpdate(notification, () => activeSessionId, request, (text) => {
+                        receivedAgentMessage = true;
+                        response += text;
+                    }).catch((cause) => {
+                        callbackFailure ??= cause;
+                        throw cause;
+                    });
+                    pendingUpdates.add(update);
+                    void update.then(() => pendingUpdates.delete(update), () => pendingUpdates.delete(update));
+                    return update;
+                },
+            });
+            process.onInterrupt(async () => {
+                if (activeSessionId !== undefined) {
+                    await connection.cancel({ sessionId: activeSessionId });
+                }
+            });
+            const initialized = await initializeAndAuthenticate(connection);
+            let configOptions;
+            if (request.nativeSessionId === undefined) {
+                const created = await connection.newSession({
+                    cwd: request.workingDirectory,
+                    mcpServers: [],
+                });
+                activeSessionId = requireSessionId(created.sessionId);
+                configOptions = created.configOptions ?? [];
+            }
+            else {
+                if (initialized.agentCapabilities?.sessionCapabilities?.resume ===
+                    undefined ||
+                    initialized.agentCapabilities.sessionCapabilities.resume === null) {
+                    throw new AutomationError("HARNESS_CAPABILITY_UNSUPPORTED", "Kimi Code did not advertise ACP Session resume support.");
+                }
+                activeSessionId = requireSessionId(request.nativeSessionId);
+                const resumed = await connection.resumeSession({
+                    cwd: request.workingDirectory,
+                    mcpServers: [],
+                    sessionId: activeSessionId,
+                });
+                configOptions = resumed.configOptions ?? [];
+            }
+            await applyKimiCodeConfiguration(connection, activeSessionId, configOptions, options, request.approval);
+            const prompt = await connection.prompt({
+                prompt: [
+                    {
+                        type: "text",
+                        text: promptWithOutputContract(request),
+                    },
+                ],
+                sessionId: activeSessionId,
+            });
+            await Promise.allSettled([...pendingUpdates]);
+            if (callbackFailure !== undefined) {
+                throw callbackFailure;
+            }
+            return {
+                nativeSessionId: activeSessionId,
+                receivedAgentMessage,
+                response,
+                stopReason: prompt.stopReason,
+            };
+        }, {
+            environment: request.environment,
+            ...harnessProcessControls(request),
+        });
+        if (result.exitCode !== 0) {
+            throw harnessProcessExitError(HARNESS_NAME, {
+                exitCode: result.exitCode,
+                stderr: result.stderr,
+                stdout: "",
+            });
+        }
+        if (result.value.stopReason !== "end_turn") {
+            request.sessionReady?.(result.value.nativeSessionId);
+            throw new AutomationError("HARNESS_PROCESS_FAILED", `Kimi Code stopped the Run with reason ${result.value.stopReason}.`);
+        }
+        if (!result.value.receivedAgentMessage) {
+            if (request.output !== undefined) {
+                request.sessionReady?.(result.value.nativeSessionId);
+                throw new AutomationError("RUN_OUTPUT_INVALID", "The Kimi Code Run completed without structured output.", { cause: new TypeError("Missing Kimi Code agent message.") });
+            }
+            throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Kimi Code completed without a final agent message.");
+        }
+        if (request.output === undefined) {
+            return {
+                nativeSessionId: result.value.nativeSessionId,
+                value: result.value.response,
+            };
+        }
+        try {
+            return {
+                nativeSessionId: result.value.nativeSessionId,
+                value: JSON.parse(result.value.response),
+            };
+        }
+        catch (cause) {
+            request.sessionReady?.(result.value.nativeSessionId);
+            throw new AutomationError("RUN_OUTPUT_INVALID", "The Kimi Code Run returned malformed structured output.", { cause });
+        }
+    }
+    catch (cause) {
+        throw mapKimiCodeError(cause, "run");
+    }
+}
+async function processKimiCodeUpdate(notification, activeSessionId, request, appendResponse) {
+    await request.emitNativeEvent({
+        method: "session/update",
+        params: notification,
+    });
+    const sessionId = activeSessionId();
+    if (sessionId !== undefined && notification.sessionId !== sessionId) {
+        throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Kimi Code emitted an update for a different Session.");
+    }
+    if (notification.update.sessionUpdate === "agent_message_chunk" &&
+        notification.update.content.type === "text") {
+        appendResponse(notification.update.content.text);
+    }
+}
+function createKimiConnection(input, output, options) {
+    const stream = ndJsonStream(Writable.toWeb(input), Readable.toWeb(output));
+    return new ClientSideConnection(() => ({
+        requestPermission(request) {
+            return resolvePermissionRequest(request, options.approval);
+        },
+        sessionUpdate: options.sessionUpdate,
+    }), stream);
+}
+async function initializeAndAuthenticate(connection) {
+    const initialized = await connection.initialize({
+        clientCapabilities: {},
+        clientInfo: { name: "@nyxa/automation", version: "0.1.0" },
+        protocolVersion: PROTOCOL_VERSION,
+    });
+    if (initialized.protocolVersion !== PROTOCOL_VERSION) {
+        throw new AutomationError("HARNESS_PROTOCOL_ERROR", `Kimi Code negotiated unsupported ACP version ${String(initialized.protocolVersion)}.`);
+    }
+    if (!initialized.authMethods?.some((method) => method.id === "login")) {
+        throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Kimi Code did not advertise its non-interactive login authentication check.");
+    }
+    await connection.authenticate({ methodId: "login" });
+    return initialized;
+}
+async function applyKimiCodeConfiguration(connection, sessionId, initialOptions, options, approval) {
+    let configOptions = initialOptions;
+    if (options.model !== undefined) {
+        configOptions = await setAdvertisedConfigOption(connection, sessionId, configOptions, "model", options.model);
+    }
+    if (options.effort !== undefined) {
+        configOptions = await setAdvertisedConfigOption(connection, sessionId, configOptions, "effort", options.effort);
+    }
+    const mode = approval === "auto" ? "auto" : "default";
+    const advertisedMode = findConfigOption(configOptions, "mode", mode);
+    if (advertisedMode !== undefined && !optionIncludes(advertisedMode, mode)) {
+        throw unsupportedKimiConfiguration("mode", mode);
+    }
+    try {
+        await connection.setSessionMode({ modeId: mode, sessionId });
+    }
+    catch (cause) {
+        throw mapKimiCodeError(cause, "configuration");
+    }
+}
+async function setAdvertisedConfigOption(connection, sessionId, configOptions, kind, value) {
+    const option = findConfigOption(configOptions, kind, value);
+    if (option === undefined || !optionIncludes(option, value)) {
+        throw unsupportedKimiConfiguration(kind, value);
+    }
+    try {
+        const configured = await connection.setSessionConfigOption({
+            configId: option.id,
+            sessionId,
+            value,
+        });
+        return configured.configOptions;
+    }
+    catch (cause) {
+        throw mapKimiCodeError(cause, "configuration");
+    }
+}
+function findConfigOption(options, kind, requestedValue) {
+    const ids = kind === "model"
+        ? ["model"]
+        : kind === "mode"
+            ? ["mode"]
+            : ["effort", "thinking_effort", "reasoning_effort", "thinking"];
+    const category = kind === "effort" ? "thought_level" : kind;
+    return (options.find((option) => ids.includes(option.id) && optionIncludes(option, requestedValue)) ??
+        options.find((option) => option.category === category && optionIncludes(option, requestedValue)) ??
+        options.find((option) => ids.includes(option.id)) ??
+        options.find((option) => option.category === category));
+}
+function optionIncludes(option, value) {
+    if (option.type !== "select") {
+        return false;
+    }
+    return option.options.some((entry) => "value" in entry
+        ? entry.value === value
+        : entry.options.some((nested) => nested.value === value));
+}
+function unsupportedKimiConfiguration(kind, value) {
+    return new AutomationError("HARNESS_CAPABILITY_UNSUPPORTED", `Kimi Code does not support the requested ${kind}: ${value}.`);
+}
+function resolvePermissionRequest(request, approval) {
+    if (approval === "auto") {
+        return Promise.resolve({ outcome: { outcome: "cancelled" } });
+    }
+    const rejected = request.options.find((option) => option.kind === "reject_once") ??
+        request.options.find((option) => option.kind === "reject_always");
+    return Promise.resolve(rejected === undefined
+        ? { outcome: { outcome: "cancelled" } }
+        : {
+            outcome: {
+                outcome: "selected",
+                optionId: rejected.optionId,
+            },
+        });
+}
+function requireSessionId(value) {
+    if (value.length === 0) {
+        throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Kimi Code returned an invalid Session identifier.");
+    }
+    return value;
+}
+function mapKimiCodeError(cause, phase) {
+    if (isAutomationError(cause)) {
+        return cause;
+    }
+    if (cause instanceof RequestError) {
+        if (cause.code === -32_000 ||
+            /auth(?:entication)? required/iu.test(cause.message)) {
+            return new AutomationError("HARNESS_NOT_AUTHENTICATED", "Kimi Code is not authenticated.", { cause });
+        }
+        if (phase === "configuration") {
+            return new AutomationError("HARNESS_CAPABILITY_UNSUPPORTED", "Kimi Code rejected the requested model, effort, or approval mode.", { cause });
+        }
+        return new AutomationError("HARNESS_PROTOCOL_ERROR", "Kimi Code returned an ACP error.", { cause });
+    }
+    return new AutomationError("HARNESS_PROTOCOL_ERROR", "Kimi Code could not complete the ACP exchange.", { cause });
+}

package/dist/opencode.d.ts

@@ -0,0 +1,15 @@
+import { type Harness } from "./harness.js";
+import type { NoExtraKeys } from "./type-utils.js";
+export declare const OPENCODE_HARNESS_PREFLIGHT: {
+    readonly harnessName: "OpenCode";
+    readonly minimumVersion: readonly [1, 18, 4];
+    readonly unsupportedVersionMessage: "OpenCode CLI 1.18.4 or later is required.";
+    readonly versionPattern: RegExp;
+};
+export interface OpenCodeOptions {
+    readonly executable?: string;
+    readonly model?: string;
+    readonly effort?: string;
+}
+export declare function opencode(): Harness;
+export declare function opencode<const TOptions extends OpenCodeOptions>(options: TOptions & NoExtraKeys<TOptions, OpenCodeOptions>): Harness;