toolcraft 0.0.748 → 0.0.750

package/dist/index.js

@@ -1,574 +1,2 @@
-import { fileURLToPath } from "node:url";
-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")) {
-            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 = process.env) {
-    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 ?? process.env;
-    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 * from "./runtime.js";
 export { findPackageMetadata, packageMetadata } from "./package-metadata.js";
-export { asMCPResult } from "./mcp-result.js";

package/dist/runtime-platform.d.ts

@@ -0,0 +1,2 @@
+export { fileURLToPath } from "node:url";
+export declare function defaultEnvironment(): Record<string, string | undefined>;

package/dist/runtime-platform.js

@@ -0,0 +1,2 @@
+export { fileURLToPath } from "node:url";
+export function defaultEnvironment() { return process.env; }

package/dist/runtime-platform.workerd.d.ts

@@ -0,0 +1,3 @@
+/** Stack locations are diagnostic only; Workers have no host environment. */
+export declare function fileURLToPath(value: string): string;
+export declare function defaultEnvironment(): Record<string, string | undefined>;

package/dist/runtime-platform.workerd.js

@@ -0,0 +1,10 @@
+/** Stack locations are diagnostic only; Workers have no host environment. */
+export function fileURLToPath(value) {
+    const url = new URL(value);
+    if (url.protocol !== "file:" || (url.hostname && url.hostname !== "localhost"))
+        throw new Error("Not a local file URL");
+    if (url.pathname.toLowerCase().includes("%2f"))
+        throw new Error("Encoded path separators are not file paths");
+    return decodeURIComponent(url.pathname);
+}
+export function defaultEnvironment() { return {}; }