toolcraft 0.0.17 → 0.0.18

package/dist/error-report.d.ts

@@ -0,0 +1,39 @@
+import type { Command } from "./index.js";
+export type ErrorReportsOption = boolean | {
+    dir?: string;
+};
+export interface ErrorReportContext {
+    argv?: readonly string[];
+    command?: Command<any, any, any, any>;
+    commandPath?: string;
+    env?: Record<string, string | undefined>;
+    error: unknown;
+    errorReports?: ErrorReportsOption;
+    params?: unknown;
+    projectRoot?: string;
+    secrets?: Record<string, string | undefined>;
+    version?: string;
+}
+export interface ErrorReportResult {
+    absolutePath: string;
+    displayPath: string;
+}
+interface HttpErrorLike {
+    name: "HttpError";
+    message: string;
+    request: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+        body?: unknown;
+    };
+    response: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: unknown;
+    };
+}
+declare function hasHttpContext(error: unknown): error is HttpErrorLike;
+export declare function writeErrorReport(context: ErrorReportContext): Promise<ErrorReportResult | undefined>;
+export { hasHttpContext };

package/dist/error-report.js

@@ -0,0 +1,330 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { CommanderError } from "commander";
+import { ApprovalDeclinedError } from "./human-in-loop/types.js";
+import { findProjectRoot } from "./mcp-proxy.js";
+import { findPackageMetadata } from "./package-metadata.js";
+import { UserError } from "./user-error.js";
+const ERROR_REPORTS_ENV = "TOOLCRAFT_ERROR_REPORTS";
+const DEFAULT_SENSITIVE_NAMES = ["password", "token", "apikey", "secret"];
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unwrapOptional(schema) {
+    if (schema.kind === "optional") {
+        return unwrapOptional(schema.inner);
+    }
+    return schema;
+}
+function hasHttpContext(error) {
+    return (error instanceof Error &&
+        error.name === "HttpError" &&
+        isPlainObject(error.request) &&
+        isPlainObject(error.response));
+}
+function isSkippedError(error) {
+    if (error instanceof ApprovalDeclinedError) {
+        return true;
+    }
+    if (error instanceof CommanderError &&
+        (error.code === "commander.helpDisplayed" || error.code === "commander.version")) {
+        return true;
+    }
+    return error instanceof UserError && error.cause === undefined && !hasHttpContext(error);
+}
+function reportsEnabled(option, env) {
+    if (env[ERROR_REPORTS_ENV] === "1") {
+        return true;
+    }
+    return option !== undefined && option !== false;
+}
+function resolveReportDir(option, projectRoot) {
+    const configuredDir = typeof option === "object" ? option.dir : undefined;
+    if (configuredDir === undefined || configuredDir.length === 0) {
+        return path.join(projectRoot, ".toolcraft", "errors");
+    }
+    return path.isAbsolute(configuredDir) ? configuredDir : path.join(projectRoot, configuredDir);
+}
+function resolveProjectRoot(projectRoot) {
+    if (projectRoot !== undefined) {
+        return projectRoot;
+    }
+    return findProjectRoot() ?? os.tmpdir();
+}
+function formatTimestamp(date) {
+    const isoMinute = date.toISOString().slice(0, 16);
+    const colonIndex = isoMinute.indexOf(":");
+    if (colonIndex === -1) {
+        return isoMinute;
+    }
+    return `${isoMinute.slice(0, colonIndex)}${isoMinute.slice(colonIndex + 1)}`;
+}
+function slugifyCommandPath(commandPath) {
+    const source = commandPath === undefined || commandPath.length === 0 ? "root" : commandPath;
+    let output = "";
+    let previousWasDash = false;
+    for (const char of source) {
+        const lower = char.toLowerCase();
+        const isWord = (lower >= "a" && lower <= "z") || (lower >= "0" && lower <= "9");
+        if (isWord) {
+            output += lower;
+            previousWasDash = false;
+            continue;
+        }
+        if (!previousWasDash) {
+            output += "-";
+            previousWasDash = true;
+        }
+    }
+    while (output.startsWith("-")) {
+        output = output.slice(1);
+    }
+    while (output.endsWith("-")) {
+        output = output.slice(0, -1);
+    }
+    return output.length === 0 ? "root" : output;
+}
+function relativeDisplayPath(projectRoot, absolutePath) {
+    const relative = path.relative(projectRoot, absolutePath);
+    return relative.length === 0 || relative.startsWith("..") ? absolutePath : relative;
+}
+function redactValue(value) {
+    if (value === undefined) {
+        return "<unset>";
+    }
+    return `<set, ${value.length} chars>`;
+}
+function isSensitiveName(name) {
+    const normalized = name.toLowerCase();
+    return DEFAULT_SENSITIVE_NAMES.some((candidate) => normalized.includes(candidate));
+}
+function schemaSecretValue(schema) {
+    const unwrapped = unwrapOptional(schema);
+    if (unwrapped.kind === "string" || unwrapped.kind === "number") {
+        return unwrapped.secret;
+    }
+    return undefined;
+}
+function shouldRedactParam(name, schema) {
+    const secret = schemaSecretValue(schema);
+    if (secret !== undefined) {
+        return secret;
+    }
+    return isSensitiveName(name);
+}
+function redactParamsValue(value, schema, name) {
+    if (shouldRedactParam(name, schema)) {
+        return "<redacted>";
+    }
+    const unwrapped = unwrapOptional(schema);
+    if (unwrapped.kind === "object" && isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, childValue]) => {
+            const childSchema = unwrapped.shape[key];
+            return [
+                key,
+                childSchema === undefined ? childValue : redactParamsValue(childValue, childSchema, key)
+            ];
+        }));
+    }
+    if (unwrapped.kind === "array" && Array.isArray(value)) {
+        return value.map((entry) => redactParamsValue(entry, unwrapped.item, name));
+    }
+    return value;
+}
+function redactParams(params, command) {
+    if (command === undefined) {
+        return params;
+    }
+    return redactParamsValue(params, command.params, "");
+}
+function commandSecretEnvNames(secrets) {
+    if (secrets === undefined) {
+        return [];
+    }
+    return Object.values(secrets).map((secret) => secret.env);
+}
+function redactArgv(argv, options) {
+    if (argv === undefined) {
+        return [];
+    }
+    const secretValues = new Set(Object.values(options.secrets ?? {}).filter((value) => value !== undefined && value.length > 0));
+    const secretNames = new Set([
+        ...Object.keys(options.secrets ?? {}),
+        ...commandSecretEnvNames(options.command?.secrets)
+    ]);
+    const output = [];
+    let redactNext = false;
+    for (const arg of argv) {
+        if (redactNext) {
+            output.push("<redacted>");
+            redactNext = false;
+            continue;
+        }
+        const equalsIndex = arg.indexOf("=");
+        const optionName = equalsIndex === -1 ? arg : arg.slice(0, equalsIndex);
+        const normalizedOptionName = optionName.replaceAll("-", "");
+        const sensitiveByName = isSensitiveName(normalizedOptionName) ||
+            [...secretNames].some((name) => normalizedOptionName.toLowerCase().includes(name.toLowerCase()));
+        if (equalsIndex !== -1 && sensitiveByName) {
+            output.push(`${optionName}=<redacted>`);
+            continue;
+        }
+        if (arg.startsWith("-") && sensitiveByName) {
+            output.push(arg);
+            redactNext = true;
+            continue;
+        }
+        let redactedArg = arg;
+        for (const secretValue of secretValues) {
+            redactedArg = redactedArg.split(secretValue).join("<redacted>");
+        }
+        output.push(redactedArg);
+    }
+    return output;
+}
+function stableJson(value) {
+    return JSON.stringify(value, null, 2) ?? "undefined";
+}
+function redactStructuredErrorField(name, value) {
+    if (typeof value === "string" && name.toLowerCase() === "authorization") {
+        return "Bearer ****";
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => redactStructuredErrorField(name, entry));
+    }
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, redactStructuredErrorField(key, entry)]));
+    }
+    return value;
+}
+function ownStructuredFields(error) {
+    const fields = {};
+    for (const key of Object.keys(error)) {
+        if (key === "name" || key === "message" || key === "stack" || key === "cause") {
+            continue;
+        }
+        fields[key] = redactStructuredErrorField(key, error[key]);
+    }
+    return fields;
+}
+function formatStackChain(error) {
+    const lines = [];
+    let current = error;
+    let index = 0;
+    while (current !== undefined) {
+        if (current instanceof Error) {
+            lines.push(index === 0
+                ? (current.stack ?? String(current))
+                : `Caused by: ${current.stack ?? String(current)}`);
+            current = current.cause;
+        }
+        else {
+            lines.push(index === 0 ? String(current) : `Caused by: ${String(current)}`);
+            current = undefined;
+        }
+        index += 1;
+    }
+    return lines.join("\n");
+}
+function formatHeaderValue(name, value) {
+    return name.toLowerCase() === "authorization" ? "Bearer ****" : value;
+}
+function formatHeaders(headers) {
+    return Object.entries(headers)
+        .map(([name, value]) => `${name}: ${formatHeaderValue(name, value)}`)
+        .join("\n");
+}
+function formatBody(body) {
+    if (typeof body === "string") {
+        return body;
+    }
+    return stableJson(body);
+}
+function formatHttpTranscript(error) {
+    const requestLines = [
+        `${error.request.method} ${error.request.url}`,
+        formatHeaders(error.request.headers)
+    ].filter((line) => line.length > 0);
+    if (error.request.body !== undefined) {
+        requestLines.push("", formatBody(error.request.body));
+    }
+    return [
+        "Request:",
+        ...requestLines,
+        "",
+        "Response:",
+        `${error.response.status} ${error.response.statusText}`,
+        formatHeaders(error.response.headers),
+        "",
+        formatBody(error.response.body)
+    ].join("\n");
+}
+function resolveToolcraftVersion(version) {
+    return (version ??
+        findPackageMetadata(new URL("./error-report.ts", import.meta.url))?.version ??
+        "unknown");
+}
+function buildReport(context) {
+    const env = context.env ?? process.env;
+    const error = context.error;
+    const errorName = error instanceof Error ? error.name : typeof error;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const structuredFields = error instanceof Error ? ownStructuredFields(error) : {};
+    const secretLines = Object.entries(context.command?.secrets ?? {}).map(([name, secret]) => {
+        const value = context.secrets?.[name] ?? env[secret.env];
+        return `${secret.env}=${redactValue(value)}`;
+    });
+    const lines = [
+        "Toolcraft Error Report",
+        "",
+        "Runtime",
+        `toolcraft version: ${resolveToolcraftVersion(context.version)}`,
+        `node version: ${process.version}`,
+        `platform: ${process.platform} ${process.arch}`,
+        "",
+        "Argv",
+        stableJson(redactArgv(context.argv, { command: context.command, secrets: context.secrets })),
+        "",
+        "Resolved Secrets",
+        ...(secretLines.length === 0 ? ["<none>"] : secretLines),
+        "",
+        "Command Path",
+        context.commandPath === undefined || context.commandPath.length === 0
+            ? "root"
+            : context.commandPath,
+        "",
+        "Parsed Params",
+        stableJson(redactParams(context.params, context.command)),
+        "",
+        "Error",
+        `name: ${errorName}`,
+        `message: ${errorMessage}`,
+        "structured fields:",
+        stableJson(structuredFields),
+        "",
+        "Stack",
+        formatStackChain(error)
+    ];
+    if (hasHttpContext(error)) {
+        lines.push("", "HTTP Transcript", formatHttpTranscript(error));
+    }
+    return `${lines.join("\n")}\n`;
+}
+export async function writeErrorReport(context) {
+    const env = context.env ?? process.env;
+    if (!reportsEnabled(context.errorReports, env) || isSkippedError(context.error)) {
+        return undefined;
+    }
+    const projectRoot = resolveProjectRoot(context.projectRoot);
+    const reportDir = resolveReportDir(context.errorReports, projectRoot);
+    const fileName = `${formatTimestamp(new Date())}-${slugifyCommandPath(context.commandPath)}.log`;
+    const absolutePath = path.join(reportDir, fileName);
+    await mkdir(reportDir, { recursive: true });
+    await writeFile(absolutePath, buildReport(context));
+    return {
+        absolutePath,
+        displayPath: relativeDisplayPath(projectRoot, absolutePath)
+    };
+}
+export { hasHttpContext };

package/dist/human-in-loop/approval-tasks.js

@@ -14,14 +14,14 @@ export async function ensureApprovalList(runtimeOptions, deps = {}) {
     const tasks = taskList.list(listName);
     if (!isListValidated(runtimeOptions, listName)) {
         if (!isApprovalStateMachine(tasks.stateMachine)) {
-            throw new UserError("approvals task-list configured with a different state machine; pass approvalStateMachine when opening the list");
+            throw new UserError(`Approvals task list was created with a different version of toolcraft. Delete the task list directory (${getTaskListDirectory(runtimeOptions.taskList)}) or pass a matching approvalStateMachine.`);
         }
         cacheValidatedList(runtimeOptions, listName);
     }
     return {
         taskList,
         listName,
-        tasks,
+        tasks
     };
 }
 export async function enqueueApproval(ctx) {
@@ -64,7 +64,7 @@ async function resolveTaskList(runtimeOptions, taskList, openTaskListFn) {
         create: true,
         type: taskList.format,
         path: taskList.dir,
-        stateMachine: approvalStateMachine,
+        stateMachine: approvalStateMachine
     });
     openedTaskListsByRuntime.set(runtimeOptions, openedTaskList);
     return openedTaskList;
@@ -95,21 +95,21 @@ function createApprovalRecord(payload, enqueuedAt) {
             enqueuedAt,
             pid: null,
             result: null,
-            error: null,
+            error: null
         },
         pending: {
             status: "pending-approval",
             approvalId,
             message: payload.message,
-            enqueuedAt,
-        },
+            enqueuedAt
+        }
     };
 }
 async function createApprovalTask(tasks, approval) {
     await tasks.create({
         id: approval.approvalId,
         name: approval.name,
-        metadata: approval.metadata,
+        metadata: approval.metadata
     });
 }
 function isApprovalStateMachine(stateMachine) {
@@ -121,6 +121,9 @@ function isApprovalStateMachine(stateMachine) {
 function isTaskListConfig(taskList) {
     return taskList !== undefined && "dir" in taskList;
 }
+function getTaskListDirectory(taskList) {
+    return isTaskListConfig(taskList) ? taskList.dir : "unknown";
+}
 function isDeepEqualStateMachine(left, right) {
     if (!areEqualStrings(left.states, right.states)) {
         return false;
@@ -196,6 +199,6 @@ function approvalPayloadFromTask(task) {
         enqueuedAt: metadata.enqueuedAt,
         pid: typeof metadata.pid === "number" || metadata.pid === null ? metadata.pid : undefined,
         result: metadata.result,
-        error: metadata.error,
+        error: metadata.error
     };
 }

package/dist/human-in-loop/approvals-commands.js

@@ -6,10 +6,10 @@ const approvalsGroupSymbol = Symbol("toolcraft.humanInLoop.approvalsBuiltIn");
 const listScope = ["cli", "mcp", "sdk"];
 const runScope = ["cli"];
 const listParams = S.Object({
-    state: S.Optional(S.String()),
+    state: S.Optional(S.String())
 });
 const showParams = S.Object({
-    approvalId: S.String(),
+    approvalId: S.String()
 });
 export const approvalsGroup = markApprovalsBuiltIn(defineGroup({
     name: "approvals",
@@ -27,8 +27,8 @@ export const approvalsGroup = markApprovalsBuiltIn(defineGroup({
             render: {
                 rich: (result, primitives) => renderApprovalList(result, primitives),
                 markdown: (result) => renderApprovalListMarkdown(result),
-                json: (result) => result,
-            },
+                json: (result) => result
+            }
         }),
         defineCommand({
             name: "show",
@@ -42,17 +42,17 @@ export const approvalsGroup = markApprovalsBuiltIn(defineGroup({
             render: {
                 rich: (result, primitives) => renderApprovalDetails(result, primitives),
                 markdown: (result) => renderApprovalDetailsMarkdown(result),
-                json: (result) => result,
-            },
+                json: (result) => result
+            }
         }),
         defineCommand({
             name: "run",
             description: "Run one queued approval.",
             scope: runScope,
             params: showParams,
-            handler: async ({ params, runtimeOptions, root }) => runApproval(params.approvalId, runtimeOptions, root),
-        }),
-    ],
+            handler: async ({ params, runtimeOptions, root }) => runApproval(params.approvalId, runtimeOptions, root)
+        })
+    ]
 }));
 export function mergeApprovalsGroup(root) {
     const existing = root.children.find((child) => child.name === approvalsGroup.name);
@@ -60,7 +60,7 @@ export function mergeApprovalsGroup(root) {
         if (isApprovalsBuiltIn(existing)) {
             return root;
         }
-        throw new UserError("Error: 'approvals' is reserved for human-in-loop built-ins");
+        throw new UserError("'approvals' is reserved for human-in-loop built-ins");
     }
     root.children = [...root.children, approvalsGroup];
     return root;
@@ -70,12 +70,13 @@ function markApprovalsBuiltIn(group) {
         configurable: false,
         enumerable: false,
         value: true,
-        writable: false,
+        writable: false
     });
     return group;
 }
 function isApprovalsBuiltIn(node) {
-    return node.kind === "group" && node[approvalsGroupSymbol] === true;
+    return (node.kind === "group" &&
+        node[approvalsGroupSymbol] === true);
 }
 async function loadApprovals(tasks, stateFilter) {
     const states = splitStateFilter(stateFilter);
@@ -86,7 +87,7 @@ async function loadApprovals(tasks, stateFilter) {
     const approvals = [];
     for (const state of states) {
         const matching = await tasks.all({
-            state,
+            state
         });
         for (const task of matching) {
             if (seenIds.has(task.qualifiedId)) {
@@ -124,13 +125,13 @@ function renderApprovalList(result, { logger, renderTable, getTheme }) {
         columns: [
             { name: "id", title: "ID", alignment: "left", maxLen: 24 },
             { name: "state", title: "State", alignment: "left", maxLen: 18 },
-            { name: "name", title: "Name", alignment: "left", maxLen: 60 },
+            { name: "name", title: "Name", alignment: "left", maxLen: 60 }
         ],
         rows: result.map((task) => ({
             id: task.id,
             state: task.state,
-            name: task.name,
-        })),
+            name: task.name
+        }))
     }));
 }
 function renderApprovalListMarkdown(result) {
@@ -148,12 +149,12 @@ function renderApprovalDetails(result, { logger, renderTable, getTheme }) {
         theme: getTheme(),
         columns: [
             { name: "key", title: "Key", alignment: "left", maxLen: 18 },
-            { name: "value", title: "Value", alignment: "left", maxLen: 80 },
+            { name: "value", title: "Value", alignment: "left", maxLen: 80 }
         ],
         rows: Object.entries(taskToRecord(result)).map(([key, value]) => ({
             key,
-            value: stringifyValue(value),
-        })),
+            value: stringifyValue(value)
+        }))
     }));
 }
 function renderApprovalDetailsMarkdown(result) {
@@ -169,7 +170,7 @@ function taskToRecord(task) {
         name: task.name,
         state: task.state,
         description: task.description,
-        metadata: task.metadata,
+        metadata: task.metadata
     };
 }
 function stringifyValue(value) {

package/dist/human-in-loop/default-provider.js

@@ -5,8 +5,8 @@ function noProviderConfigured() {
     return {
         id: "noProviderConfigured",
         async requestApproval() {
-            throw new UserError("no human-in-loop provider configured for this platform — pass humanInLoop.provider to the runtime");
-        },
+            throw new UserError("No human-in-loop provider is configured. Pass {humanInLoop: {provider: ...}} to runCLI / createMCPServer / createSDK, or run on macOS to use the default osascript provider.");
+        }
     };
 }
 function createDefaultProviderFactory() {
@@ -16,7 +16,9 @@ function createDefaultProviderFactory() {
             return provider;
         }
         provider =
-            process.platform === "darwin" ? osascriptProvider({ title: "Approval needed" }) : noProviderConfigured();
+            process.platform === "darwin"
+                ? osascriptProvider({ title: "Approval needed" })
+                : noProviderConfigured();
         return provider;
     };
 }

package/dist/human-in-loop/runner.js

@@ -2,6 +2,7 @@ import { access, readFile, writeFile } from "node:fs/promises";
 import { UserError, resolveCommandSecrets } from "../index.js";
 import { ensureApprovalList } from "./approval-tasks.js";
 import { resolveProvider } from "./gate.js";
+const MAX_AVAILABLE_COMMAND_PATHS = 20;
 export async function runApproval(approvalId, runtimeOptions, root) {
     const { tasks } = await ensureApprovalList(runtimeOptions);
     const task = await tasks.get(approvalId);
@@ -95,25 +96,65 @@ function readApprovalPayload(task) {
 }
 function findCommand(root, commandPath) {
     const pathSegments = commandPath.split(".").filter((segment) => segment.length > 0);
+    const unknownCommandPathError = () => new UserError(`Unknown approval command path "${commandPath}". ${formatAvailableApprovalCommandPaths(root)}`);
     if (pathSegments.length === 0) {
-        throw new UserError(`Unknown approval command path "${commandPath}".`);
+        throw unknownCommandPathError();
     }
     let current = root;
     for (const segment of pathSegments) {
         if (current.kind !== "group") {
-            throw new UserError(`Unknown approval command path "${commandPath}".`);
+            throw unknownCommandPathError();
         }
         const next = current.children.find((child) => child.name === segment);
         if (next === undefined) {
-            throw new UserError(`Unknown approval command path "${commandPath}".`);
+            throw unknownCommandPathError();
         }
         current = next;
     }
     if (current.kind !== "command") {
-        throw new UserError(`Unknown approval command path "${commandPath}".`);
+        throw unknownCommandPathError();
     }
     return current;
 }
+function formatAvailableApprovalCommandPaths(root) {
+    const paths = enumerateApprovalCommandPaths(root);
+    const visiblePaths = paths.slice(0, MAX_AVAILABLE_COMMAND_PATHS);
+    const remaining = paths.length - visiblePaths.length;
+    const suffix = remaining > 0 ? `, … and ${remaining} more` : "";
+    return `Available: ${visiblePaths.join(", ")}${suffix}.`;
+}
+function enumerateApprovalCommandPaths(root) {
+    const paths = [];
+    const visit = (node, path) => {
+        if (node.kind === "command") {
+            paths.push(path.join("."));
+            return;
+        }
+        for (const child of getVisibleCliChildren(node)) {
+            visit(child, [...path, child.name]);
+        }
+    };
+    if (root.kind === "command") {
+        visit(root, [root.name]);
+        return paths.sort();
+    }
+    for (const child of getVisibleCliChildren(root)) {
+        visit(child, [child.name]);
+    }
+    return paths.sort();
+}
+function isNodeVisibleInCli(node) {
+    if (node.kind === "command") {
+        return node.scope.includes("cli");
+    }
+    return (getVisibleCliChildren(node).length > 0 ||
+        Boolean(node.default && node.default.scope.includes("cli")) ||
+        node.scope === undefined ||
+        node.scope.includes("cli"));
+}
+function getVisibleCliChildren(root) {
+    return root.kind === "group" ? root.children.filter(isNodeVisibleInCli) : [];
+}
 function createHandlerContext(command, params) {
     return {
         params,

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import type { ObjectSchema, Static } from "toolcraft-schema";
 import type { LoggerOutput, RenderTableOptions, ThemePalette } from "@poe-code/design-system";
 import { ApprovalDeclinedError } from "./human-in-loop/types.js";
 import type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntimeOptions } from "./human-in-loop/types.js";
-import { UserError } from "./user-error.js";
+import { ToolcraftBugError, UserError } from "./user-error.js";
 type ScopeValue = "cli" | "mcp" | "sdk";
 type AnyObjectSchema = ObjectSchema<Record<string, never>>;
 type EmptyServices = Record<string, never>;
@@ -178,7 +178,7 @@ export declare function defineGroup<TServices extends object = EmptyServices, TN
 }): Group<TServices> & TypedGroupMetadata<TServices, TName, TChildren, TOwnScope, ResolveOwnHumanInLoopMode<TOwnHumanInLoop>>;
 export declare function getCommandSourcePath(command: Command<any, any, any, any>): string | undefined;
 export { S, toJsonSchema } from "toolcraft-schema";
-export { ApprovalDeclinedError, UserError };
+export { ApprovalDeclinedError, ToolcraftBugError, UserError };
 export { findPackageMetadata, packageMetadata } from "./package-metadata.js";
 export type { PackageMetadata } from "./package-metadata.js";
 export type { AnySchema, ArraySchema, BooleanSchema, EnumSchema, JsonSchema, NumberSchema, ObjectSchema, OptionalSchema, Static, StringSchema } from "toolcraft-schema";