unicommand 0.0.4 → 0.1.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/command/runtime-metadata.ts
 var commandMetadata = /* @__PURE__ */ new WeakMap();
@@ -1087,14 +1087,16 @@ var createCommandCliRunner = ({
 };
 
 // src/mcp/router.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/mcp/constants.ts
 var DEFAULT_MCP_SERVER_VERSION = "0.0.0";
 var DEFAULT_RESOURCE_MIME_TYPE = "application/json";
-var MCP_PROTOCOL_VERSION = "2024-11-05";
+var MCP_SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
 var JSON_RPC_METHOD_NOT_FOUND = -32601;
 var JSON_RPC_INTERNAL_ERROR = -32603;
+var JSON_RPC_INVALID_PARAMS = -32602;
+var JSON_RPC_PARSE_ERROR = -32700;
 var JSON_RPC_VERSION = "2.0";
 var MCP_STATUS_COMPLETED = "completed";
 var MCP_STATUS_ERROR = "error";
@@ -1107,6 +1109,7 @@ var RESULT_ENVELOPE_PROGRESS_KEY = "progress";
 var PROGRESS_LIST_KEYS = ["items", "threads", "files", "events", "messages"];
 var CURSOR_KEYS = ["nextCursor", "nextPageToken"];
 var MCP_METHOD_INITIALIZE = "initialize";
+var MCP_METHOD_PING = "ping";
 var MCP_METHOD_TOOLS_LIST = "tools/list";
 var MCP_METHOD_TOOLS_CALL = "tools/call";
 var MCP_METHOD_RESOURCES_LIST = "resources/list";
@@ -1114,16 +1117,27 @@ var MCP_METHOD_RESOURCES_TEMPLATES_LIST = "resources/templates/list";
 var MCP_METHOD_RESOURCES_READ = "resources/read";
 
 // src/mcp/errors.ts
+var McpProtocolError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
 var assertToolName = (expectedName, actualName) => {
   if (actualName !== expectedName) {
     throwUnknownTool(actualName);
   }
 };
 var throwUnknownTool = (name) => {
-  throw new Error(`Unknown tool: ${name ?? EMPTY_DISPLAY_VALUE2}`);
+  throw new McpProtocolError(
+    JSON_RPC_INVALID_PARAMS,
+    `Unknown tool: ${name ?? EMPTY_DISPLAY_VALUE2}`
+  );
 };
 
 // src/mcp/progress.ts
+import { z as z2 } from "zod";
 var toolResult = (result, startedAt) => {
   const envelope = resultEnvelope(result);
   const data = envelope.data;
@@ -1137,16 +1151,22 @@ var toolResult = (result, startedAt) => {
     content: [{ type: MCP_TEXT_CONTENT_TYPE, text: JSON.stringify(structuredContent, null, 2) }]
   };
 };
+var errorMessage = (caught) => {
+  if (isZodError(caught)) return `Invalid input:
+${z2.prettifyError(caught)}`;
+  return caught instanceof Error ? caught.message : String(caught);
+};
+var isZodError = (caught) => caught instanceof Error && caught.name === "ZodError" && Array.isArray(caught.issues);
 var toolErrorResult = (caught, startedAt = Date.now()) => {
-  const message = caught instanceof Error ? caught.message : String(caught);
-  const structuredContent = {
+  const message = errorMessage(caught);
+  const errorContent = {
     status: MCP_STATUS_ERROR,
     progress: { elapsedMs: elapsedMs(startedAt), errors: [message] },
     error: { message }
   };
   return {
-    structuredContent,
-    content: [{ type: MCP_TEXT_CONTENT_TYPE, text: JSON.stringify(structuredContent, null, 2) }]
+    isError: true,
+    content: [{ type: MCP_TEXT_CONTENT_TYPE, text: JSON.stringify(errorContent, null, 2) }]
   };
 };
 var commandProgressSummary = (data, command) => {
@@ -1253,11 +1273,11 @@ var resourceInputNames = (uriTemplate) => [...uriTemplate.matchAll(/\{([^}]+)\}/
 });
 
 // src/mcp/schema.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var mcpToolOutputSchema = (dataSchema) => ({
   type: "object",
   properties: {
-    data: z2.toJSONSchema(dataSchema),
+    data: z3.toJSONSchema(dataSchema),
     progress: {
       type: "object",
       properties: {
@@ -1297,10 +1317,10 @@ var createCommandMcpRoute = ({
   inputSchema,
   outputSchema
 });
-var commandMcpRouteToTool = (route, prefix) => ({
+var commandMcpRouteToTool = (route, prefix, boundOptions = {}) => ({
   name: commandNameToMcpToolName(route.command.name, prefix),
-  description: route.command.description,
-  inputSchema: z3.toJSONSchema(route.inputSchema),
+  description: commandMcpDescription(route.command),
+  inputSchema: z4.toJSONSchema(commandMcpInputSchema(route, boundOptions)),
   outputSchema: mcpToolOutputSchema(route.outputSchema),
   annotations: commandMcpAnnotations(route.command)
 });
@@ -1308,12 +1328,51 @@ var commandNameToMcpToolName = (name, prefix) => {
   const baseName = name.replaceAll(COMMAND_NAME_SEPARATOR, TOOL_NAME_SEPARATOR);
   return prefix ? `${prefix}_${baseName}` : baseName;
 };
-var createCommandMcpRouter = ({ prefix, routes }) => {
+var commandMcpInputSchema = (route, boundOptions = {}) => {
+  const schema = route.inputSchema;
+  const shape = objectShape(schema);
+  if (!shape) return schema;
+  const hidden = hiddenInputNames(route.command, boundOptions);
+  const required = new Set(
+    (route.command.options ?? []).filter((option) => option.mcp === "required").map(optionInputName)
+  );
+  return z4.object(
+    Object.fromEntries(
+      Object.entries(shape).filter(([name]) => !hidden.has(name)).map(([name, property]) => [
+        name,
+        required.has(name) ? requiredProperty(property) : property
+      ])
+    )
+  );
+};
+var commandMcpInput = (route, args, boundOptions = {}) => {
+  const inputNames = objectInputNames(route.inputSchema);
+  const routeBoundOptions = Object.entries(boundOptions).filter(([name]) => inputNames.has(name));
+  for (const [name, value] of routeBoundOptions) {
+    if (args[name] !== void 0 && args[name] !== value) {
+      throw new Error(`'${name}' is fixed to '${value}' by this MCP server`);
+    }
+  }
+  commandMcpInputSchema(route, boundOptions).parse(args);
+  const hidden = hiddenInputNames(route.command, boundOptions);
+  const visibleArgs = Object.fromEntries(
+    Object.entries(args).filter(([name]) => !hidden.has(name))
+  );
+  return route.inputSchema.parse({
+    ...visibleArgs,
+    ...Object.fromEntries(routeBoundOptions)
+  });
+};
+var createCommandMcpRouter = ({
+  boundOptions = {},
+  prefix,
+  routes
+}) => {
   const mcpRoutes = routes.filter((route) => route.command.mcp);
   const toolRoutes = mcpRoutes.filter((route) => isCommandMcpToolMetadata(route.command.mcp));
   const resourceRoutes = mcpRoutes.flatMap(commandMcpRouteToResourceRoute);
   return {
-    tools: toolRoutes.map((route) => commandMcpRouteToTool(route, prefix)),
+    tools: toolRoutes.map((route) => commandMcpRouteToTool(route, prefix, boundOptions)),
     resources: resourceRoutes.filter((route) => !isResourceTemplate(route.uriTemplate)).map(commandResourceRouteToResource),
     resourceTemplates: resourceRoutes.filter((route) => isResourceTemplate(route.uriTemplate)).map(commandResourceRouteToResourceTemplate),
     callTool: async (params) => {
@@ -1324,7 +1383,7 @@ var createCommandMcpRouter = ({ prefix, routes }) => {
       if (!route) {
         return throwUnknownTool(toolCall.name);
       }
-      const input = route.inputSchema.parse(toolCall.arguments ?? {});
+      const input = commandMcpInput(route, toolCall.arguments ?? {}, boundOptions);
       const data = route.outputSchema.parse(await route.handler(input));
       return { data, progress: commandProgressSummary(data, route.command) };
     },
@@ -1335,11 +1394,29 @@ var createCommandMcpRouter = ({ prefix, routes }) => {
         throw new Error(`Unknown resource: ${resourceRead.uri ?? EMPTY_DISPLAY_VALUE2}`);
       }
       return routeMatch.route.command.outputSchema.parse(
-        await routeMatch.route.handler(routeMatch.input)
+        await routeMatch.route.handler({ ...routeMatch.input, ...boundOptions })
       );
     }
   };
 };
+var hiddenInputNames = (command, boundOptions) => /* @__PURE__ */ new Set([
+  ...Object.keys(boundOptions),
+  ...(command.options ?? []).filter((option) => option.mcp === false).map(optionInputName)
+]);
+var objectShape = (schema) => schema.def.type === "object" ? schema.shape : void 0;
+var requiredProperty = (property) => property.def.type === "optional" ? property.unwrap() : property;
+var objectInputNames = (schema) => new Set(Object.keys(objectShape(schema) ?? {}));
+var commandMcpDescription = (command) => {
+  const mcp = command.mcp;
+  if (!isCommandMcpToolMetadata(mcp)) return command.description;
+  const notes = [
+    ...mcp.sideEffects?.length ? [`Side effects: ${mcp.sideEffects.join(" ")}`] : [],
+    ...mcp.requiresConfirmation ? ["Confirm with the user before calling this tool."] : []
+  ];
+  return notes.length ? `${command.description}
+
+${notes.join("\n")}` : command.description;
+};
 var commandMcpAnnotations = (command) => {
   const mcp = command.mcp;
   if (!isCommandMcpToolMetadata(mcp)) return void 0;
@@ -1347,9 +1424,7 @@ var commandMcpAnnotations = (command) => {
     readOnlyHint: mcp.readOnly,
     destructiveHint: mcp.destructive,
     idempotentHint: mcp.idempotent,
-    openWorldHint: mcp.openWorld,
-    requiresConfirmation: mcp.requiresConfirmation,
-    sideEffects: mcp.sideEffects
+    openWorldHint: mcp.openWorld
   };
 };
 
@@ -1485,8 +1560,14 @@ var createSingleToolMcpServer = ({
     }
   });
 };
+var negotiateMcpProtocolVersion = (params) => {
+  const requested = params?.protocolVersion;
+  return typeof requested === "string" && MCP_SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : MCP_SUPPORTED_PROTOCOL_VERSIONS[0];
+};
 var createMcpServer = ({
   name,
+  version = DEFAULT_MCP_SERVER_VERSION,
+  instructions,
   tools,
   resources = [],
   resourceTemplates = [],
@@ -1503,15 +1584,24 @@ var createMcpServer = ({
   const error = (id, code, message) => {
     send({ jsonrpc: JSON_RPC_VERSION, id, error: { code, message } });
   };
+  const protocolError = (id, caught) => {
+    const code = caught instanceof McpProtocolError ? caught.code : JSON_RPC_INTERNAL_ERROR;
+    error(id, code, caught instanceof Error ? caught.message : String(caught));
+  };
   const handleRequest = async (request) => {
     if (request.method === MCP_METHOD_INITIALIZE) {
       result(request.id, {
-        protocolVersion: MCP_PROTOCOL_VERSION,
+        protocolVersion: negotiateMcpProtocolVersion(request.params),
         capabilities: { resources: {}, tools: {} },
-        serverInfo: { name, version: DEFAULT_MCP_SERVER_VERSION }
+        serverInfo: { name, version },
+        instructions
       });
       return;
     }
+    if (request.method === MCP_METHOD_PING) {
+      result(request.id, {});
+      return;
+    }
     if (request.method === MCP_METHOD_TOOLS_LIST) {
       result(request.id, { tools });
       return;
@@ -1533,11 +1623,10 @@ var createMcpServer = ({
         );
         return;
       }
-      const startedAt = Date.now();
       try {
         result(request.id, resourceResult(request.params, await readResource(request.params)));
       } catch (caught) {
-        result(request.id, toolErrorResult(caught, startedAt));
+        protocolError(request.id, caught);
       }
       return;
     }
@@ -1546,7 +1635,11 @@ var createMcpServer = ({
       try {
         result(request.id, toolResult(await callTool(request.params), startedAt));
       } catch (caught) {
-        result(request.id, toolErrorResult(caught, startedAt));
+        if (caught instanceof McpProtocolError) {
+          protocolError(request.id, caught);
+        } else {
+          result(request.id, toolErrorResult(caught, startedAt));
+        }
       }
       return;
     }
@@ -1559,24 +1652,88 @@ var createMcpServer = ({
     }
   };
   return {
+    handleRequest,
     start: async () => {
       const input = createInterface({ input: process.stdin });
+      const pending = /* @__PURE__ */ new Set();
       for await (const line of input) {
         if (!line.trim()) continue;
+        let request;
         try {
-          await handleRequest(JSON.parse(line));
+          request = JSON.parse(line);
         } catch (caught) {
-          error(
-            void 0,
-            JSON_RPC_INTERNAL_ERROR,
-            caught instanceof Error ? caught.message : String(caught)
-          );
+          const message = caught instanceof Error ? caught.message : String(caught);
+          protocolError(void 0, new McpProtocolError(JSON_RPC_PARSE_ERROR, message));
+          continue;
         }
+        const task = handleRequest(request).catch((caught) => protocolError(request.id, caught)).finally(() => pending.delete(task));
+        pending.add(task);
       }
+      await Promise.all(pending);
     }
   };
 };
 
+// src/mcp/server-options.ts
+var parseMcpServerArgv = (argv) => {
+  const flags = {};
+  const positionals = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+    const [rawName, inlineValue] = splitFlag(token.slice(2));
+    const nextToken = argv[index + 1];
+    if (inlineValue !== void 0) {
+      flags[kebabToCamel2(rawName)] = inlineValue;
+    } else if (nextToken !== void 0 && !nextToken.startsWith("--")) {
+      flags[kebabToCamel2(rawName)] = nextToken;
+      index += 1;
+    } else {
+      flags[kebabToCamel2(rawName)] = "true";
+    }
+  }
+  return { flags, positionals };
+};
+var mcpServerOptionEnvName = (envPrefix, option) => option.env ?? `${envPrefix}_${camelToConstant(kebabToCamel2(option.name))}`;
+var resolveMcpServerOptions = ({
+  argvFlags,
+  definitions,
+  env,
+  envPrefix
+}) => {
+  const values = {};
+  const missing = [];
+  for (const definition of definitions) {
+    const inputName = kebabToCamel2(definition.name);
+    const envName = mcpServerOptionEnvName(envPrefix, definition);
+    const value = argvFlags[inputName] ?? nonEmpty(env[envName]);
+    if (value !== void 0) {
+      values[inputName] = value;
+    } else if (definition.required) {
+      missing.push(`--${definition.name} <value> (or ${envName})`);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(`Missing required MCP server option: ${missing.join(", ")}`);
+  }
+  return values;
+};
+var withoutMcpServerOptionFlags = (flags, definitions) => {
+  const optionNames = new Set(definitions.map((definition) => kebabToCamel2(definition.name)));
+  return Object.fromEntries(Object.entries(flags).filter(([name]) => !optionNames.has(name)));
+};
+var splitFlag = (flag) => {
+  const separatorIndex = flag.indexOf("=");
+  if (separatorIndex === -1) return [flag, void 0];
+  return [flag.slice(0, separatorIndex), flag.slice(separatorIndex + 1)];
+};
+var nonEmpty = (value) => value?.trim() ? value : void 0;
+var kebabToCamel2 = (value) => value.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+var camelToConstant = (value) => value.replace(/([A-Z])/g, "_$1").toUpperCase();
+
 // src/mcp/command-server.ts
 var loadCommandMcpRoutes = async (commandsDir, getContext = () => void 0, importCommandModule2) => {
   const modules = await loadCommandModules(commandsDir, importCommandModule2);
@@ -1587,38 +1744,103 @@ var loadCommandMcpRoutes = async (commandsDir, getContext = () => void 0, import
   return factories.map((factory) => factory(getContext)).filter((route) => route.command.mcp);
 };
 var createCommandMcpServer = async ({
+  argv = process.argv.slice(2),
   commandsDir,
+  env = process.env,
+  envPrefix,
   getContext,
   importCommandModule: importCommandModule2,
   importMetaUrl,
+  instructions,
   name,
-  prefix
+  prefix,
+  serverOptions = [],
+  version
 }) => {
   const commandDirectory = commandsDir ?? join5(dirname3(fileURLToPath4(importMetaUrl)), DEFAULT_COMMANDS_DIR);
-  const { tools, resources, resourceTemplates, callTool, readResource } = createCommandMcpRouter({
-    prefix,
-    routes: await loadCommandMcpRoutes(commandDirectory, getContext, importCommandModule2)
+  const parsedArgv = parseMcpServerArgv(argv);
+  const boundOptions = resolveMcpServerOptions({
+    argvFlags: parsedArgv.flags,
+    definitions: serverOptions,
+    env,
+    envPrefix: envPrefix ?? packageEnvPrefix(name)
+  });
+  const routes = await loadCommandMcpRoutes(
+    commandDirectory,
+    () => getContext ? getContext(boundOptions) : void 0,
+    importCommandModule2
+  );
+  const router = createCommandMcpRouter({ boundOptions, prefix, routes });
+  const server = createMcpServer({
+    name,
+    version,
+    instructions: typeof instructions === "function" ? instructions(boundOptions) : instructions,
+    tools: router.tools,
+    resources: router.resources,
+    resourceTemplates: router.resourceTemplates,
+    callTool: router.callTool,
+    readResource: router.readResource
   });
-  return createMcpServer({ name, tools, resources, resourceTemplates, callTool, readResource });
+  return {
+    ...server,
+    boundOptions,
+    command: parsedArgv.positionals.length > 0 ? parsedArgv.positionals.join(" ") : void 0,
+    runCommand: (commandName, flags = {}) => runMcpCommandOnce(routes, commandName, withoutMcpServerOptionFlags(flags, serverOptions), {
+      boundOptions
+    }),
+    commandFlags: withoutMcpServerOptionFlags(parsedArgv.flags, serverOptions)
+  };
+};
+var runMcpCommandOnce = async (routes, commandName, flags, { boundOptions }) => {
+  const route = routes.find(
+    (candidate) => candidate.command.name === commandName && isCommandMcpToolMetadata(candidate.command.mcp)
+  );
+  if (!route) throw new Error(`Unknown command: ${commandName}`);
+  const input = commandMcpInput(route, oneShotInput(flags), boundOptions);
+  return route.outputSchema.parse(await route.handler(input));
 };
 var startCommandMcpServer = async (options) => {
-  await (await createCommandMcpServer(options)).start();
+  try {
+    const server = await createCommandMcpServer(options);
+    if (!server.command) {
+      await server.start();
+      return;
+    }
+    const data = await server.runCommand(server.command, server.commandFlags);
+    process.stdout.write(`${JSON.stringify(data)}
+`);
+  } catch (caught) {
+    process.stderr.write(`${errorMessage(caught)}
+`);
+    process.exitCode = 1;
+  }
 };
 var startPackageCommandMcpServer = async ({
+  envPrefix,
   importMetaUrl,
   mcpServerPrefix,
   name,
   prefix,
+  version,
   ...options
 }) => {
   const metadata = packageCommandMetadata(importMetaUrl, { mcpServerPrefix });
   await startCommandMcpServer({
     ...options,
+    envPrefix: envPrefix ?? packageEnvPrefix(metadata.packageName),
     importMetaUrl,
     name: name ?? metadata.mcpServerName,
-    prefix: prefix ?? metadata.mcpPrefix
+    prefix: prefix ?? metadata.mcpPrefix,
+    version: version ?? metadata.version
   });
 };
+var ONE_SHOT_BOOLEANS = /* @__PURE__ */ new Map([
+  ["true", true],
+  ["false", false]
+]);
+var oneShotInput = (flags) => Object.fromEntries(
+  Object.entries(flags).map(([name, value]) => [name, ONE_SHOT_BOOLEANS.get(value) ?? value])
+);
 
 // src/scripts/dev-command.ts
 import { mkdirSync, rmSync as rmSync2 } from "fs";
@@ -1742,6 +1964,7 @@ var packageDevCommandConfig = (importMetaUrl, options) => {
 };
 export {
   DEFAULT_COMMANDS_DIR,
+  McpProtocolError,
   PROGRAM_NAME_ENV_SUFFIX,
   PackageManager,
   assertToolName,
@@ -1752,6 +1975,8 @@ export {
   commandExportsFromModules,
   commandInputString,
   commandInputValue,
+  commandMcpInput,
+  commandMcpInputSchema,
   commandMcpRouteToResourceRoute,
   commandMcpRouteToTool,
   commandNameToMcpToolName,
@@ -1790,12 +2015,16 @@ export {
   loadCommandMcpRoutes,
   loadCommandModules,
   loadCommandModulesFromFiles,
+  mcpServerOptionEnvName,
   mcpToolOutputSchema,
+  negotiateMcpProtocolVersion,
   normalizeCommandInputAliases,
+  optionInputName,
   packageBinEntry,
   packageCommandMetadata,
   packageEnvPrefix,
   packageRoot,
+  parseMcpServerArgv,
   printProgramHelp,
   readPackageJson,
   registerCliCommandsFromDirectory,
@@ -1803,7 +2032,9 @@ export {
   registerCompletionCommand,
   registerParentCommandsFromDefinitions,
   registerUpdateCommand,
+  resolveMcpServerOptions,
   resourceResult,
+  runMcpCommandOnce,
   setProgramHelpData,
   shortPackageName,
   startCommandMcpServer,
@@ -1812,6 +2043,7 @@ export {
   uninstallDevCommand,
   uninstallPackageDevCommand,
   uninstallPackageDevCommands,
-  z4 as z
+  withoutMcpServerOptionFlags,
+  z5 as z
 };
 //# sourceMappingURL=index.js.map