poe-code 3.0.187 → 3.0.188

package/packages/cmdkit/dist/mcp.js

@@ -1,1254 +0,0 @@
-// packages/cmdkit/src/mcp.ts
-import { access, readFile, writeFile } from "node:fs/promises";
-
-// packages/tiny-stdio-mcp-server/src/server.ts
-import * as readline from "readline";
-
-// packages/tiny-stdio-mcp-server/src/types.ts
-var JSON_RPC_ERROR_CODES = {
-  PARSE_ERROR: -32700,
-  INVALID_REQUEST: -32600,
-  METHOD_NOT_FOUND: -32601,
-  INVALID_PARAMS: -32602,
-  INTERNAL_ERROR: -32603
-};
-var ToolError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "ToolError";
-  }
-};
-
-// packages/tiny-stdio-mcp-server/src/jsonrpc.ts
-function parseMessage(line) {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return {
-      success: false,
-      error: {
-        code: JSON_RPC_ERROR_CODES.PARSE_ERROR,
-        message: "Parse error"
-      },
-      id: null
-    };
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return {
-      success: false,
-      error: {
-        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-        message: "Invalid Request"
-      },
-      id: null
-    };
-  }
-  const obj = parsed;
-  const hasId = "id" in obj;
-  const id = typeof obj.id === "string" || typeof obj.id === "number" ? obj.id : null;
-  if (obj.jsonrpc !== "2.0") {
-    return {
-      success: false,
-      error: {
-        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-        message: "Invalid Request"
-      },
-      id
-    };
-  }
-  if (typeof obj.method !== "string") {
-    return {
-      success: false,
-      error: {
-        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-        message: "Invalid Request"
-      },
-      id
-    };
-  }
-  if (!hasId) {
-    return {
-      success: true,
-      isNotification: true,
-      request: {
-        jsonrpc: "2.0",
-        method: obj.method,
-        params: obj.params
-      }
-    };
-  }
-  if (id === null) {
-    return {
-      success: false,
-      error: {
-        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-        message: "Invalid Request"
-      },
-      id: null
-    };
-  }
-  return {
-    success: true,
-    isNotification: false,
-    request: {
-      jsonrpc: "2.0",
-      id,
-      method: obj.method,
-      params: obj.params
-    }
-  };
-}
-function formatSuccessResponse(id, result) {
-  const response = {
-    jsonrpc: "2.0",
-    id,
-    result
-  };
-  return JSON.stringify(response);
-}
-function formatErrorResponse(id, error) {
-  const response = {
-    jsonrpc: "2.0",
-    id,
-    error
-  };
-  return JSON.stringify(response);
-}
-
-// packages/tiny-stdio-mcp-server/src/content/file-type.ts
-function fileTypeFromBuffer(data) {
-  if (data.length < 12) {
-    return void 0;
-  }
-  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71 && data[4] === 13 && data[5] === 10 && data[6] === 26 && data[7] === 10) {
-    return { mime: "image/png", ext: "png" };
-  }
-  if (data[0] === 255 && data[1] === 216 && data[2] === 255) {
-    return { mime: "image/jpeg", ext: "jpg" };
-  }
-  if (data[0] === 71 && data[1] === 73 && data[2] === 70 && data[3] === 56) {
-    return { mime: "image/gif", ext: "gif" };
-  }
-  if (data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70 && data[8] === 87 && data[9] === 69 && data[10] === 66 && data[11] === 80) {
-    return { mime: "image/webp", ext: "webp" };
-  }
-  if (data[0] === 255 && (data[1] === 251 || data[1] === 250) || data[0] === 73 && data[1] === 68 && data[2] === 51) {
-    return { mime: "audio/mpeg", ext: "mp3" };
-  }
-  if (data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70 && data[8] === 87 && data[9] === 65 && data[10] === 86 && data[11] === 69) {
-    return { mime: "audio/wav", ext: "wav" };
-  }
-  if (data[0] === 79 && data[1] === 103 && data[2] === 103 && data[3] === 83) {
-    return { mime: "audio/ogg", ext: "ogg" };
-  }
-  if (data[4] === 102 && data[5] === 116 && data[6] === 121 && data[7] === 112 && data[8] === 77 && data[9] === 52 && data[10] === 65) {
-    return { mime: "audio/mp4", ext: "m4a" };
-  }
-  if (data[4] === 102 && data[5] === 116 && data[6] === 121 && data[7] === 112) {
-    return { mime: "video/mp4", ext: "mp4" };
-  }
-  if (data[0] === 26 && data[1] === 69 && data[2] === 223 && data[3] === 163) {
-    return { mime: "video/webm", ext: "webm" };
-  }
-  return void 0;
-}
-
-// packages/tiny-stdio-mcp-server/src/content/image.ts
-var SUPPORTED_IMAGE_MIMES = /* @__PURE__ */ new Set([
-  "image/png",
-  "image/jpeg",
-  "image/gif",
-  "image/webp"
-]);
-var Image = class _Image {
-  constructor(base64Data, mimeType) {
-    this.base64Data = base64Data;
-    this.mimeType = mimeType;
-  }
-  static async fromUrl(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch image from ${url}: ${response.status} ${response.statusText}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const data = new Uint8Array(arrayBuffer);
-    const detected = fileTypeFromBuffer(data);
-    let mimeType;
-    if (detected && SUPPORTED_IMAGE_MIMES.has(detected.mime)) {
-      mimeType = detected.mime;
-    } else {
-      const contentType = response.headers.get("content-type")?.split(";")[0];
-      if (contentType && SUPPORTED_IMAGE_MIMES.has(contentType)) {
-        mimeType = contentType;
-      } else {
-        throw new Error(`Unable to detect image MIME type from ${url}`);
-      }
-    }
-    const base64 = Buffer.from(data).toString("base64");
-    return new _Image(base64, mimeType);
-  }
-  static fromBytes(data, format) {
-    let mimeType;
-    if (format) {
-      mimeType = format.includes("/") ? format : `image/${format}`;
-    } else {
-      const detected = fileTypeFromBuffer(data);
-      if (!detected || !SUPPORTED_IMAGE_MIMES.has(detected.mime)) {
-        throw new Error("Unable to detect image MIME type from bytes");
-      }
-      mimeType = detected.mime;
-    }
-    const base64 = Buffer.from(data).toString("base64");
-    return new _Image(base64, mimeType);
-  }
-  static fromBase64(base64, mimeType) {
-    return new _Image(base64, mimeType);
-  }
-  toContentBlock() {
-    return {
-      type: "image",
-      data: this.base64Data,
-      mimeType: this.mimeType
-    };
-  }
-};
-
-// packages/tiny-stdio-mcp-server/src/content/audio.ts
-var SUPPORTED_AUDIO_MIMES = /* @__PURE__ */ new Set([
-  "audio/mpeg",
-  "audio/wav",
-  "audio/ogg",
-  "audio/mp4"
-]);
-var AUDIO_FORMAT_MAP = {
-  mp3: "audio/mpeg",
-  wav: "audio/wav",
-  ogg: "audio/ogg",
-  m4a: "audio/mp4",
-  mpeg: "audio/mpeg"
-};
-var Audio = class _Audio {
-  constructor(base64Data, mimeType) {
-    this.base64Data = base64Data;
-    this.mimeType = mimeType;
-  }
-  static async fromUrl(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch audio from ${url}: ${response.status} ${response.statusText}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const data = new Uint8Array(arrayBuffer);
-    const detected = fileTypeFromBuffer(data);
-    let mimeType;
-    if (detected && SUPPORTED_AUDIO_MIMES.has(detected.mime)) {
-      mimeType = detected.mime;
-    } else {
-      const contentType = response.headers.get("content-type")?.split(";")[0];
-      if (contentType && SUPPORTED_AUDIO_MIMES.has(contentType)) {
-        mimeType = contentType;
-      } else {
-        throw new Error(`Unable to detect audio MIME type from ${url}`);
-      }
-    }
-    const base64 = Buffer.from(data).toString("base64");
-    return new _Audio(base64, mimeType);
-  }
-  static fromBytes(data, format) {
-    let mimeType;
-    if (format) {
-      if (format.includes("/")) {
-        mimeType = format;
-      } else {
-        mimeType = AUDIO_FORMAT_MAP[format.toLowerCase()] || `audio/${format}`;
-      }
-    } else {
-      const detected = fileTypeFromBuffer(data);
-      if (!detected || !SUPPORTED_AUDIO_MIMES.has(detected.mime)) {
-        throw new Error("Unable to detect audio MIME type from bytes");
-      }
-      mimeType = detected.mime;
-    }
-    const base64 = Buffer.from(data).toString("base64");
-    return new _Audio(base64, mimeType);
-  }
-  static fromBase64(base64, mimeType) {
-    return new _Audio(base64, mimeType);
-  }
-  toContentBlock() {
-    return {
-      type: "audio",
-      data: this.base64Data,
-      mimeType: this.mimeType
-    };
-  }
-};
-
-// packages/tiny-stdio-mcp-server/src/content/file.ts
-function isTextMimeType(mimeType) {
-  return mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || mimeType === "application/javascript" || mimeType === "application/typescript";
-}
-var File = class _File {
-  constructor(data, mimeType, isText, name) {
-    this.data = data;
-    this.mimeType = mimeType;
-    this.isText = isText;
-    this.name = name;
-  }
-  static async fromUrl(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch file from ${url}: ${response.status} ${response.statusText}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const data = new Uint8Array(arrayBuffer);
-    const detected = fileTypeFromBuffer(data);
-    let mimeType;
-    if (detected) {
-      mimeType = detected.mime;
-    } else {
-      const contentType = response.headers.get("content-type")?.split(";")[0];
-      if (contentType) {
-        mimeType = contentType;
-      } else {
-        throw new Error(`Unable to detect MIME type from ${url}`);
-      }
-    }
-    const isText = isTextMimeType(mimeType);
-    const name = url.split("/").pop() || "file";
-    return new _File(data, mimeType, isText, name);
-  }
-  static fromBytes(data, mimeType) {
-    const isText = isTextMimeType(mimeType);
-    return new _File(data, mimeType, isText);
-  }
-  static fromText(text, mimeType = "text/plain") {
-    return new _File(text, mimeType, true);
-  }
-  static fromBase64(base64, mimeType) {
-    const data = Buffer.from(base64, "base64");
-    const isText = isTextMimeType(mimeType);
-    return new _File(new Uint8Array(data), mimeType, isText);
-  }
-  toContentBlock() {
-    const uri = this.name ? `file:///${this.name}` : "file:///data";
-    if (this.isText) {
-      let text;
-      if (typeof this.data === "string") {
-        text = this.data;
-      } else {
-        text = new TextDecoder("utf-8").decode(this.data);
-      }
-      return {
-        type: "resource",
-        resource: {
-          uri,
-          mimeType: this.mimeType,
-          text
-        }
-      };
-    } else {
-      let blob;
-      if (typeof this.data === "string") {
-        blob = Buffer.from(this.data).toString("base64");
-      } else {
-        blob = Buffer.from(this.data).toString("base64");
-      }
-      return {
-        type: "resource",
-        resource: {
-          uri,
-          mimeType: this.mimeType,
-          blob
-        }
-      };
-    }
-  }
-};
-
-// packages/tiny-stdio-mcp-server/src/content/convert.ts
-function convertSingleValue(value) {
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return { type: "text", text: String(value) };
-  }
-  if (value === null) {
-    return { type: "text", text: "null" };
-  }
-  if (value instanceof Image) {
-    return value.toContentBlock();
-  }
-  if (value instanceof Audio) {
-    return value.toContentBlock();
-  }
-  if (value instanceof File) {
-    return value.toContentBlock();
-  }
-  if (isContentBlock(value)) {
-    return value;
-  }
-  return { type: "text", text: JSON.stringify(value) };
-}
-function toContentBlocks(result) {
-  if (result === void 0) {
-    return [];
-  }
-  if (Array.isArray(result)) {
-    return result.flatMap((item) => toContentBlocks(item));
-  }
-  return [convertSingleValue(result)];
-}
-function isContentBlock(value) {
-  if (!("type" in value) || typeof value.type !== "string") {
-    return false;
-  }
-  return value.type === "text" || value.type === "image" || value.type === "audio" || value.type === "resource";
-}
-
-// packages/tiny-stdio-mcp-server/src/server.ts
-var PROTOCOL_VERSION = "2025-11-25";
-function createServer(options) {
-  const tools = /* @__PURE__ */ new Map();
-  const notificationListeners = /* @__PURE__ */ new Set();
-  let initialized = false;
-  const handleMessage = async (method, params) => {
-    if (method === "ping") {
-      return { result: {} };
-    }
-    if (method === "initialize") {
-      initialized = true;
-      const requestedProtocol = typeof params?.protocolVersion === "string" ? params.protocolVersion : null;
-      const result = {
-        protocolVersion: requestedProtocol ?? PROTOCOL_VERSION,
-        capabilities: {
-          tools: {
-            listChanged: true
-          }
-        },
-        serverInfo: {
-          name: options.name,
-          version: options.version
-        }
-      };
-      return { result };
-    }
-    if (method === "notifications/initialized") {
-      return { result: void 0 };
-    }
-    if (!initialized) {
-      return {
-        error: {
-          code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-          message: "Server not initialized"
-        }
-      };
-    }
-    if (method === "tools/list") {
-      const toolList = [];
-      for (const tool of tools.values()) {
-        toolList.push({
-          name: tool.name,
-          description: tool.description,
-          inputSchema: tool.inputSchema
-        });
-      }
-      return { result: { tools: toolList } };
-    }
-    if (method === "tools/call") {
-      const toolName = params?.name;
-      const toolArgs = params?.arguments || {};
-      if (!toolName) {
-        return {
-          error: {
-            code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
-            message: "Tool name required"
-          }
-        };
-      }
-      const tool = tools.get(toolName);
-      if (!tool) {
-        return {
-          error: {
-            code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
-            message: `Tool not found: ${toolName}`
-          }
-        };
-      }
-      try {
-        const handlerResult = await tool.handler(toolArgs);
-        const result = { content: toContentBlocks(handlerResult) };
-        return { result };
-      } catch (err) {
-        if (err instanceof ToolError) {
-          return {
-            error: {
-              code: err.code,
-              message: err.message
-            }
-          };
-        }
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        const result = {
-          content: [{ type: "text", text: `Error: ${errorMessage}` }],
-          isError: true
-        };
-        return { result };
-      }
-    }
-    return {
-      error: {
-        code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
-        message: "Method not found"
-      }
-    };
-  };
-  const processLine = async (line, write) => {
-    const parsed = parseMessage(line);
-    if (!parsed.success) {
-      write(formatErrorResponse(parsed.id, parsed.error) + "\n");
-      return;
-    }
-    const { request, isNotification } = parsed;
-    const { result, error } = await server.handleMessage(
-      request.method,
-      request.params
-    );
-    if (isNotification) {
-      return;
-    }
-    const requestWithId = request;
-    if (error) {
-      write(formatErrorResponse(requestWithId.id, error) + "\n");
-    } else if (result !== void 0) {
-      write(formatSuccessResponse(requestWithId.id, result) + "\n");
-    }
-  };
-  const broadcastNotification = (method) => {
-    const notification = {
-      jsonrpc: "2.0",
-      method
-    };
-    for (const listener of notificationListeners) {
-      listener(notification);
-    }
-  };
-  const server = {
-    tool(name, description, inputSchema, handler) {
-      tools.set(name, {
-        name,
-        description,
-        inputSchema,
-        handler
-      });
-      return server;
-    },
-    onNotification(listener) {
-      notificationListeners.add(listener);
-      return () => {
-        notificationListeners.delete(listener);
-      };
-    },
-    removeTool(name) {
-      return tools.delete(name);
-    },
-    async notifyToolsChanged() {
-      if (initialized) {
-        broadcastNotification("notifications/tools/list_changed");
-      }
-    },
-    handleMessage,
-    async listen() {
-      return server.connect({
-        readable: process.stdin,
-        writable: process.stdout
-      });
-    },
-    async connect(transport) {
-      return new Promise((resolve) => {
-        const unsubscribe = server.onNotification((notification) => {
-          transport.writable.write(`${JSON.stringify(notification)}
-`);
-        });
-        const rl = readline.createInterface({
-          input: transport.readable,
-          crlfDelay: Infinity
-        });
-        rl.on("line", (line) => {
-          processLine(line, (data) => transport.writable.write(data));
-        });
-        rl.on("close", () => {
-          unsubscribe();
-          resolve();
-        });
-      });
-    },
-    async connectSDK(transport) {
-      return new Promise((resolve) => {
-        const unsubscribe = server.onNotification((notification) => {
-          void transport.send(notification);
-        });
-        transport.onmessage = async (message) => {
-          if (!("method" in message)) {
-            return;
-          }
-          if (!("id" in message) || message.id === void 0) {
-            await server.handleMessage(message.method, message.params);
-            return;
-          }
-          const request = message;
-          const { result, error } = await server.handleMessage(
-            request.method,
-            request.params
-          );
-          if (error) {
-            const response = {
-              jsonrpc: "2.0",
-              id: request.id,
-              error
-            };
-            await transport.send(response);
-          } else if (result !== void 0) {
-            const response = {
-              jsonrpc: "2.0",
-              id: request.id,
-              result
-            };
-            await transport.send(response);
-          }
-        };
-        transport.onclose = () => {
-          unsubscribe();
-          resolve();
-        };
-        transport.start();
-      });
-    }
-  };
-  return server;
-}
-
-// packages/cmdkit-schema/src/index.ts
-function withMetadata(schema, jsonSchema) {
-  if (schema.description !== void 0) {
-    jsonSchema.description = schema.description;
-  }
-  if (schema.default !== void 0) {
-    jsonSchema.default = schema.default;
-  }
-  if (schema.nullable === true) {
-    jsonSchema.nullable = true;
-  }
-  return jsonSchema;
-}
-function withStringMetadata(schema, jsonSchema) {
-  if (schema.minLength !== void 0) {
-    jsonSchema.minLength = schema.minLength;
-  }
-  if (schema.maxLength !== void 0) {
-    jsonSchema.maxLength = schema.maxLength;
-  }
-  if (schema.pattern !== void 0) {
-    jsonSchema.pattern = schema.pattern;
-  }
-  if (schema.format !== void 0) {
-    jsonSchema.format = schema.format;
-  }
-  return withMetadata(schema, jsonSchema);
-}
-function withNumberMetadata(schema, jsonSchema) {
-  if (schema.minimum !== void 0) {
-    jsonSchema.minimum = schema.minimum;
-  }
-  if (schema.maximum !== void 0) {
-    jsonSchema.maximum = schema.maximum;
-  }
-  return withMetadata(schema, jsonSchema);
-}
-function withArrayMetadata(schema, jsonSchema) {
-  if (schema.minItems !== void 0) {
-    jsonSchema.minItems = schema.minItems;
-  }
-  if (schema.maxItems !== void 0) {
-    jsonSchema.maxItems = schema.maxItems;
-  }
-  return withMetadata(schema, jsonSchema);
-}
-function withObjectMetadata(schema, jsonSchema) {
-  if (schema.additionalProperties !== void 0) {
-    jsonSchema.additionalProperties = schema.additionalProperties;
-  }
-  return withMetadata(schema, jsonSchema);
-}
-function getEnumJsonType(values) {
-  const [firstValue] = values;
-  if (firstValue === void 0) {
-    return void 0;
-  }
-  const firstType = typeof firstValue;
-  const isSinglePrimitiveType = values.every((value) => typeof value === firstType);
-  if (!isSinglePrimitiveType) {
-    return void 0;
-  }
-  if (firstType === "string" || firstType === "number" || firstType === "boolean") {
-    return firstType;
-  }
-  return void 0;
-}
-function isOptionalSchema(schema) {
-  return schema.kind === "optional";
-}
-function unwrapOptional(schema) {
-  if (isOptionalSchema(schema)) {
-    return unwrapOptional(schema.inner);
-  }
-  return schema;
-}
-function toJsonSchema(schema) {
-  const unwrappedSchema = unwrapOptional(schema);
-  switch (unwrappedSchema.kind) {
-    case "string":
-      return withStringMetadata(unwrappedSchema, { type: "string" });
-    case "number":
-      return withNumberMetadata(unwrappedSchema, { type: unwrappedSchema.jsonType ?? "number" });
-    case "boolean":
-      return withMetadata(unwrappedSchema, { type: "boolean" });
-    case "enum": {
-      const jsonSchema = {
-        enum: unwrappedSchema.nullable === true ? [...unwrappedSchema.values, null] : [...unwrappedSchema.values]
-      };
-      const enumType = unwrappedSchema.jsonType ?? getEnumJsonType(unwrappedSchema.values);
-      if (enumType !== void 0) {
-        jsonSchema.type = enumType;
-      }
-      return withMetadata(unwrappedSchema, jsonSchema);
-    }
-    case "array":
-      return withArrayMetadata(unwrappedSchema, {
-        type: "array",
-        items: toJsonSchema(unwrappedSchema.item)
-      });
-    case "object": {
-      const properties = {};
-      const required = [];
-      for (const [key, propertySchema] of Object.entries(unwrappedSchema.shape)) {
-        properties[key] = toJsonSchema(propertySchema);
-        if (!isOptionalSchema(propertySchema)) {
-          required.push(key);
-        }
-      }
-      return withObjectMetadata(unwrappedSchema, {
-        type: "object",
-        properties,
-        required
-      });
-    }
-  }
-}
-
-// packages/cmdkit/src/index.ts
-import { fileURLToPath } from "node:url";
-var UserError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "UserError";
-  }
-};
-function parseSimpleSemver(value) {
-  const parts = value.split(".");
-  if (parts.length !== 3) {
-    return void 0;
-  }
-  const parsed = parts.map((part) => {
-    if (part.length === 0) {
-      return Number.NaN;
-    }
-    for (const char of part) {
-      if (char < "0" || char > "9") {
-        return Number.NaN;
-      }
-    }
-    return Number(part);
-  });
-  if (parsed.some((part) => !Number.isInteger(part) || part < 0)) {
-    return void 0;
-  }
-  return parsed;
-}
-function parseMinimumApiVersion(requirement) {
-  if (!requirement.startsWith(">=")) {
-    return void 0;
-  }
-  return parseSimpleSemver(requirement.slice(2).trim());
-}
-function compareSemver(left, right) {
-  for (let index = 0; index < left.length; index += 1) {
-    if (left[index] === right[index]) {
-      continue;
-    }
-    return left[index] > right[index] ? 1 : -1;
-  }
-  return 0;
-}
-function resolveCommandSecrets(command, env = process.env) {
-  const secrets = {};
-  for (const [name, secret] of Object.entries(command.secrets)) {
-    const value = env[secret.env];
-    if (value === void 0 && secret.optional !== true) {
-      const details = secret.description ? `
-  ${secret.description}` : "";
-      throw new UserError(`Error: Missing required secret ${secret.env}${details}`);
-    }
-    secrets[name] = value;
-  }
-  return secrets;
-}
-async function assertCommandRequirements(command, context, options = {}) {
-  const requires = command.requires;
-  if (requires === void 0) {
-    return;
-  }
-  const env = options.env ?? process.env;
-  const authEnvVar = options.authEnvVar ?? "POE_API_KEY";
-  if (requires.auth === true && env[authEnvVar] === void 0) {
-    throw new UserError(
-      `Error: Command "${command.name}" requires authentication.
-  Run 'poe-code login' first.`
-    );
-  }
-  if (requires.apiVersion !== void 0) {
-    const minimumVersion = parseMinimumApiVersion(requires.apiVersion);
-    if (minimumVersion === void 0) {
-      throw new UserError(
-        `Error: Command "${command.name}" has invalid apiVersion requirement "${requires.apiVersion}". Expected format ">=X.Y.Z".`
-      );
-    }
-    if (options.apiVersion === void 0) {
-      throw new UserError(
-        `Error: Command "${command.name}" requires API version ${requires.apiVersion}, but no runner API version was provided.`
-      );
-    }
-    const runnerVersion = parseSimpleSemver(options.apiVersion);
-    if (runnerVersion === void 0) {
-      throw new UserError(
-        `Error: Command "${command.name}" requires API version ${requires.apiVersion}, but runner API version "${options.apiVersion}" is not valid semver.`
-      );
-    }
-    if (compareSemver(runnerVersion, minimumVersion) < 0) {
-      throw new UserError(
-        `Error: Command "${command.name}" requires API version ${requires.apiVersion}, but runner API version is ${options.apiVersion}.`
-      );
-    }
-  }
-  const checkResult = await requires.check?.(context);
-  if (checkResult && !checkResult.ok) {
-    throw new UserError(checkResult.message ?? "Command precondition failed.");
-  }
-}
-
-// packages/cmdkit/src/number-schema.ts
-function isValidNumberSchemaValue(value, schema) {
-  return typeof value === "number" && Number.isFinite(value) && (schema.jsonType !== "integer" || Number.isInteger(value));
-}
-function getExpectedNumberDescription(schema) {
-  return schema.jsonType === "integer" ? "an integer" : "a number";
-}
-
-// packages/cmdkit/src/schema-scope.ts
-function filterSchemaForScope(schema, scope) {
-  if (schema.scope !== void 0 && !schema.scope.includes(scope)) {
-    return void 0;
-  }
-  switch (schema.kind) {
-    case "optional": {
-      const inner = filterSchemaForScope(schema.inner, scope);
-      if (inner === void 0) {
-        return void 0;
-      }
-      if (inner.requiredScopes?.includes(scope)) {
-        return inner;
-      }
-      return { ...schema, inner };
-    }
-    case "array": {
-      const item = filterSchemaForScope(schema.item, scope);
-      return item === void 0 ? void 0 : { ...schema, item };
-    }
-    case "string":
-    case "number":
-    case "boolean":
-    case "enum":
-      return schema;
-    case "object":
-      return {
-        ...schema,
-        shape: Object.fromEntries(
-          Object.entries(schema.shape).flatMap(([key, childSchema]) => {
-            const filtered = filterSchemaForScope(childSchema, scope);
-            return filtered === void 0 ? [] : [[key, filtered]];
-          })
-        )
-      };
-  }
-}
-
-// packages/cmdkit/src/mcp.ts
-var RESERVED_SERVICE_NAMES = /* @__PURE__ */ new Set(["params", "secrets", "fetch", "fs", "env", "progress"]);
-function normalizeRoots(roots) {
-  if (!Array.isArray(roots)) {
-    return roots;
-  }
-  return {
-    kind: "group",
-    name: "",
-    aliases: [],
-    secrets: {},
-    children: roots
-  };
-}
-function splitWords(value) {
-  const words = [];
-  let current = "";
-  for (let index = 0; index < value.length; index += 1) {
-    const char = value[index] ?? "";
-    const lower = char.toLowerCase();
-    const upper = char.toUpperCase();
-    const isSeparator = char === "-" || char === "_" || char === " " || char === ".";
-    if (isSeparator) {
-      if (current.length > 0) {
-        words.push(current.toLowerCase());
-        current = "";
-      }
-      continue;
-    }
-    const isUppercase = char !== lower && char === upper;
-    const previous = value[index - 1];
-    const next = value[index + 1];
-    const previousIsLowercase = previous !== void 0 && previous === previous.toLowerCase() && previous !== previous.toUpperCase();
-    const nextIsLowercase = next !== void 0 && next === next.toLowerCase() && next !== next.toUpperCase();
-    if (isUppercase && current.length > 0 && (previousIsLowercase || nextIsLowercase)) {
-      words.push(current.toLowerCase());
-      current = char;
-      continue;
-    }
-    current += char;
-  }
-  if (current.length > 0) {
-    words.push(current.toLowerCase());
-  }
-  return words;
-}
-function formatSegment(segment, casing) {
-  const words = splitWords(segment);
-  if (casing === "snake") {
-    return words.join("_");
-  }
-  return words.map(
-    (word, index) => index === 0 ? word : `${word[0]?.toUpperCase() ?? ""}${word.slice(1)}`
-  ).join("");
-}
-function unwrapOptional2(schema) {
-  if (schema.kind === "optional") {
-    return unwrapOptional2(schema.inner);
-  }
-  return schema;
-}
-function isOptional(schema) {
-  return schema.kind === "optional";
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function createFs() {
-  return {
-    readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
-    writeFile: async (path, contents) => {
-      await writeFile(path, contents);
-    },
-    exists: async (path) => {
-      try {
-        await access(path);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  };
-}
-function createEnv(values = process.env) {
-  return {
-    get(key) {
-      return values[key];
-    }
-  };
-}
-function validateServices(services) {
-  for (const name of Object.keys(services)) {
-    if (RESERVED_SERVICE_NAMES.has(name)) {
-      throw new Error(`Service name "${name}" is reserved. Choose a different name.`);
-    }
-  }
-}
-function applySchemaCasing(schema, casing) {
-  if (schema.type !== "object" || schema.properties === void 0) {
-    if (schema.type === "array" && schema.items !== void 0) {
-      return {
-        ...schema,
-        items: applySchemaCasing(schema.items, casing)
-      };
-    }
-    return schema;
-  }
-  const properties = Object.fromEntries(
-    Object.entries(schema.properties).map(([key, value]) => [
-      formatSegment(key, casing),
-      applySchemaCasing(value, casing)
-    ])
-  );
-  const required = schema.required?.map((key) => formatSegment(key, casing));
-  return {
-    ...schema,
-    properties,
-    ...required === void 0 ? {} : { required }
-  };
-}
-function collectParamSummaries(schema, casing, path = [], inheritedOptional = false) {
-  const summaries = [];
-  for (const [key, rawChildSchema] of Object.entries(schema.shape)) {
-    const childSchema = unwrapOptional2(rawChildSchema);
-    const nextPath = [...path, formatSegment(key, casing)];
-    const optional = inheritedOptional || isOptional(rawChildSchema);
-    if (childSchema.kind === "object") {
-      summaries.push(...collectParamSummaries(childSchema, casing, nextPath, optional));
-      continue;
-    }
-    summaries.push(`${nextPath.join(".")}${optional ? "" : " (required)"}`);
-  }
-  return summaries;
-}
-function buildToolDescription(description, params, casing) {
-  const summary = collectParamSummaries(params, casing);
-  const parameterSummary = summary.length === 0 ? "" : `Parameters: ${summary.join(", ")}.`;
-  if (description === void 0) {
-    return parameterSummary;
-  }
-  if (parameterSummary.length === 0) {
-    return description;
-  }
-  return `${description} ${parameterSummary}`;
-}
-function matchesAllowlist(toolName, allowlist) {
-  if (allowlist === void 0) {
-    return true;
-  }
-  const segments = toolName.split("__");
-  const candidates = segments.map((_segment, index) => segments.slice(0, index + 1).join("__"));
-  return candidates.some((candidate) => allowlist.includes(candidate));
-}
-function formatToolName(path) {
-  return path.map((segment) => formatSegment(segment, "snake")).join("__");
-}
-function enumerateTools(root, casing, allowlist) {
-  const tools = [];
-  function visit(node, path) {
-    if (node.kind === "command") {
-      if (!node.scope.includes("mcp")) {
-        return;
-      }
-      const name = formatToolName([...path, node.name]);
-      const params = filterSchemaForScope(node.params, "mcp");
-      if (!matchesAllowlist(name, allowlist)) {
-        return;
-      }
-      if (params === void 0 || params.kind !== "object") {
-        throw new Error(`Bug: command "${name}" must define an object params schema for MCP.`);
-      }
-      tools.push({
-        command: node,
-        name,
-        description: buildToolDescription(node.description, params, casing),
-        inputSchema: applySchemaCasing(toJsonSchema(params), casing)
-      });
-      return;
-    }
-    const nextPath = [...path, node.name];
-    for (const child of node.children) {
-      visit(child, nextPath);
-    }
-  }
-  const rootPath = root.name.length === 0 ? [] : [root.name];
-  for (const child of root.children) {
-    visit(child, rootPath);
-  }
-  return tools;
-}
-function validateEnum(value, schema, label) {
-  if (!schema.values.includes(value)) {
-    throw new UserError(
-      `Invalid value for "${label}". Expected one of: ${schema.values.map((candidate) => String(candidate)).join(", ")}.`
-    );
-  }
-  return value;
-}
-function validateSchemaValue(schema, value, casing, label) {
-  const unwrappedSchema = unwrapOptional2(schema);
-  if (value === null && unwrappedSchema.nullable === true) {
-    return null;
-  }
-  switch (unwrappedSchema.kind) {
-    case "string":
-      if (typeof value !== "string") {
-        throw new UserError(`Invalid value for "${label}". Expected a string.`);
-      }
-      return value;
-    case "number":
-      if (!isValidNumberSchemaValue(value, unwrappedSchema)) {
-        throw new UserError(
-          `Invalid value for "${label}". Expected ${getExpectedNumberDescription(unwrappedSchema)}.`
-        );
-      }
-      return value;
-    case "boolean":
-      if (typeof value !== "boolean") {
-        throw new UserError(`Invalid value for "${label}". Expected a boolean.`);
-      }
-      return value;
-    case "enum":
-      return validateEnum(value, unwrappedSchema, label);
-    case "array":
-      if (!Array.isArray(value)) {
-        throw new UserError(`Invalid value for "${label}". Expected an array.`);
-      }
-      return value.map(
-        (item, index) => validateSchemaValue(unwrappedSchema.item, item, casing, `${label}[${index}]`)
-      );
-    case "object":
-      return validateObjectSchema(unwrappedSchema, value, casing, label);
-  }
-}
-function validateObjectSchema(schema, value, casing, label) {
-  if (!isPlainObject(value)) {
-    throw new UserError(`Invalid value for "${label}". Expected an object.`);
-  }
-  const result = {};
-  const expectedKeys = /* @__PURE__ */ new Map();
-  for (const [key, childSchema] of Object.entries(schema.shape)) {
-    expectedKeys.set(formatSegment(key, casing), [key, childSchema]);
-  }
-  for (const key of Object.keys(value)) {
-    if (!expectedKeys.has(key)) {
-      const fieldLabel = label.length === 0 ? key : `${label}.${key}`;
-      throw new UserError(`Unexpected parameter "${fieldLabel}".`);
-    }
-  }
-  for (const [inputKey, [outputKey, rawChildSchema]] of expectedKeys.entries()) {
-    const childSchema = unwrapOptional2(rawChildSchema);
-    const hasValue = Object.prototype.hasOwnProperty.call(value, inputKey);
-    const fieldLabel = label.length === 0 ? inputKey : `${label}.${inputKey}`;
-    if (!hasValue) {
-      if (childSchema.default !== void 0) {
-        result[outputKey] = childSchema.default;
-        continue;
-      }
-      if (isOptional(rawChildSchema)) {
-        continue;
-      }
-      throw new UserError(`Missing required parameter "${fieldLabel}".`);
-    }
-    result[outputKey] = validateSchemaValue(rawChildSchema, value[inputKey], casing, fieldLabel);
-  }
-  return result;
-}
-function validateToolArguments(schema, argumentsValue, casing) {
-  return validateObjectSchema(schema, argumentsValue ?? {}, casing, "");
-}
-function isContentBlock2(value) {
-  if (!isPlainObject(value) || typeof value.type !== "string") {
-    return false;
-  }
-  return value.type === "text" || value.type === "image" || value.type === "audio" || value.type === "resource";
-}
-function toToolContent(result) {
-  if (result === void 0) {
-    return [];
-  }
-  if (Array.isArray(result)) {
-    return result.flatMap((item) => toToolContent(item));
-  }
-  if (typeof result === "string" || typeof result === "number" || typeof result === "boolean") {
-    return [{ type: "text", text: String(result) }];
-  }
-  if (result === null) {
-    return [{ type: "text", text: "null" }];
-  }
-  if (isContentBlock2(result)) {
-    return [result];
-  }
-  return [{ type: "text", text: JSON.stringify(result) }];
-}
-function toToolError(error) {
-  if (error instanceof ToolError) {
-    return error;
-  }
-  if (error instanceof UserError) {
-    return new ToolError(JSON_RPC_ERROR_CODES.INVALID_PARAMS, error.message);
-  }
-  if (error instanceof Error) {
-    return new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, error.message);
-  }
-  return new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, String(error));
-}
-function createMCPServer(roots, options) {
-  const root = normalizeRoots(roots);
-  const casing = options.casing ?? "snake";
-  const services = options.services ?? {};
-  validateServices(services);
-  const tools = enumerateTools(root, casing, options.tools);
-  const server = createServer({ name: options.name, version: options.version });
-  for (const tool of tools) {
-    server.tool(
-      tool.name,
-      tool.description,
-      tool.inputSchema,
-      async (argumentsValue) => {
-        try {
-          const secrets = resolveCommandSecrets(tool.command);
-          const baseContext = {
-            ...services,
-            secrets,
-            fetch: globalThis.fetch,
-            fs: createFs(),
-            env: createEnv(),
-            progress() {
-              return void 0;
-            }
-          };
-          await assertCommandRequirements(tool.command, { ...baseContext, params: void 0 });
-          const params = validateToolArguments(tool.command.params, argumentsValue, casing);
-          const result = await tool.command.handler({
-            ...baseContext,
-            params
-          });
-          return toToolContent(result);
-        } catch (error) {
-          throw toToolError(error);
-        }
-      }
-    );
-  }
-  return {
-    ...server,
-    connect(transport) {
-      return server.connectSDK(transport);
-    }
-  };
-}
-async function runMCP(roots, options) {
-  const server = createMCPServer(roots, options);
-  await server.listen();
-}
-export {
-  createMCPServer,
-  runMCP
-};
-//# sourceMappingURL=mcp.js.map