@amalgm/tools 0.1.0

package/dist/cli.js

@@ -0,0 +1,123 @@
+import { loadDefinitions } from './module.js';
+import { Toolbox } from './toolbox.js';
+const HELP = `Usage: amalgm-tools [--state-dir DIR] [--loadout IDS] <command>
+
+Commands:
+  apply <definition.js|json>  Apply one tool or an array of tools
+  list                        List tools and enabled actions
+  catalog                     Print the complete canonical catalog
+  show <tool-or-action-id>    Show one record
+  enable <tool-or-action-id>  Enable one record
+  disable <tool-or-action-id> Disable one record
+  remove <tool-or-action-id>  Remove one record
+  run <action-id> [--input JSON]
+                              Run an action
+  connections                 List MCP connections for a composing host`;
+function parse(argv) {
+    const args = [...argv];
+    let stateDir;
+    let loadout;
+    let input = {};
+    for (let index = 0; index < args.length;) {
+        const flag = args[index];
+        if (flag === '--state-dir') {
+            if (!args[index + 1])
+                throw new Error('--state-dir requires a value');
+            stateDir = args[index + 1];
+            args.splice(index, 2);
+        }
+        else if (flag === '--loadout') {
+            if (args[index + 1] === undefined)
+                throw new Error('--loadout requires a comma-separated value');
+            loadout = args[index + 1].split(',').map((value) => value.trim()).filter(Boolean);
+            args.splice(index, 2);
+        }
+        else if (flag === '--input') {
+            if (!args[index + 1])
+                throw new Error('--input requires JSON');
+            input = JSON.parse(args[index + 1]);
+            args.splice(index, 2);
+        }
+        else
+            index += 1;
+    }
+    return { command: args.shift(), args, stateDir, loadout, input };
+}
+function required(value, label) {
+    if (!value)
+        throw new Error(`${label} is required`);
+    return value;
+}
+function write(output, value) {
+    output.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+async function runCli(argv, io = {}) {
+    const stdout = io.stdout || process.stdout;
+    const stderr = io.stderr || process.stderr;
+    let parsed;
+    try {
+        parsed = parse(argv);
+    }
+    catch (error) {
+        stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+    if (!parsed.command || ['help', '-h', '--help'].includes(parsed.command)) {
+        stdout.write(`${HELP}\n`);
+        return 0;
+    }
+    const toolbox = io.toolbox || new Toolbox({ stateDir: parsed.stateDir });
+    try {
+        const recordId = parsed.args[0];
+        switch (parsed.command) {
+            case 'apply': {
+                const definitions = await loadDefinitions(required(recordId, 'definition file'));
+                const results = [];
+                for (const definition of definitions)
+                    results.push(await toolbox.apply(definition));
+                write(stdout, results.length === 1 ? results[0] : results);
+                break;
+            }
+            case 'list':
+                write(stdout, toolbox.list(parsed.loadout));
+                break;
+            case 'catalog':
+                write(stdout, toolbox.catalog());
+                break;
+            case 'show': {
+                const value = required(recordId, 'tool or action id');
+                const result = toolbox.get(value) || toolbox.action(value);
+                if (!result)
+                    throw new Error(`Unknown tool or action: ${value}`);
+                write(stdout, result);
+                break;
+            }
+            case 'enable':
+                write(stdout, await toolbox.setStatus(required(recordId, 'record id'), 'enabled'));
+                break;
+            case 'disable':
+                write(stdout, await toolbox.setStatus(required(recordId, 'record id'), 'disabled'));
+                break;
+            case 'remove':
+                write(stdout, await toolbox.remove(required(recordId, 'record id')));
+                break;
+            case 'run':
+                write(stdout, await toolbox.call(required(recordId, 'action id'), parsed.input, { loadout: parsed.loadout }));
+                break;
+            case 'connections':
+                write(stdout, toolbox.connections(parsed.loadout));
+                break;
+            default: throw new Error(`Unknown command: ${parsed.command}`);
+        }
+        return 0;
+    }
+    catch (error) {
+        stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+    finally {
+        if (!io.toolbox)
+            toolbox.close();
+    }
+}
+export { HELP, parse, runCli };

package/dist/definition.d.ts

@@ -0,0 +1,7 @@
+import type { ActionRecord, ToolDefinition, ToolRecord } from './types.js';
+declare function normalizeDefinition(definition: ToolDefinition, existing?: ToolRecord, now?: string): {
+    tool: ToolRecord;
+    actions: ActionRecord[];
+};
+declare function defineTool(definition: ToolDefinition): ToolDefinition;
+export { defineTool, normalizeDefinition };

package/dist/definition.js

@@ -0,0 +1,170 @@
+import { actionId, actionName, id } from './ids.js';
+const DEFAULT_TIMEOUT = 30_000;
+const DEFAULT_MAX_OUTPUT = 256_000;
+function string(value, label) {
+    const result = typeof value === 'string' ? value.trim() : '';
+    if (!result)
+        throw new Error(`${label} is required`);
+    return result;
+}
+function strings(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string')) {
+        throw new Error(`${label} must be an array of strings`);
+    }
+    return [...value];
+}
+function positive(value, fallback, label) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value) || Number(value) <= 0)
+        throw new Error(`${label} must be a positive integer`);
+    return Number(value);
+}
+function refs(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${label} must be an object`);
+    const result = {};
+    for (const [key, reference] of Object.entries(value))
+        result[string(key, label)] = string(reference, `${label}.${key}`);
+    return result;
+}
+function base(source) {
+    return {
+        timeoutMs: positive(source.timeoutMs, DEFAULT_TIMEOUT, 'source.timeoutMs'),
+        maxOutputBytes: positive(source.maxOutputBytes, DEFAULT_MAX_OUTPUT, 'source.maxOutputBytes'),
+    };
+}
+function normalizeSource(source) {
+    if (!source || typeof source !== 'object')
+        throw new Error('tool.source is required');
+    if ('headers' in source || 'env' in source) {
+        throw new Error('Inline headers and environment values are forbidden; use secret references');
+    }
+    if (source.type === 'cli') {
+        const inputMode = source.inputMode || 'json-stdin';
+        const outputMode = source.outputMode || 'text';
+        if (!['json-stdin', 'argv', 'none'].includes(inputMode))
+            throw new Error(`Unsupported CLI input mode: ${inputMode}`);
+        if (!['json', 'text'].includes(outputMode))
+            throw new Error(`Unsupported CLI output mode: ${outputMode}`);
+        return {
+            type: 'cli', command: string(source.command, 'source.command'),
+            ...base(source), inputMode, outputMode,
+            ...(strings(source.args, 'source.args') ? { args: strings(source.args, 'source.args') } : {}),
+            ...(source.cwd ? { cwd: string(source.cwd, 'source.cwd') } : {}),
+            ...(refs(source.secretEnv, 'source.secretEnv') ? { secretEnv: refs(source.secretEnv, 'source.secretEnv') } : {}),
+        };
+    }
+    if (source.type === 'api') {
+        const url = new URL(string(source.baseUrl, 'source.baseUrl'));
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new Error('source.baseUrl must use http or https');
+        if (url.username || url.password)
+            throw new Error('source.baseUrl cannot contain credentials');
+        return {
+            type: 'api', baseUrl: url.toString(), ...base(source),
+            ...(refs(source.secretHeaders, 'source.secretHeaders') ? { secretHeaders: refs(source.secretHeaders, 'source.secretHeaders') } : {}),
+        };
+    }
+    if (source.type === 'mcp') {
+        if (!['http', 'sse', 'stdio', 'host'].includes(source.transport))
+            throw new Error(`Unsupported MCP transport: ${source.transport}`);
+        if (['http', 'sse'].includes(source.transport) && !source.url)
+            throw new Error(`${source.transport} MCP tools require source.url`);
+        if (source.transport === 'stdio' && !source.command)
+            throw new Error('stdio MCP tools require source.command');
+        if (source.url) {
+            const url = new URL(source.url);
+            if (!['http:', 'https:'].includes(url.protocol))
+                throw new Error('source.url must use http or https');
+            if (url.username || url.password)
+                throw new Error('source.url cannot contain credentials');
+        }
+        return {
+            type: 'mcp', transport: source.transport, ...base(source),
+            ...(source.url ? { url: string(source.url, 'source.url') } : {}),
+            ...(source.command ? { command: string(source.command, 'source.command') } : {}),
+            ...(strings(source.args, 'source.args') ? { args: strings(source.args, 'source.args') } : {}),
+            ...(source.cwd ? { cwd: string(source.cwd, 'source.cwd') } : {}),
+            ...(source.serverName ? { serverName: string(source.serverName, 'source.serverName') } : {}),
+            ...(refs(source.secretHeaders, 'source.secretHeaders') ? { secretHeaders: refs(source.secretHeaders, 'source.secretHeaders') } : {}),
+            ...(refs(source.secretEnv, 'source.secretEnv') ? { secretEnv: refs(source.secretEnv, 'source.secretEnv') } : {}),
+        };
+    }
+    throw new Error(`Unsupported tool type: ${source.type}`);
+}
+function inputSchema(value) {
+    if (value === undefined)
+        return { type: 'object', properties: {}, additionalProperties: true };
+    if (!value || typeof value !== 'object' || Array.isArray(value) || value.type !== 'object') {
+        throw new Error('action.inputSchema must be an object schema');
+    }
+    const schema = structuredClone(value);
+    if (schema.properties !== undefined && (!schema.properties || typeof schema.properties !== 'object' || Array.isArray(schema.properties))) {
+        throw new Error('action.inputSchema.properties must be an object');
+    }
+    return { ...schema, properties: schema.properties || {} };
+}
+function target(type, value) {
+    const raw = value || {};
+    if (type === 'cli')
+        return { ...(strings(raw.args, 'action.target.args') ? { args: strings(raw.args, 'action.target.args') } : {}) };
+    if (type === 'api')
+        return { method: string(raw.method, 'action.target.method').toUpperCase(), path: string(raw.path, 'action.target.path') };
+    return { name: string(raw.name, 'action.target.name') };
+}
+function normalizeDefinition(definition, existing, now = new Date().toISOString()) {
+    if (!definition || typeof definition !== 'object')
+        throw new Error('tool definition must be an object');
+    const toolId = id(definition.id, 'tool.id', 64);
+    const source = normalizeSource(definition.source);
+    const origin = definition.origin || 'user';
+    if (!['user', 'catalog', 'system'].includes(origin))
+        throw new Error(`Unsupported tool origin: ${origin}`);
+    const tool = {
+        id: toolId, name: string(definition.name, 'tool.name'), source,
+        owner: definition.owner?.trim() || 'user', origin,
+        status: definition.status || 'enabled',
+        ...(definition.description?.trim() ? { description: definition.description.trim() } : {}),
+        ...(definition.display ? { display: structuredClone(definition.display) } : {}),
+        ...(definition.policy ? { policy: structuredClone(definition.policy) } : {}),
+        ...(definition.metadata ? { metadata: structuredClone(definition.metadata) } : {}),
+        createdAt: existing?.createdAt || now, updatedAt: now,
+    };
+    if (!['enabled', 'disabled'].includes(tool.status))
+        throw new Error(`Unsupported tool status: ${tool.status}`);
+    const definitions = definition.actions || (source.type === 'cli' ? [{ name: 'run' }] : []);
+    const seen = new Set();
+    const actions = definitions.map((action) => {
+        const name = actionName(action.name);
+        const canonicalId = actionId(toolId, name);
+        if (action.id && id(action.id, 'action.id') !== canonicalId)
+            throw new Error(`Action id must be ${canonicalId}`);
+        if (seen.has(canonicalId))
+            throw new Error(`Duplicate action: ${canonicalId}`);
+        seen.add(canonicalId);
+        const status = action.status || 'enabled';
+        if (!['enabled', 'disabled'].includes(status))
+            throw new Error(`Unsupported action status: ${status}`);
+        return {
+            id: canonicalId, toolId, name, status,
+            inputSchema: inputSchema(action.inputSchema), target: target(source.type, action.target),
+            ...(action.displayName?.trim() ? { displayName: action.displayName.trim() } : {}),
+            ...(action.description?.trim() ? { description: action.description.trim() } : {}),
+            ...(action.outputSchema ? { outputSchema: structuredClone(action.outputSchema) } : {}),
+            ...(action.policy ? { policy: structuredClone(action.policy) } : {}),
+            ...(action.metadata ? { metadata: structuredClone(action.metadata) } : {}),
+            createdAt: now, updatedAt: now,
+        };
+    });
+    return { tool, actions };
+}
+function defineTool(definition) {
+    normalizeDefinition(definition);
+    return structuredClone(definition);
+}
+export { defineTool, normalizeDefinition };

package/dist/ids.d.ts

@@ -0,0 +1,7 @@
+import type { ActionRecord } from './types.js';
+declare function id(value: unknown, label?: string, maximumLength?: number): string;
+declare function actionName(value: unknown): string;
+declare function actionId(toolId: string, name: string): string;
+declare function mcpName(action: Pick<ActionRecord, 'id'>): string;
+declare function assertMcpNamesUnique(actions: Pick<ActionRecord, 'id'>[]): void;
+export { actionId, actionName, assertMcpNamesUnique, id, mcpName };

package/dist/ids.js

@@ -0,0 +1,38 @@
+function id(value, label = 'id', maximumLength = 120) {
+    const result = String(value || '').trim().toLowerCase();
+    if (!result)
+        throw new Error(`${label} is required`);
+    if (result.length > maximumLength)
+        throw new Error(`${label} must be at most ${maximumLength} characters`);
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(result)) {
+        throw new Error(`${label} must contain only lowercase letters, numbers, dots, underscores, and hyphens`);
+    }
+    return result;
+}
+function actionName(value) {
+    const result = id(value, 'action.name', 48);
+    if (result.includes('.'))
+        throw new Error('action.name cannot contain dots');
+    return result;
+}
+function actionId(toolId, name) {
+    return `${id(toolId, 'tool.id', 64)}.${actionName(name)}`;
+}
+function safeMcpName(value) {
+    return value.replace(/[^A-Za-z0-9_-]+/g, '_').replace(/_+/g, '_');
+}
+function mcpName(action) {
+    return `toolbox__${safeMcpName(action.id)}`;
+}
+function assertMcpNamesUnique(actions) {
+    const names = new Map();
+    for (const action of actions) {
+        const name = mcpName(action);
+        const existing = names.get(name);
+        if (existing && existing !== action.id) {
+            throw new Error(`Actions ${existing} and ${action.id} collide as MCP tool ${name}`);
+        }
+        names.set(name, action.id);
+    }
+}
+export { actionId, actionName, assertMcpNamesUnique, id, mcpName };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { ArtifactFiles } from './artifact-files.js';
+export { LEGACY_TOOLBOX_BACKUP_FILE_NAME, LEGACY_TOOLBOX_FILE_NAME, TOOL_ARTIFACT_KIND, TOOL_ARTIFACT_SCHEMA_VERSION, TOOLBOX_INDEX_FILE_NAME, artifactDocument, catalogIndexDocument, isToolArtifactDocument, legacyMigrationPlan, safeToolId, toolboxIndexDocument, userArtifactFileName, } from './artifacts.js';
+export type { ArtifactFileWrite, LegacyMigrationPlan, ToolArtifactDocument, ToolboxIndexDocument, } from './artifacts.js';
+export { defineTool, normalizeDefinition } from './definition.js';
+export { actionId, actionName, id, mcpName } from './ids.js';
+export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, } from './mcp.js';
+export { createMcpServer } from './mcp-server.js';
+export { Toolbox } from './toolbox.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { ArtifactFiles } from './artifact-files.js';
+export { LEGACY_TOOLBOX_BACKUP_FILE_NAME, LEGACY_TOOLBOX_FILE_NAME, TOOL_ARTIFACT_KIND, TOOL_ARTIFACT_SCHEMA_VERSION, TOOLBOX_INDEX_FILE_NAME, artifactDocument, catalogIndexDocument, isToolArtifactDocument, legacyMigrationPlan, safeToolId, toolboxIndexDocument, userArtifactFileName, } from './artifacts.js';
+export { defineTool, normalizeDefinition } from './definition.js';
+export { actionId, actionName, id, mcpName } from './ids.js';
+export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, } from './mcp.js';
+export { createMcpServer } from './mcp-server.js';
+export { Toolbox } from './toolbox.js';

package/dist/input.d.ts

@@ -0,0 +1,4 @@
+import type { JsonSchema } from './types.js';
+declare function objectInput(value: unknown): Record<string, unknown>;
+declare function validateInput(schema: JsonSchema, value: unknown): Record<string, unknown>;
+export { objectInput, validateInput };

package/dist/input.js

@@ -0,0 +1,43 @@
+function objectInput(value) {
+    if (value === undefined)
+        return {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Tool input must be an object');
+    }
+    return value;
+}
+function matchesType(value, type) {
+    if (type === 'array')
+        return Array.isArray(value);
+    if (type === 'integer')
+        return Number.isInteger(value);
+    if (type === 'number')
+        return typeof value === 'number' && Number.isFinite(value);
+    if (type === 'object')
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    if (type === 'null')
+        return value === null;
+    return typeof value === type;
+}
+function validateInput(schema, value) {
+    const input = objectInput(value);
+    for (const key of schema.required || []) {
+        if (!(key in input))
+            throw new Error(`Tool input is missing required property: ${key}`);
+    }
+    if (schema.additionalProperties === false) {
+        const known = new Set(Object.keys(schema.properties || {}));
+        const extra = Object.keys(input).find((key) => !known.has(key));
+        if (extra)
+            throw new Error(`Tool input contains unknown property: ${extra}`);
+    }
+    for (const [key, property] of Object.entries(schema.properties || {})) {
+        if (!(key in input) || !property.type)
+            continue;
+        if (!matchesType(input[key], property.type)) {
+            throw new Error(`Tool input property ${key} must be ${property.type}`);
+        }
+    }
+    return input;
+}
+export { objectInput, validateInput };

package/dist/mcp-server.d.ts

@@ -0,0 +1,18 @@
+import readline from 'node:readline';
+import type { Readable, Writable } from 'node:stream';
+import { Toolbox } from './toolbox.js';
+import type { ToolboxOptions } from './types.js';
+interface Request {
+    jsonrpc?: string;
+    id?: string | number;
+    method: string;
+    params?: Record<string, any>;
+}
+declare function createMcpServer(options?: ToolboxOptions & {
+    toolbox?: Toolbox;
+}): {
+    toolbox: Toolbox;
+    handle: (request: Request) => Promise<unknown>;
+    start: (input?: Readable, output?: Writable) => readline.Interface;
+};
+export { createMcpServer };

package/dist/mcp-server.js

@@ -0,0 +1,61 @@
+import readline from 'node:readline';
+import { callMcpTool, createMcpTools } from './mcp.js';
+import { Toolbox } from './toolbox.js';
+function descriptor(tool) {
+    const { handler, ...definition } = tool;
+    return definition;
+}
+function createMcpServer(options = {}) {
+    const toolbox = options.toolbox || new Toolbox(options);
+    async function handle(request) {
+        if (request.method === 'initialize') {
+            return {
+                protocolVersion: request.params?.protocolVersion || '2024-11-05',
+                capabilities: { tools: { listChanged: true } },
+                serverInfo: { name: 'amalgm-tools', version: '0.1.0' },
+            };
+        }
+        if (request.method === 'ping')
+            return {};
+        const tools = createMcpTools(toolbox);
+        if (request.method === 'tools/list')
+            return { tools: tools.map(descriptor) };
+        if (request.method === 'tools/call') {
+            try {
+                return await callMcpTool(toolbox, String(request.params?.name || ''), request.params?.arguments || {});
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.startsWith('Unknown tool:')) {
+                    Object.assign(error, { code: -32602 });
+                }
+                throw error;
+            }
+        }
+        if (request.method.startsWith('notifications/'))
+            return undefined;
+        throw Object.assign(new Error(`Method not found: ${request.method}`), { code: -32601 });
+    }
+    function start(input = process.stdin, output = process.stdout) {
+        const lines = readline.createInterface({ input, crlfDelay: Infinity });
+        lines.on('line', async (line) => {
+            let request;
+            try {
+                request = JSON.parse(line);
+                const result = await handle(request);
+                if (request.id !== undefined && result !== undefined)
+                    output.write(`${JSON.stringify({ jsonrpc: '2.0', id: request.id, result })}\n`);
+            }
+            catch (error) {
+                if (request?.id === undefined)
+                    return;
+                output.write(`${JSON.stringify({
+                    jsonrpc: '2.0', id: request.id,
+                    error: { code: error?.code || -32603, message: error instanceof Error ? error.message : String(error) },
+                })}\n`);
+            }
+        });
+        return lines;
+    }
+    return { toolbox, handle, start };
+}
+export { createMcpServer };

package/dist/mcp.d.ts

@@ -0,0 +1,9 @@
+import type { Toolbox } from './toolbox.js';
+import type { JsonSchema, McpOptions, McpTool } from './types.js';
+declare function portable(schema: JsonSchema): JsonSchema;
+declare function managementTools(toolbox: Toolbox): McpTool[];
+declare function actionTools(toolbox: Toolbox, options?: McpOptions): McpTool[];
+declare function createMcpTools(toolbox: Toolbox, options?: McpOptions): McpTool[];
+declare function findMcpTool(toolbox: Toolbox, name: string, options?: McpOptions): McpTool | null;
+declare function callMcpTool(toolbox: Toolbox, name: string, input?: Record<string, unknown>, options?: McpOptions): Promise<import("./types.js").ToolResult>;
+export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, portable, };

package/dist/mcp.js

@@ -0,0 +1,95 @@
+import { mcpName } from './ids.js';
+import { errorResult, structuredResult } from './results.js';
+function portable(schema) {
+    const result = structuredClone(schema);
+    for (const key of ['anyOf', 'oneOf', 'allOf', 'not', 'enum'])
+        delete result[key];
+    result.type = 'object';
+    result.properties ||= {};
+    return result;
+}
+function managed(definition, handler) {
+    return {
+        ...definition,
+        async handler(input = {}) {
+            try {
+                return structuredResult(await handler(input));
+            }
+            catch (error) {
+                return errorResult(error);
+            }
+        },
+    };
+}
+function managementTools(toolbox) {
+    const idProperty = { id: { type: 'string', description: 'Tool or action id' } };
+    return [
+        managed({
+            name: 'toolbox_tools_list', description: 'List the canonical Toolbox catalog.',
+            inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        }, () => toolbox.catalog()),
+        managed({
+            name: 'toolbox_tool_get', description: 'Get one tool and its actions.',
+            inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
+        }, ({ id }) => {
+            const result = toolbox.get(String(id));
+            if (!result)
+                throw new Error(`Unknown tool: ${id}`);
+            return result;
+        }),
+        managed({
+            name: 'toolbox_tool_apply', description: 'Atomically apply an authoritative tool definition.',
+            inputSchema: {
+                type: 'object', required: ['tool'], additionalProperties: false,
+                properties: { tool: { type: 'object', description: 'Complete tool definition' } },
+            },
+        }, ({ tool }) => toolbox.apply(tool)),
+        managed({
+            name: 'toolbox_record_enable', description: 'Enable one user-owned tool or action.',
+            inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
+        }, ({ id }) => toolbox.setStatus(String(id), 'enabled')),
+        managed({
+            name: 'toolbox_record_disable', description: 'Disable one user-owned tool or action.',
+            inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
+        }, ({ id }) => toolbox.setStatus(String(id), 'disabled')),
+        managed({
+            name: 'toolbox_record_remove', description: 'Remove one user-owned tool or action.',
+            inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
+        }, ({ id }) => toolbox.remove(String(id))),
+        managed({
+            name: 'toolbox_mcp_connections', description: 'List external MCP connections for the composing host.',
+            inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        }, () => toolbox.connections()),
+    ];
+}
+function actionTools(toolbox, options = {}) {
+    return toolbox.callable(options.loadout).map(({ tool, action }) => ({
+        name: mcpName(action),
+        description: action.description || `Run ${tool.name}: ${action.displayName || action.name}.`,
+        inputSchema: portable(action.inputSchema),
+        async handler(input = {}) {
+            try {
+                return await toolbox.call(action.id, input, options);
+            }
+            catch (error) {
+                return errorResult(error);
+            }
+        },
+    }));
+}
+function createMcpTools(toolbox, options = {}) {
+    return [
+        ...(options.includeManagement === false ? [] : managementTools(toolbox)),
+        ...actionTools(toolbox, options),
+    ];
+}
+function findMcpTool(toolbox, name, options = {}) {
+    return createMcpTools(toolbox, options).find((tool) => tool.name === name) || null;
+}
+async function callMcpTool(toolbox, name, input = {}, options = {}) {
+    const tool = findMcpTool(toolbox, name, options);
+    if (!tool)
+        throw new Error(`Unknown tool: ${name}`);
+    return tool.handler(input);
+}
+export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, portable, };

package/dist/module.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from './types.js';
+declare function loadDefinitions(file: string): Promise<ToolDefinition[]>;
+export { loadDefinitions };

package/dist/module.js

@@ -0,0 +1,22 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+async function loadDefinitions(file) {
+    const absolute = path.resolve(file);
+    if (!fs.existsSync(absolute))
+        throw new Error(`Definition file not found: ${absolute}`);
+    let value;
+    if (path.extname(absolute).toLowerCase() === '.json') {
+        value = JSON.parse(fs.readFileSync(absolute, 'utf8'));
+    }
+    else {
+        const loaded = await import(`${pathToFileURL(absolute).href}?updated=${fs.statSync(absolute).mtimeMs}`);
+        value = loaded.default ?? loaded.tools ?? loaded.tool;
+    }
+    const definitions = Array.isArray(value) ? value : [value];
+    if (!definitions.length || definitions.some((definition) => !definition || typeof definition !== 'object')) {
+        throw new Error('Definition module must export one tool or an array of tools');
+    }
+    return definitions;
+}
+export { loadDefinitions };

package/dist/process.d.ts

@@ -0,0 +1,22 @@
+interface CommandInput {
+    command: string;
+    args: string[];
+    cwd?: string;
+    env: NodeJS.ProcessEnv;
+    stdin?: string;
+    timeoutMs: number;
+    maximumBytes: number;
+    signal?: AbortSignal;
+}
+interface CommandOutput {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    aborted: boolean;
+    truncated: boolean;
+}
+declare function runCommand(input: CommandInput): Promise<CommandOutput>;
+export { runCommand };
+export type { CommandInput, CommandOutput };