toolcraft 0.0.363 → 0.0.364

package/README.md

@@ -13,11 +13,95 @@ You have one-off scripts and MCP servers. Each one re-derives argument parsing,
 - `runCLI` — argv parsing, `--help`, kebab/snake flags, exit codes.
 - `createMCPServer` / `runMCP` — JSON-RPC over stdio with auto-generated tool schemas.
 - `createSDK` — typed in-process function calls.
+- `toolcraftCommands` — register a whole library in Safe Bash with captured help, local status and streaming output.
 
 Same handler runs everywhere. Schema, secrets, preconditions, and human-in-loop gating are declared once.
 
 Building from an OpenAPI spec? Use [`toolcraft-openapi`](../toolcraft-openapi/) to generate toolcraft commands from the API contract.
 
+## Use a library inside Safe Bash
+
+Install `toolcraft` and `@poe-platform/safe-bash` in the application that owns the shell.
+
+```ts
+import { Shell, createMemoryFileSystem } from "@poe-platform/safe-bash";
+import { toolcraftCommands, toolcraftDefaults } from "toolcraft/safe-bash";
+
+const shell = new Shell({ fs: createMemoryFileSystem(), env: {} });
+shell.use(toolcraftCommands(myToolcraftLibrary));
+const result = await shell.exec("tools list-users --limit 10 --output json");
+await shell.dispose();
+```
+
+Each root name and alias becomes a virtual command. Nested groups, command aliases,
+default commands, positional arguments, schema defaults, scalar/enum/array/object/
+record/union inputs and CLI scope filtering reuse Toolcraft's CLI parser. Hidden
+commands are excluded from this surface. Standalone CLI behavior remains unchanged.
+No CLI subprocess or per-tool adapter is needed.
+
+Configure services or declared parameter defaults once for the library:
+
+```ts
+shell.use(toolcraftCommands(myToolcraftLibrary, {
+  services: { baseUrl: "https://api.example.com", api: existingApiClient },
+  defaults: toolcraftDefaults(myToolcraftLibrary, {
+    "users/list_users": { limit: 25 },
+  }),
+  version: "1.0.0",
+}));
+```
+
+The `toolcraftDefaults` helper infers declaration paths and parameter types from
+`defineGroup`/`defineCommand` metadata; keep child arrays as tuples (`as const`) for
+precise inference. Runtime defaults also accept a record. Paths use original
+names, separated by `/`, relative to a single root; arrays of roots require the
+root name prefix. Aliases share the same defaults. Unknown paths/parameters and
+invalid values fail at registration. Schema defaults come first, then plugin
+defaults, then explicit argv (including false, zero, empty strings and null).
+Arrays and objects replace the lower-priority value as a whole. Defaults are
+snapshotted, and resolved parameters are validated before requirements and approvals.
+Service objects retain their client identities and cannot override runtime fields.
+
+`createToolcraftCommandExecutor(library, options).execute(argv, invocation)` is the
+same public execution contract without plugin registration. A single-root executor
+accepts arguments after the root command; a multiple-root executor expects the root
+name/alias as its first token. `ToolcraftInvocation` supplies async byte sinks,
+stdin, cancellation, virtual filesystem/cwd, explicit environment, services and
+optional authorized fetch/human-in-loop capabilities. The result is `{ exitCode }`.
+Help/version/results use stdout; errors and diagnostics use stderr. Both sinks are
+awaited, and streaming commands wait for writes before consuming the next event.
+Cancellation preserves the abort reason and closes the active iterator. A sink
+failure propagates to the shell, including its output budget failures. The plugin
+never sets host exit status, installs host signal listeners or prompts host stdin.
+`confirm` commands require explicit `--yes`; wire approval policy with the optional
+`humanInLoop` runtime. `controls` configures existing output formats and log controls.
+
+Handlers are trusted application code; this adapter does not sandbox JavaScript.
+The filesystem bridge uses the invocation's virtual cwd and original filesystem,
+including middleware and budget state. Text reads/writes support Node encodings;
+writes support `w`, `wx` and `a`. Other flags fail explicitly. Missing fetch is
+denied; there is no native network fallback. Callers own supplied capabilities;
+plugin disposal does not close them. Synchronous rendering is bounded to 1 MiB of
+pending output; use `defineStreamCommand` or the invocation's async sinks for larger
+outputs. Binary/artifact results have no automatic binary renderer; existing MCP
+structured/text rendering is retained.
+
+Native plugins currently exclude MCP proxy discovery, host fixture loading,
+file presets, interactive parameter resolvers and detached approval runners.
+Use an explicitly supplied in-process approval provider; providers that spawn a
+runner remain application code. Shell `capabilities` supplies borrowed `services`,
+authorized `fetch`, and `humanInLoop` to each library automatically. Per-execution
+capabilities override shell defaults; explicit `undefined` revokes a capability.
+`agentCommands({ regexExecutor, regex })` also supplies its exact bounded regex
+provider and effective limits as `ctx.regex.executor` and `ctx.regex.limits`.
+`BoundedRegexProvider`, `RegexExecutionOptions`, and `RegexExecutor` are public
+safe-bash exports; missing regex never gains a native JavaScript fallback. Native
+handlers can use `signal`, byte `stdin`/`stdout`/`stderr`, `cwd`, `inputBudget`,
+`invoke` and `registerCleanup`. Dry-run readback uses an explicitly supplied mock
+or overlay filesystem. Library services combine with invocation services; runtime
+capability names are reserved and cannot be replaced through services.
+Schema pattern validation currently follows Toolcraft's existing validator.
+
 ## What the owner decides
 
 Before writing toolcraft code, make a small tool map. For each script or MCP tool, write down:

package/composition.json

@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.363",
+      "version": "0.0.364",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.363",
+      "version": "0.0.364",
       "license": "MIT"
     },
     {

package/dist/cli.d.ts

@@ -54,6 +54,15 @@ export interface RunCLIOptions<TServices extends object = Record<string, unknown
     presets?: boolean;
     errorReports?: ErrorReportsOption;
 }
+/** Invocation-local transport used by the native command executor. */
+export interface CLIInvocationRuntime {
+    signal: AbortSignal;
+    write(chunk: string, stream?: "stdout" | "stderr"): void;
+    flush(): Promise<void>;
+    exitCode: number;
+    defaults?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    capabilities?: Readonly<Record<string, unknown>>;
+}
 export interface CLICommandTreeSnapshotOption {
     name: string;
     flags: string[];
@@ -112,3 +121,5 @@ export interface CLICommandTreeSnapshotOptions {
  */
 export declare function createCLICommandTreeSnapshot<TServices extends object>(roots: Group<TServices> | Group<TServices>[], options?: CLICommandTreeSnapshotOptions): Promise<CLICommandTreeSnapshot>;
 export declare function runCLI<TServices extends object = Record<string, unknown>>(roots: Group<TServices> | Group<TServices>[], options?: RunCLIOptions<TServices>): Promise<void>;
+/** Shared parser, validation and dispatch; native callers supply a local runtime. */
+export declare function executeCLICommand<TServices extends object>(roots: Group<TServices> | Group<TServices>[], options: RunCLIOptions<TServices>, invocation?: CLIInvocationRuntime): Promise<void>;

package/dist/cli.js

@@ -112,17 +112,18 @@ function splitWords(value) {
     }
     return words;
 }
-function formatSegment(segment, casing) {
+/** @internal */
+export function formatCLIName(segment, casing) {
     const separator = casing === "snake" ? "_" : "-";
     return splitWords(segment).join(separator);
 }
 function toOptionFlag(path, casing) {
-    return `--${path.map((segment) => formatSegment(segment, casing)).join(".")}`;
+    return `--${path.map((segment) => formatCLIName(segment, casing)).join(".")}`;
 }
 function toOptionAttribute(path, casing) {
     return path
         .map((segment) => {
-        const formatted = formatSegment(segment, casing);
+        const formatted = formatCLIName(segment, casing);
         if (casing === "snake") {
             return formatted;
         }
@@ -164,7 +165,7 @@ function createSyntheticEnumSchema(values) {
 function getRequiredBranchFingerprint(branch, casing) {
     const requiredKeys = Object.entries(branch.shape)
         .filter(([, schema]) => schema.kind !== "optional")
-        .map(([key]) => formatSegment(key, casing))
+        .map(([key]) => formatCLIName(key, casing))
         .sort();
     return requiredKeys.join("+");
 }
@@ -1207,7 +1208,7 @@ function collectDynamicObjectHelpRows(schema, casing, optionPrefix, displayPrefi
     const rows = [];
     for (const [key, rawChildSchema] of Object.entries(schema.shape)) {
         const childSchema = unwrapOptional(rawChildSchema);
-        const optionFlag = `${optionPrefix}.${formatSegment(key, casing)}`;
+        const optionFlag = `${optionPrefix}.${formatCLIName(key, casing)}`;
         const displayPath = `${displayPrefix}.${key}`;
         const rawDescription = childSchema.description ?? displayPath;
         const description = suppressEchoHelpDescription(rawDescription, displayPath);
@@ -1740,14 +1741,15 @@ function renderHelpDocument(input) {
     lines.push(renderHelpSections(input.sections));
     return `${lines.join("\n").trimEnd()}\n`;
 }
-async function renderGeneratedHelp(root, argv, options) {
+async function renderGeneratedHelp(root, argv, options, invocation) {
+    const write = invocation?.write ?? ((chunk) => { process.stdout.write(chunk); });
     const output = resolveHelpOutput(argv);
     const casing = options.casing ?? "kebab";
     const rootUsageName = options.rootUsageName ?? inferProgramName(argv);
     const target = resolveHelpTarget(root, argv, "cli", rootUsageName, options.rootDisplayName);
     const controls = resolveCLIControls(options.controls);
     if (output === "json") {
-        process.stdout.write(renderJsonHelp(target, root, casing, {
+        write(renderJsonHelp(target, root, casing, {
             controls,
             showVersion: options.version !== undefined,
             presetsEnabled: options.presets === true
@@ -1766,7 +1768,7 @@ async function renderGeneratedHelp(root, argv, options) {
                 showVersion: options.version !== undefined,
                 presetsEnabled: options.presets === true
             }, rootUsageName);
-        process.stdout.write(rendered);
+        write(rendered);
     });
 }
 function createNodeCommand(node, casing, globalLongOptionFlags, execute, presetsEnabled, controls, fieldLoaders, pathSegments = []) {
@@ -1832,6 +1834,7 @@ function createNodeCommand(node, casing, globalLongOptionFlags, execute, presets
                 await execute({
                     command: node,
                     commandPath: nextPathSegments.join("."),
+                    declarationPath: nextPathSegments,
                     casing,
                     dynamicFields: collected.dynamicFields,
                     fields,
@@ -2723,8 +2726,8 @@ function createFixtureEnvValues(command) {
     }
     return values;
 }
-async function resolveFixtureRuntime(command, services, requirementOptions, runtimeFetch, runtimeEnv, runtimeFs) {
-    const selector = process.env.TOOLCRAFT_FIXTURE;
+async function resolveFixtureRuntime(command, services, requirementOptions, runtimeFetch, runtimeEnv, runtimeFs, embedded = false) {
+    const selector = embedded ? undefined : process.env.TOOLCRAFT_FIXTURE;
     if (selector === undefined || selector.length === 0) {
         return {
             env: createEnv(runtimeEnv),
@@ -2966,12 +2969,12 @@ function resolveDynamicLeaf(schema, rawSegments, casing, outputPath = [], displa
         case "object": {
             const [head, ...rest] = rawSegments;
             for (const [key, childSchema] of Object.entries(unwrappedSchema.shape)) {
-                if (formatSegment(key, casing) !== head) {
+                if (formatCLIName(key, casing) !== head) {
                     continue;
                 }
                 return resolveDynamicLeaf(childSchema, rest, casing, [...outputPath, key], [...displayPath, key], displayPathPrefix);
             }
-            throw new UserError(`Unknown parameter "${qualifyDisplayPath(displayPathPrefix, [...displayPath, head].join("."))}". ${formatAvailableList(Object.keys(unwrappedSchema.shape).map((key) => qualifyDisplayPath(displayPathPrefix, toDisplayPath([...displayPath, formatSegment(key, casing)]))))}`);
+            throw new UserError(`Unknown parameter "${qualifyDisplayPath(displayPathPrefix, [...displayPath, head].join("."))}". ${formatAvailableList(Object.keys(unwrappedSchema.shape).map((key) => qualifyDisplayPath(displayPathPrefix, toDisplayPath([...displayPath, formatCLIName(key, casing)]))))}`);
         }
         case "record": {
             const [head, ...rest] = rawSegments;
@@ -3123,7 +3126,7 @@ function resolveDynamicOption(dynamicFields, flagName, casing) {
     const match = [...dynamicFields]
         .sort((left, right) => right.optionPath.length - left.optionPath.length)
         .find((field) => {
-        const optionPath = field.optionPath.map((segment) => formatSegment(segment, casing));
+        const optionPath = field.optionPath.map((segment) => formatCLIName(segment, casing));
         return flagPath.length > optionPath.length &&
             optionPath.every((segment, index) => flagPath[index] === segment);
     });
@@ -3317,11 +3320,28 @@ async function enforceVariantConstraints(params, fields, dynamicFields, variants
         }
     }
 }
-async function resolveParams(fields, dynamicFields, variants, positionalValues, optionValues, rawArgv, casing, presetPath, shouldPrompt, missingParameterContext, promptStreams) {
+async function resolveParams(fields, dynamicFields, variants, positionalValues, optionValues, rawArgv, casing, presetPath, shouldPrompt, missingParameterContext, promptStreams, parameterDefaults = {}) {
     const params = {};
     const errors = [];
     const dynamicResults = parseDynamicValues(dynamicFields, rawArgv, casing, errors);
     const positionalTokens = [...positionalValues, ...dynamicResults.positionals];
+    const fieldRoot = (field) => field.synthetic
+        ? (field.path.length === 1 ? field.path[0].slice(0, -"Kind".length) : field.path[0])
+        : field.path[0];
+    const explicitRoots = new Set();
+    for (const field of fields) {
+        if (hasFieldValue(optionValues[field.commanderOptionAttribute]) ||
+            (field.positionalIndex !== undefined && positionalTokens[field.positionalIndex] !== undefined)) {
+            explicitRoots.add(fieldRoot(field));
+        }
+    }
+    for (const field of dynamicFields) {
+        if (dynamicResults.values.has(field.id))
+            explicitRoots.add(field.path[0]);
+    }
+    const defaultRoots = new Set(Object.keys(parameterDefaults).filter(key => !explicitRoots.has(key)));
+    for (const key of defaultRoots)
+        params[key] = cloneDefaultValue(parameterDefaults[key]);
     const positionalFields = fields.filter((field) => field.positionalIndex !== undefined);
     if (!positionalFields.some((field) => field.variadicPosition === true) &&
         positionalTokens.length > positionalFields.length) {
@@ -3333,6 +3353,8 @@ async function resolveParams(fields, dynamicFields, variants, positionalValues,
     const providedFieldIds = new Set();
     const resolvedFieldValues = new Map();
     for (const field of fields) {
+        if (defaultRoots.has(fieldRoot(field)))
+            continue;
         let value;
         let resolvedMissing = false;
         let source;
@@ -3463,6 +3485,8 @@ async function resolveParams(fields, dynamicFields, variants, positionalValues,
         }
     }
     for (const field of dynamicFields) {
+        if (defaultRoots.has(field.path[0]))
+            continue;
         let value = dynamicResults.values.get(field.id);
         if (presetValues.dynamic.has(field.id)) {
             if (value === undefined)
@@ -3484,7 +3508,7 @@ async function resolveParams(fields, dynamicFields, variants, positionalValues,
         }
         setNestedValue(params, field.path, value);
     }
-    await enforceVariantConstraints(params, fields, dynamicFields, variants, resolvedFieldValues, dynamicResults.providedFieldIds, providedFieldIds, shouldPrompt, errors, promptStreams);
+    await enforceVariantConstraints(params, fields, dynamicFields, variants.filter(variant => !defaultRoots.has(fieldRoot(fields.find(field => field.id === variant.controlFieldId)))), resolvedFieldValues, dynamicResults.providedFieldIds, providedFieldIds, shouldPrompt, errors, promptStreams);
     throwValidationErrors(errors);
     return params;
 }
@@ -3499,7 +3523,7 @@ function getResolvedFlags(command) {
     }
     return flags;
 }
-async function executeCommand(state, rootUsageName, services, requirementOptions, runtimeFetch, humanInLoop, runtimeEnv, runtimeFs, outputEmitter, outputFormats, promptStreams, diagnosticsOptions, onErrorReportContext) {
+async function executeCommand(state, rootUsageName, services, requirementOptions, runtimeFetch, humanInLoop, runtimeEnv, runtimeFs, outputEmitter, outputFormats, promptStreams, diagnosticsOptions, onErrorReportContext, invocation) {
     const logger = createLogger(outputEmitter);
     const optionValues = getResolvedFlags(state.actionCommand);
     const resolvedFlags = optionValues;
@@ -3508,7 +3532,7 @@ async function executeCommand(state, rootUsageName, services, requirementOptions
         logger,
         renderTable,
         getTheme,
-        note,
+        note: invocation ? (message, title) => note(message, title, invocation.write) : note,
         outputFormat: output
     };
     const diagnostics = createRuntimeLogger({
@@ -3516,10 +3540,12 @@ async function executeCommand(state, rootUsageName, services, requirementOptions
             (diagnosticsOptions.verboseControlEnabled && resolvedFlags.verbose
                 ? "trace"
                 : diagnosticsOptions.logLevel),
-        logger: diagnosticsOptions.logger ?? writeCLIDiagnosticEvent
+        logger: diagnosticsOptions.logger ?? (invocation
+            ? (event) => invocation.write(`${event.message}\n`, "stderr")
+            : writeCLIDiagnosticEvent)
     });
-    const promptInput = promptStreams.input ?? process.stdin;
-    const promptOutput = promptStreams.output ?? process.stdout;
+    const promptInput = promptStreams.input ?? (invocation ? { isTTY: false } : process.stdin);
+    const promptOutput = promptStreams.output ?? (invocation ? { isTTY: false } : process.stdout);
     const stdinTTY = Boolean(promptInput.isTTY);
     const stdoutTTY = Boolean(promptOutput.isTTY);
     const shouldPrompt = !resolvedFlags.yes && stdinTTY;
@@ -3532,9 +3558,11 @@ async function executeCommand(state, rootUsageName, services, requirementOptions
             stdoutTTY
         }
         : undefined;
-    const runtime = await resolveFixtureRuntime(state.command, services, requirementOptions, runtimeFetch, runtimeEnv, runtimeFs);
+    const runtime = await resolveFixtureRuntime(state.command, services, requirementOptions, runtimeFetch, runtimeEnv, runtimeFs, invocation !== undefined);
     const preflightContext = {
         ...runtime.services,
+        ...invocation?.capabilities,
+        ...(invocation ? { signal: invocation.signal } : {}),
         secrets: runtime.secrets,
         fetch: runtime.fetch,
         fs: runtime.fs,
@@ -3549,14 +3577,28 @@ async function executeCommand(state, rootUsageName, services, requirementOptions
     let resolvedParams;
     try {
         await withOutputFormat(toDesignSystemOutput(output), async () => {
-            await assertCommandRequirements(state.command, preflightContext, runtime.requirementOptions);
-            const params = await resolveParams(state.fields, state.dynamicFields, state.variants, state.positionalValues, optionValues, state.rawArgv, state.casing, state.presetsEnabled ? resolvedFlags.preset : undefined, shouldPrompt, missingParameterContext, promptStreams);
+            if (!invocation)
+                await assertCommandRequirements(state.command, preflightContext, runtime.requirementOptions);
+            const params = await resolveParams(state.fields, state.dynamicFields, state.variants, state.positionalValues, optionValues, state.rawArgv, state.casing, state.presetsEnabled ? resolvedFlags.preset : undefined, shouldPrompt, missingParameterContext, promptStreams, invocation?.defaults?.[state.declarationPath.join("/")]);
             const paramsSchema = state.command.params;
             if (paramsSchema !== undefined && paramsSchema[nativeJsonSchema] !== undefined) {
                 const validation = validateSchema(paramsSchema, params);
                 if (!validation.ok)
                     throwValidationErrors(validation.issues.map((issue) => formatFieldValidationIssue(issue, "")));
             }
+            if (invocation) {
+                const validation = validateSchema(state.command.params, params);
+                if (!validation.ok) {
+                    throwValidationErrors(validation.issues.map((issue) => formatFieldValidationIssue(issue, "")));
+                    return;
+                }
+                Object.assign(params, validation.value);
+                invocation.signal.throwIfAborted();
+                await assertCommandRequirements(state.command, { ...preflightContext, params }, runtime.requirementOptions);
+                if (state.command.confirm && !state.command.humanInLoop && !resolvedFlags.yes) {
+                    throw new UserError("Confirmation required; supply --yes to authorize this command.");
+                }
+            }
             resolvedParams = params;
             runtimeSecrets = runtime.secrets;
             const context = {
@@ -3566,6 +3608,7 @@ async function executeCommand(state, rootUsageName, services, requirementOptions
             if (state.command.stream !== undefined) {
                 const stream = createManagedStream({
                     eventSchema: state.command.stream.event,
+                    signal: invocation?.signal,
                     onStatus(event) {
                         diagnostics.emit({
                             level: "info",
@@ -3590,9 +3633,11 @@ async function executeCommand(state, rootUsageName, services, requirementOptions
                 const interrupt = () => {
                     void stream.cancel(new UserError("Operation cancelled.")).catch(() => undefined);
                 };
-                process.once("SIGINT", interrupt);
+                if (!invocation)
+                    process.once("SIGINT", interrupt);
                 try {
                     for await (const event of stream) {
+                        invocation?.signal.throwIfAborted();
                         if (output === "json") {
                             const line = JSON.stringify(event);
                             if (outputEmitter === undefined) {
@@ -3603,14 +3648,17 @@ async function executeCommand(state, rootUsageName, services, requirementOptions
                             }
                         }
                         else {
-                            renderCLIResult(state.command, state.commandPath, event, output, primitives, outputFormats, outputEmitter === undefined
+                            renderCLIResult(state.command, state.commandPath, event, output, primitives, outputFormats, invocation?.write ?? (outputEmitter === undefined
                                 ? undefined
-                                : (chunk) => outputEmitter(chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk), outputEmitter);
+                                : (chunk) => outputEmitter(chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk)), outputEmitter);
                         }
+                        await invocation?.flush();
                     }
+                    invocation?.signal.throwIfAborted();
                 }
                 finally {
-                    process.removeListener("SIGINT", interrupt);
+                    if (!invocation)
+                        process.removeListener("SIGINT", interrupt);
                     await stream.cancel();
                 }
                 return;
@@ -3644,16 +3692,20 @@ async function executeCommand(state, rootUsageName, services, requirementOptions
             if (output === "rich" && runtime.isFixture) {
                 writeRichHeader(`${state.command.name} (fixture)`);
             }
+            invocation?.signal.throwIfAborted();
             const pendingApproval = isHumanInLoopPending(result);
             if (pendingApproval && output === "rich") {
                 renderHumanInLoopPending(result, rootUsageName, outputEmitter);
                 return;
             }
-            const renderStatus = renderCLIResult(pendingApproval ? { ...state.command, render: undefined } : state.command, state.commandPath, result, output, primitives, outputFormats, outputEmitter === undefined
+            const renderStatus = renderCLIResult(pendingApproval ? { ...state.command, render: undefined } : state.command, state.commandPath, result, output, primitives, outputFormats, invocation?.write ?? (outputEmitter === undefined
                 ? undefined
-                : (chunk) => outputEmitter(chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk), outputEmitter);
+                : (chunk) => outputEmitter(chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk)), outputEmitter);
             if (renderStatus.mcpError) {
-                process.exitCode = 1;
+                if (invocation)
+                    invocation.exitCode = 1;
+                else
+                    process.exitCode = 1;
             }
         });
     }
@@ -4200,6 +4252,10 @@ function configureCommanderSuggestionOutput(command, version) {
 }
 export async function runCLI(roots, options = {}) {
     enableSourceMaps();
+    await executeCLICommand(roots, options);
+}
+/** Shared parser, validation and dispatch; native callers supply a local runtime. */
+export async function executeCLICommand(roots, options, invocation) {
     const controls = resolveCLIControls(options.controls);
     let argv = [...(options.argv ?? process.argv)];
     const rootUsageName = options.rootUsageName ?? inferProgramName(argv);
@@ -4215,6 +4271,8 @@ export async function runCLI(roots, options = {}) {
         const root = mergeApprovalsRoot(normalizedRoot, options);
         assertHumanInLoopWired(root, options.humanInLoop);
         if (hasMcpProxyConfig(root)) {
+            if (invocation)
+                throw new UserError("MCP proxy discovery requires the standalone CLI; native library plugins support in-process handlers only.");
             const proxyRuntime = await importOptionalModule(optionalModulePaths.mcpProxy);
             await proxyRuntime.resolveMcpProxies(root, { projectRoot: options.projectRoot });
             proxyCleanup = { dispose: proxyRuntime.disposeMcpProxies, root };
@@ -4223,7 +4281,7 @@ export async function runCLI(roots, options = {}) {
         const services = (options.services ?? {});
         const humanInLoop = options.humanInLoop;
         const runtimeFetch = options.fetch ?? globalThis.fetch;
-        version = options.version ?? findEntrypointPackageMetadata(argv[1])?.version;
+        version = options.version ?? (invocation ? undefined : findEntrypointPackageMetadata(argv[1])?.version);
         const servicesWithBuiltIns = {
             ...services,
             humanInLoop,
@@ -4236,7 +4294,7 @@ export async function runCLI(roots, options = {}) {
         validateServices(services);
         if (argv.length <= 2 && root.default?.scope.includes("cli") !== true) {
             userErrorPattern = "usage";
-            await renderGeneratedHelp(root, argv, { ...options, version });
+            await renderGeneratedHelp(root, argv, { ...options, version }, invocation);
             return;
         }
         program = new CommanderCommand();
@@ -4266,7 +4324,7 @@ export async function runCLI(roots, options = {}) {
                 verboseControlEnabled: controls.verbose
             }, (context) => {
                 errorReportContext = context;
-            });
+            }, invocation);
         };
         const rootChildNames = new Set(root.children
             .filter((candidate) => isNodeVisibleInScope(candidate, "cli"))
@@ -4282,11 +4340,18 @@ export async function runCLI(roots, options = {}) {
             addCommanderChild(program, command, isDefaultChild, rootChildNames);
         }
         configureCommanderSuggestionOutput(program, version);
+        if (invocation) {
+            const configure = (command) => {
+                command.configureOutput({ writeOut: chunk => invocation.write(chunk), writeErr: chunk => invocation.write(chunk, "stderr") });
+                command.commands.forEach(configure);
+            };
+            configure(program);
+        }
         const prepared = prepareCliArguments(program, argv, fieldLoaders, casing, controls);
         argv = prepared.argv;
         if (prepared.helpArgv !== undefined) {
             userErrorPattern = "usage";
-            await renderGeneratedHelp(root, prepared.helpArgv, { ...options, version });
+            await renderGeneratedHelp(root, prepared.helpArgv, { ...options, version }, invocation);
             return;
         }
         for (const loadFields of fieldLoaders.values()) {
@@ -4294,6 +4359,8 @@ export async function runCLI(roots, options = {}) {
         }
         const unknownCommand = findUnknownCommanderCommand(program, argv);
         if (unknownCommand !== undefined) {
+            if (invocation)
+                throw new UserError(formatUnknownCommandMessage(unknownCommand.input, unknownCommand.currentCommand));
             await withOutputFormat(toDesignSystemOutput(resolveOutputFromArgv(argv, controls.outputFormats)), async () => {
                 renderCliErrorPattern({
                     kind: "usage",
@@ -4308,6 +4375,15 @@ export async function runCLI(roots, options = {}) {
         await program.parseAsync(argv);
     }
     catch (error) {
+        if (invocation) {
+            if (invocation.signal.aborted)
+                throw invocation.signal.reason;
+            invocation.exitCode = error instanceof CommanderError ? error.exitCode : 1;
+            if (!(error instanceof CommanderError && error.exitCode === 0)) {
+                invocation.write(`${error instanceof Error ? error.message : String(error)}\n`, "stderr");
+            }
+            return;
+        }
         const resolvedFlags = lastActionCommand ? getResolvedFlags(lastActionCommand) : undefined;
         if (error instanceof ApprovalDeclinedError) {
             await withOutputFormat(toDesignSystemOutput(resolvedFlags !== undefined
@@ -4353,6 +4429,7 @@ export async function runCLI(roots, options = {}) {
         });
     }
     finally {
+        await invocation?.flush();
         if (proxyCleanup !== undefined) {
             try {
                 await proxyCleanup.dispose(proxyCleanup.root);

package/dist/composition.json

@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.363",
+      "version": "0.0.364",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.363",
+      "version": "0.0.364",
       "license": "MIT"
     },
     {

package/dist/index.d.ts

@@ -68,7 +68,7 @@ export interface CommandExample {
     title: string;
     params: Record<string, unknown>;
 }
-export type GroupCheckContext<TServices extends object = EmptyServices> = TServices & {
+export type GroupCheckContext<TServices extends object = EmptyServices> = TServices & HandlerInvocationCapabilities & {
     params?: unknown;
     secrets?: Record<string, string | undefined>;
     fetch: typeof globalThis.fetch;
@@ -78,7 +78,7 @@ export type GroupCheckContext<TServices extends object = EmptyServices> = TServi
     signal?: AbortSignal;
     progress(message: string): void;
 };
-export type CommandCheckContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & {
+export type CommandCheckContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & HandlerInvocationCapabilities & {
     params?: Static<TParamsSchema>;
     secrets?: InferSecrets<TSecrets>;
     fetch: typeof globalThis.fetch;
@@ -105,7 +105,11 @@ export interface ToolAnnotations {
     idempotentHint?: boolean;
     openWorldHint?: boolean;
 }
-export type HandlerContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & {
+/** Additional capabilities supplied by native invocation hosts. */
+export interface HandlerInvocationCapabilities {
+    readonly signal?: AbortSignal;
+}
+export type HandlerContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & HandlerInvocationCapabilities & {
     params: Static<TParamsSchema>;
     secrets: InferSecrets<TSecrets>;
     fetch: typeof globalThis.fetch;

package/dist/runtime/io.js

@@ -8,9 +8,18 @@ export const RESERVED_SERVICE_NAMES = new Set([
     "diagnostics",
     "progress",
     "runtimeOptions",
-    "root"
+    "root",
+    "signal",
+    "stdin",
+    "stdout",
+    "stderr",
+    "cwd",
+    "regex",
+    "registerCleanup",
+    "invoke",
+    "inputBudget"
 ]);
-const RESERVED_SERVICE_NAMES_MESSAGE = "Available reserved names: params, secrets, fetch, fs, env, diagnostics, progress, runtimeOptions, root.";
+const RESERVED_SERVICE_NAMES_MESSAGE = `Available reserved names: ${[...RESERVED_SERVICE_NAMES].join(", ")}.`;
 export function createFs(fs) {
     if (fs !== undefined) {
         return fs;

package/dist/safe-bash-capabilities.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/safe-bash-capabilities.compile-check.js

@@ -0,0 +1,11 @@
+const revoked = { capabilities: { fetch: undefined, regex: undefined, services: undefined } };
+const provider = { createWorker() { throw new Error("synthetic provider"); } };
+const supplied = {
+    services: { client: {} },
+    regex: { executor: provider, limits: { requestTimeoutMs: 17 } },
+    fetch: undefined,
+    humanInLoop: undefined
+};
+void revoked;
+void supplied;
+export {};

package/dist/safe-bash.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/safe-bash.compile-check.js

@@ -0,0 +1,16 @@
+import { S, defineCommand, defineGroup } from "./index.js";
+import { toolcraftCommands, toolcraftDefaults } from "./safe-bash.js";
+const users = defineGroup({ name: "users", children: [
+        defineCommand({ name: "list_users", params: S.Object({ limit: S.Number(), enabled: S.Boolean() }), handler: ({ params }) => params })
+    ] });
+const library = defineGroup({ name: "tools", children: [users] });
+toolcraftCommands(library, { defaults: toolcraftDefaults(library, { "users/list_users": { limit: 25, enabled: false } }) });
+// @ts-expect-error unknown declaration path
+toolcraftDefaults(library, { "users/missing": { limit: 25 } });
+// @ts-expect-error unknown parameter
+toolcraftDefaults(library, { "users/list_users": { typo: 25 } });
+// @ts-expect-error wrong schema value type
+toolcraftDefaults(library, { "users/list_users": { limit: "25" } });
+toolcraftDefaults([library], { "tools/users/list_users": { limit: 25 } });
+// @ts-expect-error multiple roots require the root prefix
+toolcraftDefaults([library], { "users/list_users": { limit: 25 } });

package/dist/safe-bash.d.ts

@@ -0,0 +1,75 @@
+import type { ByteSink, ByteSource, CommandContext, FileSystem, VirtualShellPlugin, ShellCapabilities } from "@poe-platform/safe-bash";
+import { type AnySchema, type Static } from "toolcraft-schema";
+import type { Group } from "./index.js";
+import type { HumanInLoopRuntime } from "./human-in-loop/types.js";
+import { type CLIControls } from "./cli.js";
+export interface ToolcraftInvocation<TServices extends object = Record<string, never>> {
+    regex?: ShellCapabilities["regex"];
+    registerCleanup?: CommandContext["registerCleanup"];
+    invoke?: CommandContext["invoke"];
+    inputBudget?: CommandContext["inputBudget"];
+    cwd: string;
+    env: Readonly<Record<string, string>>;
+    fs: FileSystem;
+    stdin: ByteSource;
+    stdout: ByteSink;
+    stderr: ByteSink;
+    signal: AbortSignal;
+    services?: TServices;
+    fetch?: typeof globalThis.fetch;
+    humanInLoop?: HumanInLoopRuntime;
+}
+declare module "./index.js" {
+    interface HandlerInvocationCapabilities {
+        readonly cwd?: string;
+        readonly stdin?: ByteSource;
+        readonly stdout?: ByteSink;
+        readonly stderr?: ByteSink;
+        readonly regex?: ShellCapabilities["regex"];
+        readonly registerCleanup?: CommandContext["registerCleanup"];
+        readonly invoke?: CommandContext["invoke"];
+        readonly inputBudget?: CommandContext["inputBudget"];
+    }
+}
+export interface ToolcraftCapabilities<TServices extends object = Record<string, never>> extends ShellCapabilities {
+    readonly services?: TServices | undefined;
+    readonly humanInLoop?: HumanInLoopRuntime | undefined;
+}
+export interface ToolcraftCommandsOptions<TServices extends object = Record<string, never>> {
+    services?: TServices | ((invocation: ToolcraftInvocation<TServices>) => TServices);
+    defaults?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    apiVersion?: string;
+    version?: string;
+    controls?: CLIControls;
+    humanInLoop?: HumanInLoopRuntime;
+}
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer U) => void ? U : never;
+type NodeDefaults<T, TPrefix extends string = ""> = T extends {
+    readonly __agentKitCommandTypeInfo: {
+        name: infer N extends string;
+        params: infer P;
+    };
+} ? P extends AnySchema ? {
+    [K in `${TPrefix}${N}`]?: Partial<Static<P>>;
+} : never : T extends {
+    readonly __agentKitGroupTypeInfo: {
+        name: infer N extends string;
+        children: infer C extends readonly unknown[];
+    };
+} ? UnionToIntersection<NodeDefaults<C[number], `${TPrefix}${N}/`>> : never;
+export type ToolcraftParameterDefaults<TLibrary> = TLibrary extends readonly unknown[] ? UnionToIntersection<NodeDefaults<TLibrary[number]>> : TLibrary extends {
+    readonly __agentKitGroupTypeInfo: {
+        children: infer C extends readonly unknown[];
+    };
+} ? UnionToIntersection<NodeDefaults<C[number]>> : ToolcraftCommandsOptions["defaults"];
+/** Checks paths, parameter names and values against a library's inferred definitions. */
+export declare function toolcraftDefaults<TLibrary>(_library: TLibrary, defaults: ToolcraftParameterDefaults<TLibrary>): ToolcraftParameterDefaults<TLibrary>;
+/** Executes already-tokenized argv in process, using the same parser and dispatch as runCLI. */
+export declare function createToolcraftCommandExecutor<TServices extends object>(library: Group<TServices> | readonly Group<TServices>[], options?: ToolcraftCommandsOptions<TServices>): {
+    execute(argv: readonly string[], invocation: ToolcraftInvocation<TServices>): Promise<{
+        exitCode: number;
+    }>;
+};
+/** Registers every CLI-visible root and alias; nested commands use shared Toolcraft discovery. */
+export declare function toolcraftCommands<TServices extends object>(library: Group<TServices> | readonly Group<TServices>[], options?: ToolcraftCommandsOptions<TServices>): VirtualShellPlugin;
+export {};

package/dist/safe-bash.js

@@ -0,0 +1,195 @@
+import path from "node:path";
+import { cloneDefaultValue, validate } from "toolcraft-schema";
+import { executeCLICommand, formatCLIName } from "./cli.js";
+import { validateServices } from "./runtime/io.js";
+/** Checks paths, parameter names and values against a library's inferred definitions. */
+export function toolcraftDefaults(_library, defaults) {
+    // Snapshot configuration so changing the caller's defaults cannot change registered commands.
+    return cloneDefaultValue(defaults);
+}
+function discoverCommands(root, prefix = "") {
+    const commands = new Map();
+    const visit = (node, commandPath) => {
+        if (node.kind === "command") {
+            if (node.scope.includes("cli") && !node.hidden)
+                commands.set(commandPath, node);
+            return;
+        }
+        if (node.scope && !node.scope.includes("cli"))
+            return;
+        for (const child of node.children)
+            visit(child, `${commandPath}${commandPath ? "/" : ""}${child.name}`);
+    };
+    if (!root.scope || root.scope.includes("cli")) {
+        for (const child of root.children)
+            visit(child, `${prefix}${child.name}`);
+    }
+    return commands;
+}
+function visibleLibrary(root) {
+    const aliases = (node) => {
+        const name = formatCLIName(node.name, "kebab");
+        return name === node.name || node.aliases.includes(name) ? [...node.aliases] : [...node.aliases, name];
+    };
+    const children = root.children.filter(child => child.kind === "command"
+        ? child.scope.includes("cli") && !child.hidden
+        : !child.scope || child.scope.includes("cli"))
+        .map(child => child.kind === "group" ? visibleLibrary(child) : { ...child, aliases: aliases(child) });
+    const defaultCommand = children.find(child => child.kind === "command" && child.name === root.default?.name);
+    return { ...root, aliases: aliases(root), children, default: defaultCommand };
+}
+function handlerFileSystem(invocation) {
+    const { fs, signal, cwd } = invocation;
+    const resolve = (value) => path.posix.resolve(cwd, value);
+    return {
+        async readFile(value, encoding = "utf8") {
+            return Buffer.from(await fs.readFile(resolve(value), { signal })).toString(encoding);
+        },
+        async writeFile(value, contents, options = {}) {
+            const bytes = Buffer.from(contents, options.encoding ?? "utf8");
+            const target = resolve(value);
+            const flag = options.flag ?? "w";
+            if (flag === "a")
+                await fs.appendFile(target, bytes, { signal, mode: options.mode });
+            else if (flag === "w" || flag === "wx")
+                await fs.writeFile(target, bytes, { signal, mode: options.mode, flag });
+            else
+                throw new Error(`Unsupported virtual write flag: ${flag}`);
+        },
+        async exists(value) {
+            try {
+                await fs.stat(resolve(value), { signal });
+                return true;
+            }
+            catch (error) {
+                if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT")
+                    return false;
+                throw error;
+            }
+        },
+        async lstat(value) {
+            const stat = await fs.lstat(resolve(value), { signal });
+            return { isSymbolicLink: () => stat.type === "symlink" };
+        },
+        async rename(from, to) { await fs.rename(resolve(from), resolve(to), { signal }); },
+        async unlink(value) {
+            if (!fs.unlink)
+                throw new Error("Virtual filesystem does not support unlink");
+            await fs.unlink(resolve(value), { signal });
+        }
+    };
+}
+/** Executes already-tokenized argv in process, using the same parser and dispatch as runCLI. */
+export function createToolcraftCommandExecutor(library, options = {}) {
+    const roots = Array.isArray(library) ? library : [library];
+    const multiple = Array.isArray(library);
+    const commands = new Map(roots.flatMap(root => [...discoverCommands(root, multiple ? `${root.name}/` : "")]));
+    const defaults = cloneDefaultValue(options.defaults ?? {});
+    for (const [commandPath, values] of Object.entries(defaults)) {
+        const command = commands.get(commandPath);
+        if (!command)
+            throw new TypeError(`Unknown default command path: ${commandPath}`);
+        for (const [key, value] of Object.entries(values)) {
+            if (!Object.prototype.hasOwnProperty.call(command.params.shape, key))
+                throw new TypeError(`Unknown default parameter: ${commandPath}/${key}`);
+            const result = validate(command.params.shape[key], value);
+            if (!result.ok)
+                throw new TypeError(`Invalid default parameter ${commandPath}/${key}: ${result.issues.map(issue => issue.message).join("; ")}`);
+        }
+    }
+    if (options.services && typeof options.services !== "function")
+        validateServices(options.services);
+    return {
+        async execute(argv, invocation) {
+            invocation.signal.throwIfAborted();
+            let services;
+            let root;
+            try {
+                const configuredServices = typeof options.services === "function" ? options.services(invocation) : options.services;
+                services = { ...invocation.services, ...configuredServices };
+                const rootName = multiple ? argv[0] : roots[0]?.name;
+                const selectedRoot = multiple ? roots.find(candidate => candidate.name === rootName || candidate.aliases.includes(rootName ?? "")) : roots[0];
+                if (!selectedRoot)
+                    throw new TypeError(`Unknown toolcraft root: ${rootName}`);
+                root = selectedRoot;
+            }
+            catch (error) {
+                invocation.signal.throwIfAborted();
+                await invocation.stderr.write(new TextEncoder().encode(`${error instanceof Error ? error.message : String(error)}\n`));
+                return { exitCode: 1 };
+            }
+            const args = multiple ? argv.slice(1) : argv;
+            let pending = Promise.resolve();
+            let queuedBytes = 0;
+            const runtime = {
+                signal: invocation.signal,
+                exitCode: 0,
+                defaults: multiple ? Object.fromEntries(Object.entries(defaults).filter(([key]) => key.startsWith(`${root.name}/`)).map(([key, value]) => [key.slice(root.name.length + 1), value])) : defaults,
+                capabilities: { signal: invocation.signal, stdin: invocation.stdin, stdout: invocation.stdout, stderr: invocation.stderr, cwd: invocation.cwd, regex: invocation.regex, registerCleanup: invocation.registerCleanup, invoke: invocation.invoke, inputBudget: invocation.inputBudget },
+                write(chunk, stream = "stdout") {
+                    invocation.signal.throwIfAborted();
+                    const bytes = new TextEncoder().encode(chunk);
+                    queuedBytes += bytes.byteLength;
+                    if (queuedBytes > 1024 * 1024)
+                        throw new Error("Toolcraft synchronous output exceeded 1 MiB; use a streaming command for larger output");
+                    pending = pending.then(async () => {
+                        invocation.signal.throwIfAborted();
+                        await invocation[stream].write(bytes);
+                        queuedBytes -= bytes.byteLength;
+                    });
+                    // The awaited flush propagates sink failures; observe immediately to avoid unhandled rejections.
+                    void pending.catch(() => { });
+                },
+                async flush() { await pending; }
+            };
+            const deniedFetch = async () => { throw new Error("Network capability is unavailable for this invocation"); };
+            await executeCLICommand(visibleLibrary(root), {
+                argv: ["toolcraft", root.name, ...args],
+                rootUsageName: root.name,
+                version: options.version,
+                apiVersion: options.apiVersion,
+                services: services,
+                env: { ...invocation.env },
+                fs: handlerFileSystem(invocation),
+                fetch: invocation.fetch ?? deniedFetch,
+                humanInLoop: invocation.humanInLoop ?? options.humanInLoop,
+                controls: { output: true, yes: true, ...options.controls },
+                errorReports: false,
+                outputEmitter: entry => runtime.write(`${entry}\n`)
+            }, runtime);
+            return { exitCode: runtime.exitCode };
+        }
+    };
+}
+/** Registers every CLI-visible root and alias; nested commands use shared Toolcraft discovery. */
+export function toolcraftCommands(library, options = {}) {
+    const executor = createToolcraftCommandExecutor(library, options);
+    const roots = Array.isArray(library) ? library : [library];
+    return {
+        name: "toolcraft",
+        setup(host) {
+            if (typeof host.provideCapabilities !== "function")
+                throw new Error("Toolcraft requires a safe-bash runtime with invocation capabilities");
+            for (const root of roots) {
+                if (root.scope && !root.scope.includes("cli"))
+                    continue;
+                for (const name of [root.name, ...root.aliases]) {
+                    host.commands.register({
+                        name,
+                        description: root.description,
+                        execute(context) {
+                            const capabilities = context.capabilities;
+                            return executor.execute(Array.isArray(library) ? [root.name, ...context.args] : context.args, {
+                                ...context,
+                                services: capabilities?.services,
+                                fetch: capabilities?.fetch,
+                                regex: capabilities?.regex,
+                                humanInLoop: capabilities?.humanInLoop
+                            });
+                        }
+                    });
+                }
+            }
+        }
+    };
+}

package/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.363",
+      "version": "0.0.364",
       "license": "MIT"
     }
   ]

package/node_modules/toolcraft-design/dist/prompts/primitives/note.d.ts

@@ -1 +1 @@
-export declare function note(message: string, title?: string): void;
+export declare function note(message: string, title?: string, write?: (chunk: string) => void): void;

package/node_modules/toolcraft-design/dist/prompts/primitives/note.js

@@ -16,7 +16,7 @@ function renderTerminalNote(message, title) {
     const bottom = color.gray(`├${"─".repeat(contentWidth + 2)}╯`);
     return [color.gray("│"), titleLine, ...content, bottom].join("\n");
 }
-export function note(message, title) {
+export function note(message, title, write = process.stdout.write.bind(process.stdout)) {
     const format = resolveOutputFormat();
     const strippedMessage = stripAnsi(message);
     const strippedTitle = stripAnsi(title ?? "").replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
@@ -24,16 +24,16 @@ export function note(message, title) {
         const lines = strippedMessage.split("\n");
         const heading = strippedTitle ? `> **${strippedTitle}**\n` : "";
         const body = lines.map((line) => `> ${line}`).join("\n");
-        process.stdout.write(`${heading}${body}\n`);
+        write(`${heading}${body}\n`);
         return;
     }
     if (format === "json") {
-        process.stdout.write(`${JSON.stringify({
+        write(`${JSON.stringify({
             type: "note",
             title: strippedTitle,
             message: strippedMessage
         })}\n`);
         return;
     }
-    process.stdout.write(`${renderTerminalNote(message, title)}\n`);
+    write(`${renderTerminalNote(message, title)}\n`);
 }

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.363",
+  "version": "0.0.364",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.363",
+  "version": "0.0.364",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -97,6 +97,10 @@
     "./tiny-mcp-client": {
       "types": "./dist/tiny-mcp-client.d.ts",
       "import": "./dist/tiny-mcp-client.js"
+    },
+    "./safe-bash": {
+      "types": "./dist/safe-bash.d.ts",
+      "import": "./dist/safe-bash.js"
     }
   },
   "scripts": {
@@ -158,7 +162,7 @@
     "yaml"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.363",
+    "toolcraft-schema": "0.0.364",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",
@@ -175,6 +179,7 @@
     "auth-store": "*"
   },
   "devDependencies": {
-    "tiny-stdio-mcp-test-server": "*"
+    "tiny-stdio-mcp-test-server": "*",
+    "@poe-platform/safe-bash": "*"
   }
 }