@amalgm/tools 0.1.7-preview.34545371724 → 0.1.7-preview.34547452288

package/dist/cli.d.ts

@@ -7,7 +7,12 @@ interface Parsed {
     loadout?: LoadoutInput;
     input: Record<string, unknown>;
 }
+/** One call on the command surface: an MCP tool name and its arguments. */
+interface Call {
+    name: string;
+    args: Record<string, unknown>;
+}
 declare function parse(argv: string[]): Parsed;
 declare function runCli(argv: string[], io?: CliIo): Promise<number>;
 export { HELP, parse, runCli };
-export type { Parsed };
+export type { Call, Parsed };

package/dist/cli.js

@@ -1,3 +1,5 @@
+import { createToolboxCommands } from './commands.js';
+import { id, mcpName } from './ids.js';
 import { loadDefinitions } from './module.js';
 import { Toolbox } from './toolbox.js';
 const HELP = `Usage: amalgm-tools [--state-dir DIR] [--loadout IDS] <command>
@@ -50,9 +52,44 @@ function required(value, label) {
         throw new Error(`${label} is required`);
     return value;
 }
+/** Map one parsed command line to its calls; `apply` makes one call per definition. */
+async function calls(parsed) {
+    const [first, second] = parsed.args;
+    const record = (name, label) => ({ name, args: { id: required(first, label) } });
+    switch (parsed.command) {
+        case 'apply': {
+            const definitions = await loadDefinitions(required(first, 'definition file'));
+            return definitions.map((tool) => ({ name: 'toolbox_tool_apply', args: { tool } }));
+        }
+        case 'list': return [{ name: 'toolbox_tools_selected', args: {} }];
+        case 'catalog': return [{ name: 'toolbox_tools_list', args: {} }];
+        case 'show': return [record('toolbox_tool_get', 'tool or action id')];
+        case 'enable': return [record('toolbox_record_enable', 'record id')];
+        case 'disable': return [record('toolbox_record_disable', 'record id')];
+        case 'remove': return [record('toolbox_record_remove', 'record id')];
+        case 'link': return [{
+                name: 'toolbox_tool_link',
+                args: { id: required(first, 'tool id'), app_id: required(second, 'app id') },
+            }];
+        case 'unlink': return [record('toolbox_tool_unlink', 'tool id')];
+        case 'run': return [{ name: mcpName({ id: id(first, 'action id') }), args: parsed.input }];
+        case 'connections': return [{ name: 'toolbox_mcp_connections', args: {} }];
+        default: throw new Error(`Unknown command: ${parsed.command}`);
+    }
+}
+function open(io, parsed) {
+    if (io.commands)
+        return { commands: io.commands, close() { } };
+    const toolbox = new Toolbox({ stateDir: parsed.stateDir });
+    return { commands: createToolboxCommands(toolbox, parsed.loadout), close: () => toolbox.close() };
+}
 function write(output, value) {
     output.write(`${JSON.stringify(value, null, 2)}\n`);
 }
+function fail(output, error) {
+    output.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+}
 async function runCli(argv, io = {}) {
     const stdout = io.stdout || process.stdout;
     const stderr = io.stderr || process.stderr;
@@ -61,71 +98,28 @@ async function runCli(argv, io = {}) {
         parsed = parse(argv);
     }
     catch (error) {
-        stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return 1;
+        return fail(stderr, error);
     }
     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 'link':
-                write(stdout, await toolbox.link(required(recordId, 'tool id'), required(parsed.args[1], 'app id')));
-                break;
-            case 'unlink':
-                write(stdout, await toolbox.link(required(recordId, 'tool id'), null));
-                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}`);
+        const planned = await calls(parsed);
+        const session = open(io, parsed);
+        try {
+            const results = [];
+            for (const call of planned)
+                results.push(await session.commands.execute(call.name, call.args));
+            write(stdout, results.length === 1 ? results[0] : results);
+        }
+        finally {
+            session.close();
         }
         return 0;
     }
     catch (error) {
-        stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return 1;
-    }
-    finally {
-        if (!io.toolbox)
-            toolbox.close();
+        return fail(stderr, error);
     }
 }
 export { HELP, parse, runCli };

package/dist/commands.d.ts

@@ -0,0 +1,27 @@
+import type { Toolbox } from './toolbox.js';
+import type { LoadoutInput } from './types.js';
+/**
+ * The one command surface. The CLI speaks only this; a host forwards it to a
+ * running runtime's MCP over HTTP, and `createToolboxCommands` runs it against
+ * a local Toolbox through that Toolbox's own MCP tools.
+ *
+ * `name` is an MCP tool name from this package's MCP surface: a management
+ * tool (`toolbox_*`, single underscore) or an action tool (`toolbox__<id>`,
+ * from `mcpName`). `args` is the MCP `arguments` object for that tool.
+ *
+ * `execute` resolves to the tool's value, unwrapped from the MCP call result:
+ * - any result with `isError: true` rejects with an Error whose message is
+ *   the result's text content (every `content[].text`, joined by newlines);
+ * - a management tool's value is `result.structuredContent` (its text
+ *   content is the same value as JSON and is never consulted);
+ * - an action tool's value is the whole MCP result (`content`,
+ *   `structuredContent`, `truncated`) exactly as the driver returned it.
+ * A remote implementation sends `name`/`args` as an MCP `tools/call` and
+ * applies these three rules to the response.
+ */
+interface ToolCommands {
+    execute(name: string, args: Record<string, unknown>): Promise<unknown>;
+}
+declare function createToolboxCommands(toolbox: Toolbox, loadout?: LoadoutInput): ToolCommands;
+export { createToolboxCommands };
+export type { ToolCommands };

package/dist/commands.js

@@ -0,0 +1,15 @@
+import { isActionMcpName } from './ids.js';
+import { callMcpTool } from './mcp.js';
+function unwrap(name, result) {
+    if (result.isError)
+        throw new Error(result.content.map((item) => item.text).join('\n'));
+    return isActionMcpName(name) ? result : result.structuredContent;
+}
+function createToolboxCommands(toolbox, loadout) {
+    return {
+        async execute(name, args) {
+            return unwrap(name, await callMcpTool(toolbox, name, args, { loadout }));
+        },
+    };
+}
+export { createToolboxCommands };

package/dist/ids.d.ts

@@ -3,5 +3,7 @@ declare function id(value: unknown, label?: string, maximumLength?: number): str
 declare function actionName(value: unknown): string;
 declare function actionId(toolId: string, name: string): string;
 declare function mcpName(action: Pick<ActionRecord, 'id'>): string;
+/** Action tools carry the double-underscore prefix; management tools never do. */
+declare function isActionMcpName(name: string): boolean;
 declare function assertMcpNamesUnique(actions: Pick<ActionRecord, 'id'>[]): void;
-export { actionId, actionName, assertMcpNamesUnique, id, mcpName };
+export { actionId, actionName, assertMcpNamesUnique, id, isActionMcpName, mcpName };

package/dist/ids.js

@@ -21,8 +21,13 @@ function actionId(toolId, name) {
 function safeMcpName(value) {
     return value.replace(/[^A-Za-z0-9_-]+/g, '_').replace(/_+/g, '_');
 }
+const MCP_ACTION_PREFIX = 'toolbox__';
 function mcpName(action) {
-    return `toolbox__${safeMcpName(action.id)}`;
+    return `${MCP_ACTION_PREFIX}${safeMcpName(action.id)}`;
+}
+/** Action tools carry the double-underscore prefix; management tools never do. */
+function isActionMcpName(name) {
+    return name.startsWith(MCP_ACTION_PREFIX);
 }
 function assertMcpNamesUnique(actions) {
     const names = new Map();
@@ -35,4 +40,4 @@ function assertMcpNamesUnique(actions) {
         names.set(name, action.id);
     }
 }
-export { actionId, actionName, assertMcpNamesUnique, id, mcpName };
+export { actionId, actionName, assertMcpNamesUnique, id, isActionMcpName, mcpName };

package/dist/index.d.ts

@@ -1,6 +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 { runCli } from './cli.js';
+export { createToolboxCommands } from './commands.js';
+export type { ToolCommands } from './commands.js';
 export { defineTool, normalizeDefinition } from './definition.js';
 export { defineHostMcpTool } from './host-mcp-tool.js';
 export { TOOL_DEPLOYMENT_CONTRACT, TOOL_DEPLOYMENT_KIND, TOOL_DEPLOYMENT_SCHEMA_VERSION, assertToolDeploymentActivation, createToolDeployment, deploymentRevisionId, emptyToolDeploymentSnapshot, } from './deployments.js';

package/dist/index.js

@@ -1,5 +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 { runCli } from './cli.js';
+export { createToolboxCommands } from './commands.js';
 export { defineTool, normalizeDefinition } from './definition.js';
 export { defineHostMcpTool } from './host-mcp-tool.js';
 export { TOOL_DEPLOYMENT_CONTRACT, TOOL_DEPLOYMENT_KIND, TOOL_DEPLOYMENT_SCHEMA_VERSION, assertToolDeploymentActivation, createToolDeployment, deploymentRevisionId, emptyToolDeploymentSnapshot, } from './deployments.js';

package/dist/mcp.d.ts

@@ -2,7 +2,7 @@ import type { Toolbox } from './toolbox.js';
 import type { JsonSchema, McpOptions, McpTool } from './types.js';
 declare function portable(schema: JsonSchema): JsonSchema;
 declare function managementToolDescriptors(): Array<Omit<McpTool, 'handler'>>;
-declare function managementTools(toolbox: Toolbox): McpTool[];
+declare function managementTools(toolbox: Toolbox, options?: McpOptions): 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;

package/dist/mcp.js

@@ -29,7 +29,12 @@ function managementToolDescriptors() {
             inputSchema: { type: 'object', properties: {}, additionalProperties: false },
         },
         {
-            name: 'toolbox_tool_get', description: 'Get one tool and its actions.',
+            name: 'toolbox_tools_selected',
+            description: 'List tools with their selected actions: the loadout, or every enabled action.',
+            inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        },
+        {
+            name: 'toolbox_tool_get', description: 'Get one tool and its actions, or one action.',
             inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
         },
         {
@@ -68,14 +73,15 @@ function managementToolDescriptors() {
         },
     ];
 }
-function managementTools(toolbox) {
-    const [list, get, apply, enable, disable, remove, link, unlink, connections] = managementToolDescriptors();
+function managementTools(toolbox, options = {}) {
+    const [list, selected, get, apply, enable, disable, remove, link, unlink, connections,] = managementToolDescriptors();
     return [
         managed(list, () => toolbox.catalog()),
+        managed(selected, () => toolbox.list(options.loadout)),
         managed(get, ({ id }) => {
-            const result = toolbox.get(String(id));
+            const result = toolbox.get(String(id)) || toolbox.action(String(id));
             if (!result)
-                throw new Error(`Unknown tool: ${id}`);
+                throw new Error(`Unknown tool or action: ${id}`);
             return result;
         }),
         managed(apply, ({ tool }) => toolbox.apply(tool)),
@@ -84,7 +90,7 @@ function managementTools(toolbox) {
         managed(remove, ({ id }) => toolbox.remove(String(id))),
         managed(link, ({ id, app_id }) => toolbox.link(String(id), String(app_id))),
         managed(unlink, ({ id }) => toolbox.link(String(id), null)),
-        managed(connections, () => toolbox.connections()),
+        managed(connections, () => toolbox.connections(options.loadout)),
     ];
 }
 function actionTools(toolbox, options = {}) {
@@ -104,7 +110,7 @@ function actionTools(toolbox, options = {}) {
 }
 function createMcpTools(toolbox, options = {}) {
     return [
-        ...(options.includeManagement === false ? [] : managementTools(toolbox)),
+        ...(options.includeManagement === false ? [] : managementTools(toolbox, options)),
         ...actionTools(toolbox, options),
     ];
 }

package/dist/types.d.ts

@@ -183,7 +183,7 @@ interface McpOptions extends CallOptions {
 interface CliIo {
     stdout?: Writable;
     stderr?: Writable;
-    toolbox?: import('./toolbox.js').Toolbox;
+    commands?: import('./commands.js').ToolCommands;
 }
 export type { ActionDefinition, ActionRecord, ActionTarget, ApiSource, ApiTarget, ApplyResult, CallOptions, Catalog, CliIo, CliSource, CliTarget, DriverCall, JsonSchema, Loadout, LoadoutInput, McpOptions, McpSource, McpTarget, McpTool, Origin, SecretResolver, Status, ToolDefinition, ToolDriver, ToolboxOptions, ToolRecord, ToolResult, ToolPatch, ActionPatch, ToolQuery, ToolSource, ToolType, };
 export type { ToolDeployment, ToolDeploymentActivation, ToolDeploymentSnapshot, ToolDeploymentSurface, } from './deployment-types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amalgm/tools",
-  "version": "0.1.7-preview.34545371724",
+  "version": "0.1.7-preview.34547452288",
   "description": "Local-first tool definitions, Toolbox registry, and agent execution surfaces.",
   "license": "UNLICENSED",
   "private": false,
@@ -87,11 +87,11 @@
       "package.json"
     ]
   },
-  "gitHead": "53f469e2ce16c667c6883239cc3f98c0af6943fc",
+  "gitHead": "483f1a4def4b39cf8da719182291cf8df3076224",
   "amalgmSource": {
     "repository": "amalgm-inc/amalgm-tools",
     "branch": "preview",
-    "commit": "53f469e2ce16c667c6883239cc3f98c0af6943fc",
-    "occurrence": "34545371724"
+    "commit": "483f1a4def4b39cf8da719182291cf8df3076224",
+    "occurrence": "34547452288"
   }
 }