@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/agents/launch-snapshot/parse-helpers.js

@@ -1,114 +0,0 @@
-import * as path from "node:path";
-export function snapshotError(fieldPath, message) {
-    return new Error(`Invalid resolved Akuma launch snapshot at ${fieldPath}: ${message}`);
-}
-export function isPlainObject(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-export function objectAt(value, fieldPath) {
-    if (!isPlainObject(value))
-        throw snapshotError(fieldPath, "must be a plain JSON object");
-    return value;
-}
-export function exactKeys(value, allowed, fieldPath) {
-    const allowedSet = new Set(allowed);
-    for (const key of Object.keys(value)) {
-        if (!allowedSet.has(key))
-            throw snapshotError(`${fieldPath}.${key}`, "is an unknown field");
-    }
-}
-export function requiredString(value, key, fieldPath, allowBlank = false) {
-    const item = value[key];
-    if (typeof item !== "string" || (!allowBlank && item.trim().length === 0)) {
-        throw snapshotError(`${fieldPath}.${key}`, allowBlank ? "must be a string" : "must be a nonblank string");
-    }
-    return item;
-}
-export function optionalString(value, key, fieldPath) {
-    if (!(key in value))
-        return undefined;
-    return requiredString(value, key, fieldPath);
-}
-export function requiredEnum(value, key, fieldPath, values) {
-    const item = requiredString(value, key, fieldPath);
-    if (!values.has(item))
-        throw snapshotError(`${fieldPath}.${key}`, `has invalid value '${item}'`);
-    return item;
-}
-function cloneJson(value, fieldPath, ancestors = new Set()) {
-    if (value === null || typeof value === "string" || typeof value === "boolean")
-        return value;
-    if (typeof value === "number") {
-        if (!Number.isFinite(value))
-            throw snapshotError(fieldPath, "contains a non-finite number");
-        return value;
-    }
-    if (typeof value !== "object")
-        throw snapshotError(fieldPath, "contains a non-JSON value");
-    if (ancestors.has(value))
-        throw snapshotError(fieldPath, "contains a cycle");
-    ancestors.add(value);
-    try {
-        if (Array.isArray(value)) {
-            return Object.freeze(value.map((item, index) => cloneJson(item, `${fieldPath}[${index}]`, ancestors)));
-        }
-        if (!isPlainObject(value))
-            throw snapshotError(fieldPath, "contains a non-plain JSON object");
-        const result = {};
-        for (const [key, item] of Object.entries(value)) {
-            Object.defineProperty(result, key, {
-                value: cloneJson(item, `${fieldPath}.${key}`, ancestors),
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
-        }
-        return Object.freeze(result);
-    }
-    finally {
-        ancestors.delete(value);
-    }
-}
-export function cloneJsonObject(value, fieldPath) {
-    const cloned = cloneJson(value, fieldPath);
-    if (!isPlainObject(cloned)) {
-        throw snapshotError(fieldPath, "must be a plain JSON object");
-    }
-    return cloned;
-}
-export function optionalJsonObject(provider, key) {
-    return key in provider ? cloneJsonObject(provider[key], `provider.${key}`) : undefined;
-}
-export function optionalStringRecord(provider, key) {
-    if (!(key in provider))
-        return undefined;
-    const value = provider[key];
-    if (!isPlainObject(value))
-        throw snapshotError(`provider.${key}`, "must be a plain JSON object");
-    const result = {};
-    for (const [entryKey, entryValue] of Object.entries(value)) {
-        if (typeof entryValue !== "string") {
-            throw snapshotError(`provider.${key}.${entryKey}`, "must be a string");
-        }
-        result[entryKey] = entryValue;
-    }
-    return Object.freeze(result);
-}
-export function parseAbsoluteRootList(value, fieldPath) {
-    if (!Array.isArray(value) || value.length === 0) {
-        throw snapshotError(fieldPath, "must be a nonempty array");
-    }
-    const roots = value.map((root, index) => {
-        if (typeof root !== "string" || !path.isAbsolute(root) || path.resolve(root) !== root) {
-            throw snapshotError(`${fieldPath}[${index}]`, "must be a lexically normalized absolute path");
-        }
-        return root;
-    });
-    if (new Set(roots).size !== roots.length) {
-        throw snapshotError(fieldPath, "must not contain duplicates");
-    }
-    return Object.freeze(roots);
-}

package/build/agents/launch-snapshot/resolve.js

@@ -1,46 +0,0 @@
-import { getProviderRegistration } from "../providers/registry.js";
-import { assertEffortAllowed, assertEffortRequiresModel, parseResolvedAkumaLaunchSnapshot, } from "./model.js";
-export function resolveAkumaLaunchSnapshot(selected, input) {
-    const model = input.model ?? selected.profile.model;
-    const effort = input.effort ?? selected.profile.effort;
-    assertEffortAllowed(effort, selected.profile.effortOptions);
-    if (input.effort !== undefined) {
-        assertEffortRequiresModel(model, effort, "override");
-    }
-    else {
-        assertEffortRequiresModel(model, effort, "profile", selected.name);
-    }
-    const policy = {
-        ...(selected.profile.access !== undefined ? { access: selected.profile.access } : {}),
-        ...(selected.profile.network !== undefined ? { network: selected.profile.network } : {}),
-        ...(selected.profile.webSearch !== undefined ? { webSearch: selected.profile.webSearch } : {}),
-    };
-    const akuma = {
-        name: selected.name,
-        source: selected.definition.source,
-        body: selected.definition.body,
-        ...(selected.profile.description !== undefined ? { description: selected.profile.description } : {}),
-        ...(model !== undefined ? { model } : {}),
-        ...(effort !== undefined ? { effort } : {}),
-        ...(selected.profile.effortOptions !== undefined ? { effortOptions: selected.profile.effortOptions } : {}),
-        policy,
-    };
-    const instance = selected.profile.providerInstance;
-    const common = {
-        name: selected.profile.provider,
-        source: selected.profile.providerSource,
-    };
-    const registration = getProviderRegistration(instance.kind);
-    const provider = registration.resolveLaunchProvider({
-        common,
-        instance,
-        model,
-        effort,
-        executionCwd: input.executionCwd,
-        projectRoot: input.projectRoot,
-        access: selected.profile.access,
-        network: selected.profile.network,
-        webSearch: selected.profile.webSearch,
-    });
-    return parseResolvedAkumaLaunchSnapshot({ version: 1, akuma, provider });
-}

package/build/agents/opencode-sdk.js

@@ -1,159 +0,0 @@
-import { spawn } from "node:child_process";
-import net from "node:net";
-import { createOpencodeClient, } from "@opencode-ai/sdk/v2";
-import { coerceString, createAbortError } from "./harness/runtime.js";
-export { createOpencodeClient, };
-const DEFAULT_HOSTNAME = "127.0.0.1";
-const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
-const SERVER_READY_POLL_INTERVAL_MS = 100;
-const SERVER_SHUTDOWN_FORCE_KILL_MS = 1000;
-const SERVER_SHUTDOWN_HARD_TIMEOUT_MS = 2000;
-const OPENCODE_SERVE_SUBCOMMAND = "serve";
-const OPENCODE_HOSTNAME_FLAG = "--hostname";
-const OPENCODE_PORT_FLAG = "--port";
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function getAvailablePort(hostname) {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.on("error", reject);
-        server.listen(0, hostname, () => {
-            const address = server.address();
-            if (!address || typeof address === "string") {
-                server.close(() => reject(new Error("Unable to determine OpenCode server port")));
-                return;
-            }
-            server.close((error) => error ? reject(error) : resolve(address.port));
-        });
-    });
-}
-async function waitForServerReady(client, directory, timeoutMs, signal) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (signal?.aborted)
-            throw createAbortError("OpenCode server startup aborted");
-        try {
-            // Legacy config endpoints become available before the runtime model
-            // catalog. Prompting in that window is admitted, then fails asynchronously
-            // with ModelUnavailableError and no terminal event.
-            await client.v2.model.list({ location: { directory } }, { throwOnError: true });
-            return;
-        }
-        catch {
-            await sleep(SERVER_READY_POLL_INTERVAL_MS);
-        }
-    }
-    throw new Error(`OpenCode server did not become ready within ${timeoutMs}ms`);
-}
-export async function createOpencodeServer(options = {}) {
-    const hostname = coerceString(options.hostname) ?? DEFAULT_HOSTNAME;
-    const port = options.port ?? (await getAvailablePort(hostname));
-    const url = `http://${hostname}:${port}`;
-    const executable = coerceString(options.executable) ?? "opencode";
-    const directory = coerceString(options.directory);
-    const startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
-    const child = spawn(executable, [OPENCODE_SERVE_SUBCOMMAND, OPENCODE_HOSTNAME_FLAG, hostname, OPENCODE_PORT_FLAG, String(port)], {
-        cwd: directory,
-        env: options.env !== undefined ? { ...options.env } : { ...process.env },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    let exited = false;
-    let stderr = "";
-    child.stderr.on("data", (chunk) => { stderr += String(chunk); });
-    child.on("error", (error) => { stderr += `${stderr ? " " : ""}${error.message}`; });
-    child.on("close", () => { exited = true; });
-    const client = createOpencodeClient({ baseUrl: url, directory });
-    let gracefulStop;
-    let forceStop;
-    const stop = async (mode = "graceful") => {
-        if (exited)
-            return;
-        if (mode === "force") {
-            forceStop ??= new Promise((resolve, reject) => {
-                let timer;
-                const finish = (error) => {
-                    if (timer)
-                        clearTimeout(timer);
-                    error === undefined ? resolve() : reject(error);
-                };
-                child.once("close", () => finish());
-                timer = setTimeout(() => {
-                    finish(new Error("OpenCode server forced process exit was not observed"));
-                }, SERVER_SHUTDOWN_HARD_TIMEOUT_MS);
-                timer.unref?.();
-                try {
-                    if (!child.kill("SIGKILL") && !exited)
-                        finish(new Error("OpenCode server force kill failed"));
-                }
-                catch (error) {
-                    finish(error);
-                }
-            });
-            await forceStop;
-            return;
-        }
-        if (forceStop) {
-            await forceStop;
-            return;
-        }
-        gracefulStop ??= new Promise((resolve, reject) => {
-            let settled = false;
-            let forceKill;
-            let hardTimeout;
-            const finish = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (forceKill)
-                    clearTimeout(forceKill);
-                if (hardTimeout)
-                    clearTimeout(hardTimeout);
-                error === undefined ? resolve() : reject(error);
-            };
-            child.once("close", () => finish());
-            try {
-                child.kill("SIGTERM");
-            }
-            catch (error) {
-                finish(error);
-                return;
-            }
-            forceKill = setTimeout(() => {
-                if (!exited) {
-                    try {
-                        child.kill("SIGKILL");
-                    }
-                    catch (error) {
-                        finish(error);
-                    }
-                }
-            }, SERVER_SHUTDOWN_FORCE_KILL_MS);
-            forceKill.unref?.();
-            hardTimeout = setTimeout(() => {
-                finish(new Error("OpenCode server process exit was not observed"));
-            }, SERVER_SHUTDOWN_HARD_TIMEOUT_MS);
-            hardTimeout.unref?.();
-        });
-        await gracefulStop;
-    };
-    try {
-        await waitForServerReady(client, directory, startupTimeoutMs, options.signal);
-    }
-    catch (error) {
-        await stop();
-        const suffix = stderr.trim() ? ` ${stderr.trim()}` : "";
-        throw new Error(`${error instanceof Error ? error.message : String(error)}${suffix}`);
-    }
-    return {
-        url,
-        close: stop,
-    };
-}
-export async function createOpencode(options = {}) {
-    const server = await createOpencodeServer(options);
-    return {
-        client: createOpencodeClient({ baseUrl: server.url, directory: options.directory }),
-        server,
-    };
-}