toolcraft 0.0.40 → 0.0.42

package/dist/cli.js

@@ -402,10 +402,13 @@ function parseEnumValue(value, values, label) {
     return match;
 }
 function validateStringPattern(value, schema, label) {
-    if (schema.pattern === undefined) {
-        return value;
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+        throw new UserError(`Invalid value for "${label}". Expected a string with length at least ${schema.minLength}, got string with length ${value.length}.`);
+    }
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        throw new UserError(`Invalid value for "${label}". Expected a string with length at most ${schema.maxLength}, got string with length ${value.length}.`);
     }
-    if (!matchesStringPattern(value, schema.pattern)) {
+    if (schema.pattern !== undefined && !matchesStringPattern(value, schema.pattern)) {
         throw new UserError(`Invalid value for "${label}": "${value}" does not match pattern "${schema.pattern}".`);
     }
     return value;
@@ -585,6 +588,14 @@ function parseArrayValue(value, schema, label) {
     }
     return splitArrayInput(value).map((item) => parseScalarValue(item, itemSchema, label));
 }
+function validateArrayBounds(value, schema, label) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+        throw new UserError(`Invalid value for "${label}". Expected an array with at least ${schema.minItems} items, got array(${value.length}).`);
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        throw new UserError(`Invalid value for "${label}". Expected an array with at most ${schema.maxItems} items, got array(${value.length}).`);
+    }
+}
 function createOption(field, globalLongOptionFlags) {
     const flags = formatOptionFlags(field, globalLongOptionFlags);
     const collidesWithGlobalFlag = globalLongOptionFlags.has(field.optionFlag);
@@ -979,7 +990,11 @@ function formatExampleCommand(breadcrumb, rootUsageName, params) {
     const commandPath = buildUsageLine(breadcrumb, rootUsageName, "");
     const flags = Object.entries(params).map(([key, value]) => {
         const flag = `--${key}`;
-        return typeof value === "boolean" ? (value ? flag : `--no-${key}`) : `${flag} ${formatExampleValue(value)}`;
+        return typeof value === "boolean"
+            ? value
+                ? flag
+                : `--no-${key}`
+            : `${flag} ${formatExampleValue(value)}`;
     });
     return [commandPath, ...flags].filter((token) => token.length > 0).join(" ");
 }
@@ -1493,6 +1508,9 @@ function describeExpectedPresetValue(schema) {
     if (schema.kind === "array") {
         return "an array";
     }
+    if (schema.kind === "number") {
+        return getExpectedNumberDescription(schema);
+    }
     if (schema.kind === "json") {
         return "valid JSON";
     }
@@ -1510,6 +1528,12 @@ function validatePresetScalarValue(value, schema, fieldPath, presetPath) {
             if (typeof value !== "string") {
                 break;
             }
+            if (schema.minLength !== undefined && value.length < schema.minLength) {
+                throw new UserError(`Preset file "${presetPath}" has an invalid value for "${fieldPath}". Expected a string with length at least ${schema.minLength}, got string with length ${value.length}.`);
+            }
+            if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+                throw new UserError(`Preset file "${presetPath}" has an invalid value for "${fieldPath}". Expected a string with length at most ${schema.maxLength}, got string with length ${value.length}.`);
+            }
             if (schema.pattern !== undefined && !matchesStringPattern(value, schema.pattern)) {
                 throw new UserError(`Preset file "${presetPath}" has an invalid value for "${fieldPath}": "${value}" does not match pattern "${schema.pattern}".`);
             }
@@ -1548,6 +1572,12 @@ function validatePresetFieldValue(value, field, presetPath) {
     if (!Array.isArray(value)) {
         throw new UserError(`Preset file "${presetPath}" has an invalid value for "${field.displayPath}". Expected an array, got ${describeReceived(value)}.`);
     }
+    if (field.schema.minItems !== undefined && value.length < field.schema.minItems) {
+        throw new UserError(`Preset file "${presetPath}" has an invalid value for "${field.displayPath}". Expected an array with at least ${field.schema.minItems} items, got array(${value.length}).`);
+    }
+    if (field.schema.maxItems !== undefined && value.length > field.schema.maxItems) {
+        throw new UserError(`Preset file "${presetPath}" has an invalid value for "${field.displayPath}". Expected an array with at most ${field.schema.maxItems} items, got array(${value.length}).`);
+    }
     return value.map((item) => validatePresetScalarValue(item, itemSchema, field.displayPath, presetPath));
 }
 async function loadPresetValues(fields, presetPath) {
@@ -1959,12 +1989,17 @@ function parseOptionFieldValue(field, value, errors) {
                 }
                 parsedValues.push(...parsed);
             }
+            validateArrayBounds(parsedValues, field.schema, field.displayPath);
             return { ok: true, value: parsedValues };
         }
         if (typeof value !== "string") {
             return { ok: true, value };
         }
-        return { ok: true, value: parseFieldInputValue(value, field.schema, field.displayPath) };
+        const parsedValue = parseFieldInputValue(value, field.schema, field.displayPath);
+        if (field.schema.kind === "array" && Array.isArray(parsedValue)) {
+            validateArrayBounds(parsedValue, field.schema, field.displayPath);
+        }
+        return { ok: true, value: parsedValue };
     }
     catch (error) {
         if (error instanceof UserError || error instanceof InvalidArgumentError) {
@@ -2026,6 +2061,7 @@ function consumeFieldValue(args, index, schema, label, inlineValue) {
         if (values.length === 0) {
             throw new InvalidArgumentError(`option '${label}' argument missing`);
         }
+        validateArrayBounds(values, schema, label);
         return {
             nextIndex,
             value: values

package/dist/mcp.js

@@ -360,6 +360,9 @@ function validateSchemaValue(schema, value, casing, label, errors) {
                     message: `Invalid value for "${label}". Expected a string, got ${describeReceived(value)}.`
                 });
             }
+            else {
+                validateStringConstraints(unwrappedSchema, value, label, errors);
+            }
             return value;
         case "number":
             if (!isValidNumberSchemaValue(value, unwrappedSchema)) {
@@ -390,6 +393,7 @@ function validateSchemaValue(schema, value, casing, label, errors) {
                 });
                 return value;
             }
+            validateArrayConstraints(unwrappedSchema, value, label, errors);
             return value.map((item, index) => validateSchemaValue(unwrappedSchema.item, item, casing, `${label}[${index}]`, errors));
         case "object":
             return validateObjectSchema(unwrappedSchema, value, casing, label, errors);
@@ -437,6 +441,40 @@ function validateSchemaValue(schema, value, casing, label, errors) {
         }
     }
 }
+function validateStringConstraints(schema, value, label, errors) {
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected a string with length at least ${schema.minLength}, got string with length ${value.length}.`
+        });
+    }
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected a string with length at most ${schema.maxLength}, got string with length ${value.length}.`
+        });
+    }
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}": "${value}" does not match pattern "${schema.pattern}".`
+        });
+    }
+}
+function validateArrayConstraints(schema, value, label, errors) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an array with at least ${schema.minItems} items, got array(${value.length}).`
+        });
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an array with at most ${schema.maxItems} items, got array(${value.length}).`
+        });
+    }
+}
 function validateObjectSchema(schema, value, casing, label, errors) {
     if (!isPlainObject(value)) {
         errors.push({
@@ -545,7 +583,9 @@ function serializeResultValue(schema, value, casing, label, errors) {
             if (branch === undefined) {
                 const branchNames = Object.keys(unwrappedSchema.branches);
                 errors.push({
-                    path: label.length === 0 ? unwrappedSchema.discriminator : `${label}.${unwrappedSchema.discriminator}`,
+                    path: label.length === 0
+                        ? unwrappedSchema.discriminator
+                        : `${label}.${unwrappedSchema.discriminator}`,
                     message: `Invalid value for "${label.length === 0 ? unwrappedSchema.discriminator : `${label}.${unwrappedSchema.discriminator}`}". Expected one of: ${branchNames.join(", ")}, got ${describeReceived(discriminator)}.`
                 });
                 return value;
@@ -654,9 +694,7 @@ function throwResultValidationErrors(errors) {
     if (errors.length === 1) {
         throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, errors[0]?.message ?? "Invalid command result.");
     }
-    const rendered = errors
-        .slice(0, 10)
-        .map((error) => `  - ${error.path}: ${error.message}`);
+    const rendered = errors.slice(0, 10).map((error) => `  - ${error.path}: ${error.message}`);
     const remaining = errors.length - rendered.length;
     if (remaining > 0) {
         rendered.push(`  ... and ${remaining} more`);

package/dist/number-schema.js

@@ -1,8 +1,15 @@
 export function isValidNumberSchemaValue(value, schema) {
     return (typeof value === "number" &&
         Number.isFinite(value) &&
-        (schema.jsonType !== "integer" || Number.isInteger(value)));
+        (schema.jsonType !== "integer" || Number.isInteger(value)) &&
+        (schema.minimum === undefined || value >= schema.minimum) &&
+        (schema.maximum === undefined || value <= schema.maximum));
 }
 export function getExpectedNumberDescription(schema) {
-    return schema.jsonType === "integer" ? "an integer" : "a number";
+    const type = schema.jsonType === "integer" ? "an integer" : "a number";
+    const bounds = [
+        schema.minimum === undefined ? undefined : `greater than or equal to ${schema.minimum}`,
+        schema.maximum === undefined ? undefined : `less than or equal to ${schema.maximum}`
+    ].filter((bound) => bound !== undefined);
+    return bounds.length === 0 ? type : `${type} ${bounds.join(" and ")}`;
 }

package/dist/sdk.js

@@ -146,6 +146,9 @@ function validateSchemaValue(schema, value, label, errors) {
                     message: `Invalid value for "${label}". Expected a string, got ${describeReceived(value)}.`
                 });
             }
+            else {
+                validateStringConstraints(unwrappedSchema, value, label, errors);
+            }
             return value;
         case "number":
             if (!isValidNumberSchemaValue(value, unwrappedSchema)) {
@@ -176,6 +179,7 @@ function validateSchemaValue(schema, value, label, errors) {
                 });
                 return value;
             }
+            validateArrayConstraints(unwrappedSchema, value, label, errors);
             return value.map((item, index) => validateSchemaValue(unwrappedSchema.item, item, `${label}[${index}]`, errors));
         case "object":
             return validateObjectSchema(unwrappedSchema, value, label, errors);
@@ -220,6 +224,40 @@ function validateSchemaValue(schema, value, label, errors) {
         }
     }
 }
+function validateStringConstraints(schema, value, label, errors) {
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected a string with length at least ${schema.minLength}, got string with length ${value.length}.`
+        });
+    }
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected a string with length at most ${schema.maxLength}, got string with length ${value.length}.`
+        });
+    }
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}": "${value}" does not match pattern "${schema.pattern}".`
+        });
+    }
+}
+function validateArrayConstraints(schema, value, label, errors) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an array with at least ${schema.minItems} items, got array(${value.length}).`
+        });
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an array with at most ${schema.maxItems} items, got array(${value.length}).`
+        });
+    }
+}
 function validateObjectSchema(schema, value, label, errors) {
     if (!isPlainObject(value)) {
         errors.push({

package/node_modules/@poe-code/agent-defs/dist/agents/claude-code.js

@@ -11,7 +11,7 @@ export const claudeCodeAgent = {
             CLAUDE_CODE_ENABLE_TELEMETRY: "1"
         }
     },
-    configPath: "~/.claude/settings.json",
+    configPath: "~/.claude.json",
     branding: {
         colors: {
             dark: "#C15F3C",

package/node_modules/@poe-code/agent-defs/dist/agents/claude-desktop.js

@@ -3,7 +3,12 @@ export const claudeDesktopAgent = {
     name: "claude-desktop",
     label: "Claude Desktop",
     summary: "Anthropic's official desktop application for Claude",
-    configPath: "~/.claude/settings.json",
+    configPath: "~/.config/Claude/claude_desktop_config.json",
+    configPaths: {
+        darwin: "~/Library/Application Support/Claude/claude_desktop_config.json",
+        linux: "~/.config/Claude/claude_desktop_config.json",
+        win32: "~/AppData/Roaming/Claude/claude_desktop_config.json"
+    },
     branding: {
         colors: {
             dark: "#D97757",

package/node_modules/@poe-code/agent-defs/dist/agents/cursor.js

@@ -5,7 +5,7 @@ export const cursorAgent = {
     label: "Cursor",
     summary: "Cursor's CLI coding agent.",
     binaryName: "cursor-agent",
-    configPath: "~/.cursor/cli-config.json",
+    configPath: "~/.cursor/mcp.json",
     branding: {
         colors: {
             dark: "#FFFFFF",

package/node_modules/@poe-code/agent-defs/dist/agents/kimi.js

@@ -6,7 +6,7 @@ export const kimiAgent = {
     aliases: ["kimi-cli"],
     binaryName: "kimi",
     apiShapes: ["openai-chat-completions"],
-    configPath: "~/.kimi/config.toml",
+    configPath: "~/.kimi/mcp.json",
     branding: {
         colors: {
             dark: "#7B68EE",

package/node_modules/@poe-code/agent-defs/dist/agents/opencode.js

@@ -10,7 +10,7 @@ export const openCodeAgent = {
             OPENCODE_CONFIG_CONTENT: '{"experimental":{"openTelemetry":true}}'
         }
     },
-    configPath: "~/.config/opencode/config.json",
+    configPath: "~/.config/opencode/opencode.json",
     branding: {
         colors: {
             dark: "#4A4F55",

package/node_modules/@poe-code/agent-defs/dist/specifier.js

@@ -2,24 +2,33 @@ import { resolveAgentId } from "./registry.js";
 function getOwnModel(specifier) {
     return Object.prototype.hasOwnProperty.call(specifier, "model") ? specifier.model : undefined;
 }
+function requireNonBlank(value, field) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new TypeError(`${field} must not be empty`);
+    }
+    return trimmed;
+}
 export function parseAgentSpecifier(input) {
     const colonIndex = input.indexOf(":");
     if (colonIndex === -1) {
-        return { agent: input.trim() };
+        return { agent: requireNonBlank(input, "agent") };
     }
-    const agent = input.slice(0, colonIndex).trim();
+    const agent = requireNonBlank(input.slice(0, colonIndex), "agent");
     const model = input.slice(colonIndex + 1).trim();
     return {
         agent,
-        ...(model.length > 0 ? { model } : {}),
+        ...(model.length > 0 ? { model } : {})
     };
 }
 export function formatAgentSpecifier(specifier) {
+    const agent = requireNonBlank(specifier.agent, "agent");
     const model = getOwnModel(specifier);
-    if (model) {
-        return `${specifier.agent}:${model}`;
+    const normalizedModel = model?.trim();
+    if (normalizedModel) {
+        return `${agent}:${normalizedModel}`;
     }
-    return specifier.agent;
+    return agent;
 }
 export function normalizeAgentId(input) {
     const specifier = parseAgentSpecifier(input.trim());

package/node_modules/@poe-code/agent-defs/dist/types.d.ts

@@ -14,6 +14,11 @@ export interface AgentDefinition {
     readonly apiShapes?: readonly ApiShapeId[];
     readonly otelCapture?: OtelCaptureDefinition;
     configPath: string;
+    readonly configPaths?: {
+        readonly darwin: string;
+        readonly linux: string;
+        readonly win32: string;
+    };
     branding: {
         colors: {
             dark: string;

package/node_modules/@poe-code/agent-mcp-config/dist/apply.js

@@ -15,6 +15,32 @@ export class UnsupportedAgentError extends Error {
 function isConfigObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function assertNonEmptyString(value, message) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(message);
+    }
+}
+function assertHttpUrl(value) {
+    assertNonEmptyString(value, "MCP HTTP URL must be a valid http or https URL.");
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error("MCP HTTP URL must be a valid http or https URL.");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("MCP HTTP URL must be a valid http or https URL.");
+    }
+}
+function validateServerEntry(server) {
+    assertNonEmptyString(server.name, "MCP server name must be a non-empty string.");
+    if (server.config.transport === "stdio") {
+        assertNonEmptyString(server.config.command, "MCP stdio command must be a non-empty string.");
+        return;
+    }
+    assertHttpUrl(server.config.url);
+}
 function resolveServerMap(document, configKey) {
     const value = document[configKey];
     if (value === undefined) {
@@ -32,12 +58,15 @@ export async function configure(agentId, server, options) {
     if (!isSupported(agentId)) {
         throw new UnsupportedAgentError(agentId);
     }
+    validateServerEntry(server);
     const config = getAgentConfig(agentId);
     const configPath = resolveConfigPath(config, options.platform);
     const shapeTransformer = getShapeTransformer(config.shape);
     const shaped = shapeTransformer(server);
+    const enabledServer = { ...server, enabled: true };
+    const enabledShaped = shapeTransformer(enabledServer);
     if (shaped === undefined) {
-        await unconfigure(agentId, server.name, options);
+        await unconfigure(agentId, enabledServer, options);
         return;
     }
     const configDir = getConfigDirectory(configPath);
@@ -57,10 +86,13 @@ export async function configure(agentId, server, options) {
                     ? servers[server.name]
                     : undefined;
                 const shapedServer = shaped;
+                const enabledShapedServer = enabledShaped;
                 if (existingServer !== undefined && isDeepStrictEqual(existingServer, shapedServer)) {
                     return { changed: false, content: document };
                 }
-                if (existingServer !== undefined && server.enabled !== false) {
+                if (existingServer !== undefined &&
+                    (enabledShapedServer === undefined ||
+                        !isDeepStrictEqual(existingServer, enabledShapedServer))) {
                     throw new Error(`MCP server "${server.name}" already exists with different configuration in ${configPath}.`);
                 }
                 const newServers = {
@@ -98,7 +130,8 @@ export async function unconfigure(agentId, server, options) {
                 if (!Object.hasOwn(servers, serverName)) {
                     return { changed: false, content: document };
                 }
-                if (expectedServer !== undefined && !isDeepStrictEqual(servers[serverName], expectedServer)) {
+                if (expectedServer !== undefined &&
+                    !isDeepStrictEqual(servers[serverName], expectedServer)) {
                     return { changed: false, content: document };
                 }
                 const newServers = { ...servers };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,7 +47,7 @@
     "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client mcp-oauth auth-store"
   },
   "dependencies": {
-    "toolcraft-schema": "0.0.40",
+    "toolcraft-schema": "0.0.42",
     "commander": "^14.0.3",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",