akm-cli 0.9.17-alpha.2 → 0.9.17-alpha.4

package/dist/integrations/agent/execution-preparation.js

@@ -1,98 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { cloneExecutionJsonObject } from "../../execution/json.js";
-import { withEngineFallback } from "./engine-fallback.js";
-import { planExecutionCascade, } from "./execution-cascade.js";
-import { executionEngineDefinitionsFromConfig } from "./execution-definitions.js";
-import { loadModelMap } from "./model-map.js";
-function own(value, key) {
-    return Object.hasOwn(value, key);
-}
-function requestedToolNames(tools) {
-    if (tools === null)
-        return Object.freeze([]);
-    if (typeof tools === "string") {
-        return Object.freeze(tools
-            .split(",")
-            .map((tool) => tool.trim())
-            .filter(Boolean));
-    }
-    if (Array.isArray(tools))
-        return Object.freeze(tools.map((tool) => tool.trim()).filter(Boolean));
-    const structured = tools;
-    // The portable structured spelling is a boolean allow/deny map. Opaque or
-    // nested provider policy cannot be reduced to tool names without guessing,
-    // so a host name allowlist must deny it (an explicit "*" may still allow it).
-    if (Object.values(structured).some((value) => typeof value !== "boolean"))
-        return undefined;
-    return Object.freeze(Object.keys(structured).filter((tool) => structured[tool] === true));
-}
-/** The production authorizer: executable assets may only narrow a host-owned ceiling. */
-export function toolAuthorizerFromConfig(config) {
-    const allowed = new Set(config.execution?.allowedTools ?? []);
-    return (input) => {
-        const requested = requestedToolNames(input.tools);
-        const permitted = allowed.has("*") || requested?.every((tool) => allowed.has(tool)) === true;
-        return Object.freeze({
-            status: permitted ? "allowed" : "denied",
-            policy: "config-execution-allowed-tools",
-        });
-    };
-}
-/** Pure common cascade composition once caller-specific sources are rendered. */
-export function planPreparedExecution(options) {
-    return planExecutionCascade({
-        command: options.command,
-        ...(own(options, "conversation") ? { conversation: options.conversation } : {}),
-        ...(own(options, "persona") ? { persona: options.persona } : {}),
-        layers: {
-            installation: {
-                id: "installation-defaults",
-                values: options.installationEngine === undefined ? {} : { engine: options.installationEngine },
-            },
-            ...(options.agentLayer ? { agent: options.agentLayer } : {}),
-            command: options.commandLayer,
-            ...(options.invocationDefaults
-                ? { invocationDefaults: { id: "invocation-defaults", values: options.invocationDefaults } }
-                : {}),
-            ...(options.current ? { current: { id: "current-invocation", values: options.current } } : {}),
-        },
-        engines: options.engines,
-        modelMap: options.modelMap,
-        invocationKind: options.invocationKind,
-        ...(options.authorizeTools ? { authorizeTools: options.authorizeTools } : {}),
-    });
-}
-/**
- * The one planner adapter for already-rendered command/persona content.
- * Direct, task, improve, proposal, and workflow callers contribute named
- * layers here; none may rebuild engine/model precedence around the cascade.
- */
-export function prepareResolvedExecution(options) {
-    const inputConfig = cloneExecutionJsonObject(options.config, "execution preparation input config");
-    const fallback = withEngineFallback(inputConfig);
-    const config = cloneExecutionJsonObject(fallback.config, "execution preparation resolved config");
-    const defaults = own(config, "defaults") ? config.defaults : undefined;
-    const installationEngine = defaults && own(defaults, "engine") ? defaults.engine : undefined;
-    const plan = planPreparedExecution({
-        command: options.command,
-        ...(own(options, "conversation") ? { conversation: options.conversation } : {}),
-        ...(own(options, "persona") ? { persona: options.persona } : {}),
-        ...(installationEngine === undefined ? {} : { installationEngine }),
-        ...(options.agentLayer ? { agentLayer: options.agentLayer } : {}),
-        commandLayer: options.commandLayer,
-        ...(options.invocationDefaults ? { invocationDefaults: options.invocationDefaults } : {}),
-        ...(options.current ? { current: options.current } : {}),
-        engines: executionEngineDefinitionsFromConfig(config),
-        modelMap: options.modelMap ?? loadModelMap({ engines: config.engines }).map,
-        invocationKind: options.invocationKind,
-        authorizeTools: options.authorizeTools ?? toolAuthorizerFromConfig(config),
-    });
-    return Object.freeze({
-        plan,
-        request: plan.request,
-        config,
-        ...(fallback.fallbackEngineName ? { fallbackEngineName: fallback.fallbackEngineName } : {}),
-    });
-}

package/dist/integrations/agent/inline-execution.js

@@ -1,74 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { createInlineResolvedCommand, } from "../../execution/resolved-request.js";
-import { executionEngineDefinitionFromRunner } from "./execution-definitions.js";
-import { planPreparedExecution, prepareResolvedExecution } from "./execution-preparation.js";
-import { MODEL_MAP_VERSION } from "./model-map.js";
-const EMPTY_EXACT_MODEL_MAP = Object.freeze({
-    version: MODEL_MAP_VERSION,
-    aliases: Object.freeze(Object.create(null)),
-});
-function own(value, key) {
-    return Object.hasOwn(value, key);
-}
-/**
- * Resolve anonymous command content through the same far-to-near cascade used
- * by stored commands. Tasks, workflows, and internal model work adapt their
- * already-rendered content here rather than rebuilding engine/model precedence.
- */
-export function prepareInlineExecution(options) {
-    const command = createInlineResolvedCommand({
-        template: options.content,
-        ...(own(options, "argumentInput") ? { argumentInput: options.argumentInput } : {}),
-        content: options.content,
-    });
-    return prepareResolvedExecution({
-        command,
-        config: options.config,
-        invocationKind: options.invocationKind,
-        ...(own(options, "conversation") ? { conversation: options.conversation } : {}),
-        ...(own(options, "persona") ? { persona: options.persona } : {}),
-        commandLayer: { id: "inline-command", values: {} },
-        ...(options.invocationDefaults ? { invocationDefaults: options.invocationDefaults } : {}),
-        ...(options.current ? { current: options.current } : {}),
-        ...(options.modelMap ? { modelMap: options.modelMap } : {}),
-        ...(options.authorizeTools ? { authorizeTools: options.authorizeTools } : {}),
-    });
-}
-/**
- * Prepare anonymous work from an already-resolved runner without reading live
- * config or interpreting aliases. Used by resume-safe workflow/judge and by
- * improve/proposal calls that already froze runner material.
- */
-export function prepareInlineExecutionWithRunner(options) {
-    const command = createInlineResolvedCommand({
-        template: options.content,
-        ...(own(options, "argumentInput") ? { argumentInput: options.argumentInput } : {}),
-        content: options.content,
-    });
-    const material = executionEngineDefinitionFromRunner(options.runner, own(options, "sdkFallbackModelFromRequest")
-        ? { sdkFallbackModelFromRequest: options.sdkFallbackModelFromRequest === true }
-        : {});
-    const engines = Object.create(null);
-    Object.defineProperty(engines, material.engineName, {
-        value: material.definition,
-        enumerable: true,
-        configurable: false,
-        writable: false,
-    });
-    const plan = planPreparedExecution({
-        command,
-        ...(own(options, "conversation") ? { conversation: options.conversation } : {}),
-        ...(own(options, "persona") ? { persona: options.persona } : {}),
-        installationEngine: material.engineName,
-        commandLayer: { id: "inline-command", values: {} },
-        ...(options.invocationDefaults ? { invocationDefaults: options.invocationDefaults } : {}),
-        ...(options.current ? { current: options.current } : {}),
-        engines: Object.freeze(engines),
-        modelMap: options.modelMap ?? EMPTY_EXACT_MODEL_MAP,
-        invocationKind: options.invocationKind,
-        ...(options.authorizeTools ? { authorizeTools: options.authorizeTools } : {}),
-    });
-    return Object.freeze({ plan, request: plan.request, runner: material.runner });
-}

package/dist/registry/create-provider-registry.js

@@ -1,29 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Generic factory-map utility.
- *
- * Creates a lightweight registry that maps string keys to factory functions.
- * Both registry/factory.ts (registry discovery) and sources/provider-factory.ts
- * (source providers) are built on this utility.
- */
-export function createProviderRegistry() {
-    const map = new Map();
-    return {
-        register(type, factory) {
-            map.set(type, factory);
-        },
-        resolve(type) {
-            return map.get(type) ?? null;
-        },
-        /** Removes a registration. No-op if `type` was never registered. */
-        unregister(type) {
-            map.delete(type);
-        },
-        /** Snapshot of all registered keys. Iteration order matches insertion order. */
-        list() {
-            return [...map.keys()];
-        },
-    };
-}

package/dist/registry/pinned-request-helper.js

@@ -1,247 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/** Parse and validate the private stdin request before any socket is opened. */
-async function readNodePinnedHelperRequest(isIP) {
-    const MAX_PRELUDE_BYTES = 64 * 1024;
-    const iterator = process.stdin[Symbol.asyncIterator]();
-    let buffered = Buffer.alloc(0);
-    const readExact = async (length) => {
-        while (buffered.byteLength < length) {
-            const next = await iterator.next();
-            if (next.done)
-                throw new Error("Registry helper input ended before the request prelude was complete");
-            buffered = Buffer.concat([buffered, Buffer.from(next.value)]);
-        }
-        const result = buffered.subarray(0, length);
-        buffered = buffered.subarray(length);
-        return result;
-    };
-    const preludeLength = (await readExact(4)).readUInt32BE(0);
-    if (preludeLength === 0 || preludeLength > MAX_PRELUDE_BYTES) {
-        throw new Error("Registry helper request prelude exceeds its protocol limit");
-    }
-    const raw = JSON.parse((await readExact(preludeLength)).toString("utf8"));
-    if (typeof raw.url !== "string" || typeof raw.address !== "string") {
-        throw new Error("Registry helper request prelude is invalid");
-    }
-    const url = new URL(raw.url);
-    if ((url.protocol !== "http:" && url.protocol !== "https:") || url.username || url.password) {
-        throw new Error("Registry helper accepts only credential-free HTTP(S) URLs");
-    }
-    const addressFamily = isIP(raw.address);
-    if (addressFamily === 0)
-        throw new Error("Registry helper requires a numeric pinned address");
-    if (typeof raw.timeoutMs !== "number" || !Number.isSafeInteger(raw.timeoutMs) || raw.timeoutMs <= 0) {
-        throw new Error("Registry helper timeout is invalid");
-    }
-    if (!Array.isArray(raw.headers) || raw.headers.length > 256) {
-        throw new Error("Registry helper headers are invalid");
-    }
-    const headers = {};
-    for (const pair of raw.headers) {
-        if (!Array.isArray(pair) ||
-            pair.length !== 2 ||
-            typeof pair[0] !== "string" ||
-            typeof pair[1] !== "string" ||
-            pair[0].length > 256 ||
-            pair[1].length > 16_384) {
-            throw new Error("Registry helper header entry is invalid");
-        }
-        headers[pair[0].toLowerCase()] = pair[1];
-    }
-    for (const name of [
-        "connection",
-        "keep-alive",
-        "proxy-authorization",
-        "proxy-connection",
-        "te",
-        "trailer",
-        "transfer-encoding",
-        "upgrade",
-    ]) {
-        delete headers[name];
-    }
-    headers.host = url.host;
-    return {
-        addressFamily: addressFamily,
-        bodyPresent: raw.bodyPresent === true,
-        headers,
-        initialBody: buffered,
-        iterator,
-        method: typeof raw.method === "string" ? raw.method.toUpperCase() : "GET",
-        pinnedAddress: raw.address,
-        timeoutMs: raw.timeoutMs,
-        url,
-    };
-}
-/**
- * The body of the one-request Node helper used by Bun's registry transport.
- * Its parser is passed explicitly when the parent serializes both functions.
- */
-export async function nodePinnedRequestHelperMain(readRequest, http, https, isIP) {
-    const MAX_FRAME_BYTES = 1024 * 1024;
-    const FRAME_PRELUDE = 0;
-    const FRAME_BODY = 1;
-    const FRAME_END = 2;
-    const FRAME_ERROR = 3;
-    const writeBuffer = async (value) => {
-        await new Promise((resolve, reject) => {
-            process.stdout.write(value, (error) => (error ? reject(error) : resolve()));
-        });
-    };
-    const writeFrame = async (type, payload = new Uint8Array()) => {
-        if (payload.byteLength > MAX_FRAME_BYTES && type !== FRAME_BODY) {
-            throw new Error("Registry helper frame exceeds its protocol limit");
-        }
-        if (type === FRAME_BODY && payload.byteLength > MAX_FRAME_BYTES) {
-            for (let offset = 0; offset < payload.byteLength; offset += MAX_FRAME_BYTES) {
-                await writeFrame(type, payload.subarray(offset, Math.min(payload.byteLength, offset + MAX_FRAME_BYTES)));
-            }
-            return;
-        }
-        const header = Buffer.allocUnsafe(5);
-        header[0] = type;
-        header.writeUInt32BE(payload.byteLength, 1);
-        await writeBuffer(header);
-        if (payload.byteLength > 0)
-            await writeBuffer(payload);
-    };
-    const errorPayload = (error) => {
-        const candidate = error;
-        return Buffer.from(JSON.stringify({
-            name: typeof candidate?.name === "string" ? candidate.name.slice(0, 128) : "Error",
-            message: typeof candidate?.message === "string" ? candidate.message.slice(0, 8_192) : String(error).slice(0, 8_192),
-            code: typeof candidate?.code === "string" ? candidate.code.slice(0, 128) : undefined,
-        }));
-    };
-    try {
-        const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
-        if (!Number.isInteger(nodeMajor) || nodeMajor < 22) {
-            throw new Error(`The pinned registry helper requires Node.js >= 22; found ${process.versions.node}`);
-        }
-        const { addressFamily, bodyPresent, headers, initialBody, iterator, method, pinnedAddress, timeoutMs, url } = await readRequest(isIP);
-        const hostname = url.hostname.startsWith("[") && url.hostname.endsWith("]") ? url.hostname.slice(1, -1) : url.hostname;
-        const lookup = (_hostname, options, callback) => {
-            if (typeof options === "object" && options !== null && "all" in options && options.all === true) {
-                callback(null, [{ address: pinnedAddress, family: addressFamily }]);
-            }
-            else {
-                callback(null, pinnedAddress, addressFamily);
-            }
-        };
-        const requestOptions = {
-            protocol: url.protocol,
-            hostname,
-            port: url.port || undefined,
-            path: `${url.pathname}${url.search}`,
-            method,
-            headers,
-            lookup,
-            // One helper owns exactly one fresh connection. It never pools a socket
-            // selected for an earlier DNS answer.
-            agent: false,
-            ...(url.protocol === "https:" && isIP(hostname) === 0 ? { servername: hostname } : {}),
-        };
-        let responseStarted = false;
-        let requestFinished = false;
-        let request;
-        const responseDone = new Promise((resolve, reject) => {
-            const requestFn = url.protocol === "https:" ? https.request : http.request;
-            request = requestFn(requestOptions, async (response) => {
-                responseStarted = true;
-                try {
-                    await writeFrame(FRAME_PRELUDE, Buffer.from(JSON.stringify({
-                        status: response.statusCode ?? 500,
-                        statusText: response.statusMessage ?? "",
-                        rawHeaders: response.rawHeaders,
-                    })));
-                    for await (const chunk of response) {
-                        await writeFrame(FRAME_BODY, Buffer.from(chunk));
-                    }
-                    await writeFrame(FRAME_END);
-                    resolve();
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-            const headerTimer = setTimeout(() => {
-                request?.destroy(new Error(`Registry request timed out after ${timeoutMs}ms while awaiting response headers`));
-            }, timeoutMs);
-            request.once("response", () => clearTimeout(headerTimer));
-            request.once("error", (error) => {
-                clearTimeout(headerTimer);
-                if (!responseStarted)
-                    reject(error);
-            });
-        });
-        const writeRequestChunk = async (chunk) => {
-            if (!request || request.destroyed)
-                throw new Error("Registry helper request closed while streaming its body");
-            const activeRequest = request;
-            if (activeRequest.write(chunk))
-                return;
-            await new Promise((resolve, reject) => {
-                const onDrain = () => {
-                    cleanup();
-                    resolve();
-                };
-                const onError = (error) => {
-                    cleanup();
-                    reject(error);
-                };
-                const cleanup = () => {
-                    activeRequest.off("drain", onDrain);
-                    activeRequest.off("error", onError);
-                };
-                activeRequest.once("drain", onDrain);
-                activeRequest.once("error", onError);
-            });
-        };
-        const bodyDone = (async () => {
-            if (!request)
-                throw new Error("Registry helper request was not initialized");
-            if (bodyPresent) {
-                if (initialBody.byteLength > 0) {
-                    await writeRequestChunk(initialBody);
-                }
-                while (true) {
-                    const next = await iterator.next();
-                    if (next.done)
-                        break;
-                    await writeRequestChunk(Buffer.from(next.value));
-                }
-            }
-            requestFinished = true;
-            request.end();
-        })();
-        try {
-            await Promise.all([responseDone, bodyDone]);
-        }
-        catch (error) {
-            if (!requestFinished && !responseStarted)
-                request?.destroy(error);
-            throw error;
-        }
-    }
-    catch (error) {
-        try {
-            await writeFrame(FRAME_ERROR, errorPayload(error));
-        }
-        catch {
-            // The parent also treats an unframed EOF as a transport failure.
-        }
-        process.exitCode = 1;
-    }
-}
-/** Materialize both self-contained passes into a one-request Node program. */
-export function nodePinnedRequestHelperSource() {
-    return (`import * as http from "node:http";\n` +
-        `import * as https from "node:https";\n` +
-        `import { isIP } from "node:net";\n` +
-        `(${nodePinnedRequestHelperMain.toString()})(${readNodePinnedHelperRequest.toString()}, http, https, isIP).catch((error) => {\n` +
-        `  console.error(error instanceof Error ? error.message : String(error));\n` +
-        `  process.exitCode = 1;\n` +
-        `});\n`);
-}