toolcraft 0.0.749 → 0.0.751

package/dist/runtime.js

@@ -0,0 +1,576 @@
+import { fileURLToPath, defaultEnvironment } from "#toolcraft-runtime-platform";
+import { ApprovalDeclinedError } from "./human-in-loop/types.js";
+import { mergeHumanInLoopFromGroup, validateHumanInLoopOnDefine } from "./human-in-loop/config.js";
+import { ToolcraftBugError, UserError, isUserError } from "./user-error.js";
+import { suggest } from "./suggest.js";
+import { isProxyNode } from "./mcp-proxy-metadata.js";
+export { createManagedStream } from "./stream.js";
+const commandConfigSymbol = Symbol("toolcraft.command.config");
+const groupConfigSymbol = Symbol("toolcraft.group.config");
+const commandSourcePathSymbol = Symbol("toolcraft.command.sourcePath");
+function cloneScope(scope) {
+    return scope === undefined ? undefined : [...scope];
+}
+function cloneSecretDefinition(secret) {
+    return {
+        env: secret.env,
+        description: secret.description,
+        optional: secret.optional
+    };
+}
+function cloneSecrets(secrets) {
+    if (secrets === undefined) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(secrets).map(([key, secret]) => [key, cloneSecretDefinition(secret)]));
+}
+function cloneRequires(requires) {
+    if (requires === undefined) {
+        return undefined;
+    }
+    return {
+        auth: requires.auth,
+        apiVersion: requires.apiVersion,
+        check: requires.check
+    };
+}
+function cloneToolAnnotations(annotations) {
+    return annotations === undefined ? undefined : { ...annotations };
+}
+function cloneStringArray(values) {
+    return values === undefined ? undefined : [...values];
+}
+function cloneCommandExamples(examples) {
+    return (examples ?? []).map((example) => ({
+        title: example.title,
+        params: { ...example.params }
+    }));
+}
+function cloneStringRecord(values) {
+    return values === undefined ? undefined : { ...values };
+}
+function cloneMcpServerConfig(config) {
+    if (config === undefined) {
+        return undefined;
+    }
+    if (config.transport === "stdio") {
+        return {
+            transport: "stdio",
+            command: config.command,
+            args: cloneStringArray(config.args),
+            env: cloneStringRecord(config.env)
+        };
+    }
+    return {
+        transport: "http",
+        url: config.url,
+        headers: cloneStringRecord(config.headers)
+    };
+}
+function cloneRenameMap(rename) {
+    return rename === undefined ? undefined : { ...rename };
+}
+function validateRenameMap(rename) {
+    if (rename === undefined) {
+        return;
+    }
+    const seenTargets = new Map();
+    for (const [upstreamName, targetPath] of Object.entries(rename)) {
+        if (targetPath.length === 0) {
+            throw new UserError(`Invalid rename target for upstream tool "${upstreamName}": path cannot be empty.`);
+        }
+        if (targetPath.split(".").some((segment) => segment.length === 0)) {
+            throw new UserError(`Invalid rename target for upstream tool "${upstreamName}": "${targetPath}" contains an empty segment.`);
+        }
+        const existingUpstreamName = seenTargets.get(targetPath);
+        if (existingUpstreamName !== undefined) {
+            throw new UserError(`Duplicate rename target "${targetPath}" for upstream tools "${existingUpstreamName}" and "${upstreamName}".`);
+        }
+        seenTargets.set(targetPath, upstreamName);
+    }
+}
+function parseStackPath(candidate) {
+    if (candidate.startsWith("file://")) {
+        try {
+            return fileURLToPath(candidate);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (candidate.startsWith("/")) {
+        return candidate;
+    }
+    return undefined;
+}
+function extractStackPath(line) {
+    const trimmed = line.trim();
+    const fileIndex = trimmed.indexOf("file://");
+    if (fileIndex >= 0) {
+        const location = trimmed.slice(fileIndex);
+        const separatorIndex = location.lastIndexOf(":");
+        const previousSeparatorIndex = separatorIndex >= 0 ? location.lastIndexOf(":", separatorIndex - 1) : -1;
+        const candidate = separatorIndex >= 0 && previousSeparatorIndex >= 0
+            ? location.slice(0, previousSeparatorIndex)
+            : location;
+        return parseStackPath(candidate);
+    }
+    const slashIndex = trimmed.indexOf("/");
+    if (slashIndex < 0) {
+        return undefined;
+    }
+    const location = trimmed.slice(slashIndex);
+    const separatorIndex = location.lastIndexOf(":");
+    const previousSeparatorIndex = separatorIndex >= 0 ? location.lastIndexOf(":", separatorIndex - 1) : -1;
+    const candidate = separatorIndex >= 0 && previousSeparatorIndex >= 0
+        ? location.slice(0, previousSeparatorIndex)
+        : location;
+    return parseStackPath(candidate);
+}
+function inferCommandSourcePath() {
+    const stack = new Error().stack;
+    if (typeof stack !== "string") {
+        return undefined;
+    }
+    for (const line of stack.split("\n").slice(1)) {
+        const candidate = extractStackPath(line);
+        if (candidate === undefined) {
+            continue;
+        }
+        if (candidate.includes("/packages/toolcraft/src/index.ts") ||
+            candidate.includes("/packages/toolcraft/dist/index.js") ||
+            candidate.includes("/node_modules/toolcraft/dist/index.js") ||
+            candidate.includes("/packages/toolcraft/src/runtime.ts") ||
+            candidate.includes("/packages/toolcraft/dist/runtime.js") ||
+            candidate.includes("/node_modules/toolcraft/dist/runtime.js")) {
+            continue;
+        }
+        return candidate;
+    }
+    return undefined;
+}
+function composeChecks(parentCheck, childCheck) {
+    if (parentCheck === undefined) {
+        return childCheck;
+    }
+    if (childCheck === undefined) {
+        return parentCheck;
+    }
+    return async (ctx) => {
+        const parentResult = await parentCheck(ctx);
+        if (!parentResult.ok) {
+            return parentResult;
+        }
+        return childCheck(ctx);
+    };
+}
+function mergeRequires(parent, child) {
+    if (parent === undefined && child === undefined) {
+        return undefined;
+    }
+    const merged = {
+        auth: child?.auth ?? parent?.auth,
+        apiVersion: child?.apiVersion ?? parent?.apiVersion,
+        check: composeChecks(parent?.check, child?.check)
+    };
+    if (merged.auth === undefined && merged.apiVersion === undefined && merged.check === undefined) {
+        return undefined;
+    }
+    return merged;
+}
+function parseSimpleSemver(value) {
+    const parts = value.split(".");
+    if (parts.length !== 3) {
+        return undefined;
+    }
+    const parsed = parts.map((part) => {
+        if (part.length === 0) {
+            return Number.NaN;
+        }
+        for (const char of part) {
+            if (char < "0" || char > "9") {
+                return Number.NaN;
+            }
+        }
+        return Number(part);
+    });
+    if (parsed.some((part) => !Number.isInteger(part) || part < 0)) {
+        return undefined;
+    }
+    return parsed;
+}
+function parseMinimumApiVersion(requirement) {
+    if (!requirement.startsWith(">=")) {
+        return undefined;
+    }
+    return parseSimpleSemver(requirement.slice(2).trim());
+}
+function compareSemver(left, right) {
+    for (let index = 0; index < left.length; index += 1) {
+        if (left[index] === right[index]) {
+            continue;
+        }
+        return left[index] > right[index] ? 1 : -1;
+    }
+    return 0;
+}
+export function resolveCommandSecrets(command, env = defaultEnvironment()) {
+    const secrets = {};
+    for (const [name, secret] of Object.entries(command.secrets)) {
+        const value = env[secret.env];
+        if (value === undefined && secret.optional !== true) {
+            const details = secret.description ? `\n  ${secret.description}` : "";
+            const candidates = Object.keys(env).filter((candidate) => candidate !== secret.env && env[candidate] !== undefined);
+            const suggestions = suggestSecretEnv(secret.env, candidates);
+            const suggestionLine = suggestions.length > 0 ? `\nDid you mean: ${suggestions.join(", ")}?` : "";
+            throw new UserError(`Missing required secret ${secret.env}${details}${suggestionLine}`);
+        }
+        Object.defineProperty(secrets, name, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    return secrets;
+}
+function suggestSecretEnv(input, candidates) {
+    const directSuggestions = suggest(input, candidates);
+    if (!input.includes("_")) {
+        return directSuggestions;
+    }
+    const inputParts = input.split("_");
+    const firstPart = inputParts[0];
+    const lastPart = inputParts[inputParts.length - 1];
+    const relatedCandidates = candidates.filter((candidate) => {
+        const candidateParts = candidate.split("_");
+        return (candidateParts[0] === firstPart && candidateParts[candidateParts.length - 1] === lastPart);
+    });
+    const expandedSuggestions = suggest(input, relatedCandidates, {
+        threshold: Math.max(4, Math.floor(input.length / 4))
+    });
+    return [...new Set([...directSuggestions, ...expandedSuggestions])].slice(0, 3);
+}
+export async function assertCommandRequirements(command, context, options = {}) {
+    const requires = command.requires;
+    if (requires === undefined) {
+        return;
+    }
+    const env = options.env ?? defaultEnvironment();
+    const authEnvVar = options.authEnvVar ?? "POE_API_KEY";
+    if (requires.auth === true && env[authEnvVar] === undefined) {
+        throw new UserError(`Command "${command.name}" requires authentication.\n  Run 'poe-code login' first.`);
+    }
+    if (requires.apiVersion !== undefined) {
+        const minimumVersion = parseMinimumApiVersion(requires.apiVersion);
+        if (minimumVersion === undefined) {
+            throw new UserError(`Command "${command.name}" has invalid apiVersion requirement "${requires.apiVersion}". Expected format ">=X.Y.Z".`);
+        }
+        if (options.apiVersion === undefined) {
+            throw new UserError(`Command "${command.name}" requires API version ${requires.apiVersion}, but no runner API version was provided.`);
+        }
+        const runnerVersion = parseSimpleSemver(options.apiVersion);
+        if (runnerVersion === undefined) {
+            throw new UserError(`Command "${command.name}" requires API version ${requires.apiVersion}, but runner API version "${options.apiVersion}" is not valid semver.`);
+        }
+        if (compareSemver(runnerVersion, minimumVersion) < 0) {
+            throw new UserError(`Command "${command.name}" requires API version ${requires.apiVersion}, but runner API version is ${options.apiVersion}.`);
+        }
+    }
+    const checkResult = await requires.check?.(context);
+    if (checkResult && !checkResult.ok) {
+        throw new UserError(checkResult.message ?? "Command precondition failed.");
+    }
+}
+function mergeSecrets(parent, child) {
+    return cloneSecrets({
+        ...parent,
+        ...child
+    });
+}
+function resolveCommandScope(ownScope, inheritedScope) {
+    return cloneScope(ownScope ?? inheritedScope) ?? ["cli", "sdk"];
+}
+function resolveGroupScope(ownScope, inheritedScope) {
+    return cloneScope(ownScope ?? inheritedScope);
+}
+function createBaseCommand(config) {
+    if (config.mcpResult !== undefined && config.result === undefined) {
+        throw new ToolcraftBugError(`Command "${config.name}" defines mcpResult without a result schema.`);
+    }
+    const command = {
+        kind: "command",
+        name: config.name,
+        title: config.title,
+        description: config.description,
+        annotations: cloneToolAnnotations(config.annotations),
+        hidden: config.hidden ?? false,
+        examples: cloneCommandExamples(config.examples),
+        aliases: [...(config.aliases ?? [])],
+        positional: [...(config.positional ?? [])],
+        params: config.params,
+        result: config.result,
+        mcpResult: config.mcpResult,
+        stream: undefined,
+        secrets: cloneSecrets(config.secrets),
+        scope: resolveCommandScope(config.scope, undefined),
+        confirm: config.confirm ?? false,
+        humanInLoop: config.humanInLoop,
+        requires: cloneRequires(config.requires),
+        handler: config.handler,
+        render: config.render
+    };
+    Object.defineProperty(command, commandConfigSymbol, {
+        value: {
+            title: config.title,
+            annotations: cloneToolAnnotations(config.annotations),
+            scope: cloneScope(config.scope),
+            hidden: config.hidden ?? false,
+            examples: cloneCommandExamples(config.examples),
+            result: config.result,
+            mcpResult: config.mcpResult,
+            humanInLoop: config.humanInLoop,
+            secrets: cloneSecrets(config.secrets),
+            requires: cloneRequires(config.requires),
+            sourcePath: inferCommandSourcePath()
+        }
+    });
+    return command;
+}
+function createBaseGroup(config) {
+    const group = {
+        kind: "group",
+        name: config.name,
+        description: config.description,
+        aliases: [...(config.aliases ?? [])],
+        scope: resolveGroupScope(config.scope, undefined),
+        humanInLoop: config.humanInLoop,
+        secrets: cloneSecrets(config.secrets),
+        requires: cloneRequires(config.requires),
+        children: [],
+        default: undefined
+    };
+    Object.defineProperty(group, groupConfigSymbol, {
+        value: {
+            mcp: cloneMcpServerConfig(config.mcp),
+            scope: cloneScope(config.scope),
+            humanInLoop: config.humanInLoop,
+            secrets: cloneSecrets(config.secrets),
+            tools: cloneStringArray(config.tools),
+            rename: cloneRenameMap(config.rename),
+            requires: cloneRequires(config.requires),
+            children: [...config.children],
+            default: config.default
+        }
+    });
+    return group;
+}
+function getInternalCommandConfig(command) {
+    return command[commandConfigSymbol];
+}
+function getInternalGroupConfig(group) {
+    return group[groupConfigSymbol];
+}
+function materializeCommand(command, inherited) {
+    const internal = getInternalCommandConfig(command);
+    const materialized = {
+        kind: "command",
+        name: command.name,
+        title: internal.title,
+        description: command.description,
+        annotations: cloneToolAnnotations(internal.annotations),
+        hidden: internal.hidden,
+        examples: cloneCommandExamples(internal.examples),
+        aliases: [...command.aliases],
+        positional: [...command.positional],
+        params: command.params,
+        result: internal.result,
+        mcpResult: internal.mcpResult,
+        stream: command.stream,
+        secrets: mergeSecrets(inherited.secrets, internal.secrets),
+        scope: resolveCommandScope(internal.scope, inherited.scope),
+        confirm: command.confirm,
+        humanInLoop: mergeHumanInLoopFromGroup(inherited.humanInLoop, internal.humanInLoop),
+        requires: mergeRequires(inherited.requires, internal.requires),
+        handler: command.handler,
+        render: command.render
+    };
+    Object.defineProperty(materialized, commandConfigSymbol, {
+        value: {
+            title: internal.title,
+            annotations: cloneToolAnnotations(internal.annotations),
+            scope: cloneScope(internal.scope),
+            hidden: internal.hidden,
+            examples: cloneCommandExamples(internal.examples),
+            result: internal.result,
+            mcpResult: internal.mcpResult,
+            humanInLoop: internal.humanInLoop,
+            secrets: cloneSecrets(internal.secrets),
+            requires: cloneRequires(internal.requires),
+            sourcePath: internal.sourcePath
+        }
+    });
+    Object.defineProperty(materialized, commandSourcePathSymbol, {
+        value: internal.sourcePath
+    });
+    return materialized;
+}
+function mergeInheritedMetadata(group, inherited) {
+    return {
+        scope: resolveGroupScope(group.scope, inherited.scope),
+        humanInLoop: mergeHumanInLoopFromGroup(inherited.humanInLoop, group.humanInLoop),
+        secrets: mergeSecrets(inherited.secrets, group.secrets),
+        requires: mergeRequires(inherited.requires, group.requires)
+    };
+}
+function materializeGroup(group, inherited) {
+    const internal = getInternalGroupConfig(group);
+    const mergedInherited = mergeInheritedMetadata(internal, inherited);
+    const materializedChildren = internal.children.map((child) => materializeNode(child, mergedInherited));
+    let defaultChild;
+    if (internal.default !== undefined) {
+        const defaultIndex = internal.children.indexOf(internal.default);
+        if (defaultIndex === -1) {
+            throw new ToolcraftBugError(`Default command "${internal.default.name}" must be listed in children.`);
+        }
+        const resolvedDefault = materializedChildren[defaultIndex];
+        if (resolvedDefault?.kind !== "command") {
+            throw new ToolcraftBugError(`Default child "${internal.default.name}" must be a command.`);
+        }
+        defaultChild = resolvedDefault;
+    }
+    const materialized = {
+        kind: "group",
+        name: group.name,
+        description: group.description,
+        aliases: [...group.aliases],
+        scope: mergedInherited.scope,
+        humanInLoop: mergedInherited.humanInLoop,
+        secrets: mergedInherited.secrets,
+        requires: mergedInherited.requires,
+        children: materializedChildren,
+        default: defaultChild
+    };
+    Object.defineProperty(materialized, groupConfigSymbol, {
+        value: {
+            mcp: cloneMcpServerConfig(internal.mcp),
+            scope: cloneScope(internal.scope),
+            humanInLoop: internal.humanInLoop,
+            secrets: cloneSecrets(internal.secrets),
+            tools: cloneStringArray(internal.tools),
+            rename: cloneRenameMap(internal.rename),
+            requires: cloneRequires(internal.requires),
+            children: [...internal.children],
+            default: internal.default
+        }
+    });
+    return materialized;
+}
+function materializeNode(node, inherited) {
+    if (node.kind === "command") {
+        return materializeCommand(node, inherited);
+    }
+    return materializeGroup(node, inherited);
+}
+export function defineCommand(config) {
+    validateHumanInLoopOnDefine(config);
+    return materializeCommand(createBaseCommand(config), {
+        scope: undefined,
+        humanInLoop: undefined,
+        secrets: {},
+        requires: undefined
+    });
+}
+export function defineStreamCommand(config) {
+    const command = defineCommand({
+        ...config,
+        confirm: false,
+        humanInLoop: null,
+        handler: config.handler,
+        render: undefined
+    });
+    command.stream = {
+        event: config.event,
+        bufferSize: 1
+    };
+    command.render = config.render;
+    return command;
+}
+export function defineGroup(config) {
+    validateRenameMap(config.rename);
+    validateHumanInLoopOnDefine(config);
+    return materializeGroup(createBaseGroup(config), {
+        scope: undefined,
+        humanInLoop: undefined,
+        secrets: {},
+        requires: undefined
+    });
+}
+export function cloneCommandNode(node, scopeOverride) {
+    function rebuildNode(current, root, withinProxy) {
+        const description = current.kind === "command"
+            ? commandConfigSymbol.description
+            : groupConfigSymbol.description;
+        const symbol = Object.getOwnPropertySymbols(current).find((candidate) => candidate.description === description);
+        const config = symbol === undefined ? undefined : Reflect.get(current, symbol);
+        const inherited = root || config === undefined ? current : config;
+        const metadata = {
+            scope: scopeOverride ?? inherited.scope,
+            humanInLoop: inherited.humanInLoop,
+            secrets: inherited.secrets,
+            requires: inherited.requires
+        };
+        if (current.kind === "command") {
+            const base = createBaseCommand({ ...current, ...metadata });
+            if (config !== undefined) {
+                getInternalCommandConfig(base).sourcePath = config.sourcePath;
+            }
+            base.stream = current.stream === undefined ? undefined : { ...current.stream };
+            return base;
+        }
+        const groupConfig = config;
+        const proxyChildren = withinProxy || groupConfig?.mcp !== undefined;
+        const sourceChildren = current.children.filter((child) => !proxyChildren || !isProxyNode(child));
+        const children = sourceChildren.map((child) => rebuildNode(child, false, proxyChildren));
+        const defaultIndex = current.default === undefined ? -1 : sourceChildren.indexOf(current.default);
+        if (current.default !== undefined && defaultIndex === -1) {
+            throw new ToolcraftBugError(`Default command "${current.default.name}" must be listed in children.`);
+        }
+        return createBaseGroup({
+            ...current,
+            ...metadata,
+            mcp: groupConfig?.mcp,
+            tools: groupConfig?.tools,
+            rename: groupConfig?.rename,
+            children,
+            default: defaultIndex === -1 ? undefined : children[defaultIndex]
+        });
+    }
+    return materializeNode(rebuildNode(node, true, false), {
+        scope: undefined,
+        humanInLoop: undefined,
+        secrets: {},
+        requires: undefined
+    });
+}
+export function getCommandSourcePath(command) {
+    return command[commandSourcePathSymbol];
+}
+export function hasMcpProxyConfig(group) {
+    const configSymbol = Object.getOwnPropertySymbols(group).find((candidate) => candidate.description === groupConfigSymbol.description);
+    const config = configSymbol === undefined
+        ? undefined
+        : group[configSymbol];
+    if (config?.mcp !== undefined) {
+        return true;
+    }
+    const children = config?.children ?? group.children;
+    return children.some((child) => child.kind === "group" && hasMcpProxyConfig(child));
+}
+export { S, toJsonSchema, withStandardSchema } from "./schema.js";
+export { AuthenticationError, BadRequestError, ClientError, ConflictError, HttpError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, ServerError, ServiceUnavailableError, UnprocessableEntityError, createHttpError } from "./http-errors.js";
+export { ApprovalDeclinedError, ToolcraftBugError, UserError, isUserError };
+export { suggest } from "./suggest.js";
+export { createRuntimeLogger, isLogLevel, shouldEmitDiagnostic } from "./runtime-logging.js";
+export { isSensitiveName, redactHttpBody } from "./redaction.js";
+export { asMCPResult } from "./mcp-result.js";

package/node_modules/@noble/hashes/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Paul Miller (https://paulmillr.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.