@covro/covro 0.0.0-stage → 0.1.0-dev.1

package/dist/server/websocket.js

@@ -0,0 +1,126 @@
+import { socketMessageSchema } from "../shared/validation.js";
+import { AppError } from "../shared/errors.js";
+import { compactThreadForTransport } from "./snapshot.js";
+function sendBounded(socket, message, limit) {
+  if (socket.readyState !== 1) return;
+  let outgoing = message;
+  const budget = Math.max(512, Math.floor(limit / 2));
+  try {
+    if (message.type === "snapshot")
+      outgoing = { ...message, data: compactThreadForTransport(message.data, budget) };
+    else if (message.type === "event" && message.kind === "thread")
+      outgoing = {
+        ...message,
+        payload: compactThreadForTransport(message.payload, budget)
+      };
+  } catch (error) {
+    outgoing = {
+      type: "error",
+      error: error instanceof AppError ? error.toJSON() : {
+        code: "SNAPSHOT_TOO_LARGE",
+        message: "Current control state exceeds the configured limit"
+      }
+    };
+  }
+  const encoded = JSON.stringify(outgoing);
+  if (socket.bufferedAmount + Buffer.byteLength(encoded) > limit) {
+    socket.close(4008, "Slow connection; reconnect for snapshot");
+    socket.terminate?.();
+    return;
+  }
+  socket.send(encoded);
+}
+function socketHandlers(service, config, identity, overview = false) {
+  let unsubscribe;
+  let stopRuntime;
+  let stopOverview;
+  let generation = 0;
+  let expiry;
+  const send = (ws, message) => {
+    const raw = ws.raw;
+    sendBounded(
+      raw ?? {
+        readyState: ws.readyState,
+        bufferedAmount: 0,
+        send: (data) => ws.send(data),
+        close: (code, reason) => ws.close(code, reason)
+      },
+      message,
+      config.limits.wsBytes
+    );
+  };
+  return {
+    onOpen(_event, ws) {
+      stopRuntime = service.subscribeRuntime((message) => send(ws, message));
+      if (overview) stopOverview = service.subscribeOverview((message) => send(ws, message));
+      if (identity.expiresAt)
+        expiry = setTimeout(
+          () => ws.close(4001, "Authentication expired"),
+          Math.min(2147483647, Math.max(1, identity.expiresAt - Date.now()))
+        );
+    },
+    async onMessage(event, ws) {
+      const current = ++generation;
+      unsubscribe?.();
+      unsubscribe = void 0;
+      const deliver = (message) => {
+        if (current === generation && !(message.type === "event" && message.kind === "runtime"))
+          send(ws, message);
+      };
+      try {
+        if (typeof event.data !== "string" || Buffer.byteLength(event.data) > 8192)
+          throw new AppError("VALIDATION_FAILED", "Invalid subscription");
+        const input = socketMessageSchema.parse(JSON.parse(event.data));
+        if (input.type === "unsubscribe") return;
+        const stop = await service.subscribe(input.threadId, input.after, deliver);
+        if (current !== generation || ws.readyState !== 1) stop();
+        else unsubscribe = stop;
+      } catch (error) {
+        deliver({
+          type: "error",
+          error: error instanceof AppError ? error.toJSON() : { code: "VALIDATION_FAILED", message: "Invalid subscription" }
+        });
+      }
+    },
+    onClose() {
+      generation++;
+      unsubscribe?.();
+      stopRuntime?.();
+      stopOverview?.();
+      clearTimeout(expiry);
+    },
+    onError() {
+      generation++;
+      unsubscribe?.();
+      stopRuntime?.();
+      stopOverview?.();
+      clearTimeout(expiry);
+    }
+  };
+}
+function startHeartbeat(server) {
+  const alive = /* @__PURE__ */ new WeakSet();
+  server.on("connection", (ws) => {
+    alive.add(ws);
+    ws.on("pong", () => alive.add(ws));
+    ws.on("error", () => ws.terminate());
+  });
+  const timer = setInterval(() => {
+    for (const ws of server.clients) {
+      if (!alive.has(ws)) {
+        ws.terminate();
+        continue;
+      }
+      alive.delete(ws);
+      ws.ping();
+    }
+  }, 25e3);
+  timer.unref();
+  return () => clearInterval(timer);
+}
+export {
+  sendBounded,
+  socketHandlers,
+  startHeartbeat
+};
+//# sourceMappingURL=websocket.js.map

package/dist/server/websocket.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/server/websocket.ts"],
+  "sourcesContent": ["import type { WSEvents, WSContext } from 'hono/ws';\nimport type { WebSocketLike } from '@hono/node-server';\nimport type { WebSocketServer, WebSocket } from 'ws';\nimport { socketMessageSchema } from '../shared/validation.js';\nimport type { ServerMessage, ThreadView } from '../shared/types.js';\nimport { AppError } from '../shared/errors.js';\nimport type { GatewayService } from './service.js';\nimport type { AppConfig } from './config.js';\nimport type { Identity } from './auth.js';\nimport { compactThreadForTransport } from './snapshot.js';\n\nexport interface SocketSink {\n  readyState: number;\n  bufferedAmount: number;\n  send(data: string): void;\n  close(code: number, reason: string): void;\n  terminate?(): void;\n}\n/** Bounds both individual snapshots and queued bytes, including runtime broadcasts. */\nexport function sendBounded(socket: SocketSink, message: ServerMessage, limit: number): void {\n  if (socket.readyState !== 1) return;\n  let outgoing = message;\n  const budget = Math.max(512, Math.floor(limit / 2));\n  try {\n    if (message.type === 'snapshot')\n      outgoing = { ...message, data: compactThreadForTransport(message.data, budget) };\n    else if (message.type === 'event' && message.kind === 'thread')\n      outgoing = {\n        ...message,\n        payload: compactThreadForTransport(message.payload as ThreadView, budget),\n      };\n  } catch (error) {\n    outgoing = {\n      type: 'error',\n      error:\n        error instanceof AppError\n          ? error.toJSON()\n          : {\n              code: 'SNAPSHOT_TOO_LARGE',\n              message: 'Current control state exceeds the configured limit',\n            },\n    };\n  }\n  const encoded = JSON.stringify(outgoing);\n  if (socket.bufferedAmount + Buffer.byteLength(encoded) > limit) {\n    socket.close(4008, 'Slow connection; reconnect for snapshot');\n    socket.terminate?.();\n    return;\n  }\n  socket.send(encoded);\n}\nexport function socketHandlers(\n  service: GatewayService,\n  config: AppConfig,\n  identity: Identity,\n  overview = false,\n): WSEvents<WebSocketLike> {\n  let unsubscribe: (() => void) | undefined;\n  let stopRuntime: (() => void) | undefined;\n  let stopOverview: (() => void) | undefined;\n  let generation = 0;\n  let expiry: ReturnType<typeof setTimeout> | undefined;\n  const send = (ws: WSContext<WebSocketLike>, message: ServerMessage) => {\n    const raw = ws.raw as WebSocket | undefined;\n    sendBounded(\n      raw ?? {\n        readyState: ws.readyState,\n        bufferedAmount: 0,\n        send: (data) => ws.send(data),\n        close: (code, reason) => ws.close(code, reason),\n      },\n      message,\n      config.limits.wsBytes,\n    );\n  };\n  return {\n    onOpen(_event, ws) {\n      stopRuntime = service.subscribeRuntime((message) => send(ws, message));\n      if (overview) stopOverview = service.subscribeOverview((message) => send(ws, message));\n      if (identity.expiresAt)\n        expiry = setTimeout(\n          () => ws.close(4001, 'Authentication expired'),\n          Math.min(2_147_483_647, Math.max(1, identity.expiresAt - Date.now())),\n        );\n    },\n    async onMessage(event, ws) {\n      const current = ++generation;\n      unsubscribe?.();\n      unsubscribe = undefined;\n      const deliver = (message: ServerMessage) => {\n        if (current === generation && !(message.type === 'event' && message.kind === 'runtime'))\n          send(ws, message);\n      };\n      try {\n        if (typeof event.data !== 'string' || Buffer.byteLength(event.data) > 8192)\n          throw new AppError('VALIDATION_FAILED', 'Invalid subscription');\n        const input = socketMessageSchema.parse(JSON.parse(event.data));\n        if (input.type === 'unsubscribe') return;\n        const stop = await service.subscribe(input.threadId, input.after, deliver);\n        if (current !== generation || ws.readyState !== 1) stop();\n        else unsubscribe = stop;\n      } catch (error) {\n        deliver({\n          type: 'error',\n          error:\n            error instanceof AppError\n              ? error.toJSON()\n              : { code: 'VALIDATION_FAILED', message: 'Invalid subscription' },\n        });\n      }\n    },\n    onClose() {\n      generation++;\n      unsubscribe?.();\n      stopRuntime?.();\n      stopOverview?.();\n      clearTimeout(expiry);\n    },\n    onError() {\n      generation++;\n      unsubscribe?.();\n      stopRuntime?.();\n      stopOverview?.();\n      clearTimeout(expiry);\n    },\n  };\n}\nexport function startHeartbeat(server: WebSocketServer): () => void {\n  const alive = new WeakSet<WebSocket>();\n  server.on('connection', (ws) => {\n    alive.add(ws);\n    ws.on('pong', () => alive.add(ws));\n    ws.on('error', () => ws.terminate());\n  });\n  const timer = setInterval(() => {\n    for (const ws of server.clients) {\n      if (!alive.has(ws)) {\n        ws.terminate();\n        continue;\n      }\n      alive.delete(ws);\n      ws.ping();\n    }\n  }, 25_000);\n  timer.unref();\n  return () => clearInterval(timer);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/shared/async-questions.js

@@ -0,0 +1,39 @@
+const opening = "<send_user_message_question_reply>";
+const closing = "</send_user_message_question_reply>";
+function asyncQuestionId(itemId, index) {
+  return JSON.stringify(["request_user_input_async", itemId, index]);
+}
+function encodeQuestionReplies(replies) {
+  return `${opening}${JSON.stringify(replies)}${closing}`;
+}
+function parseQuestionReplies(text) {
+  let content = text.trim();
+  if (content.startsWith("# Context from my IDE setup:\n")) {
+    const delimiter = "\n## My request for Codex:\n";
+    const index = content.lastIndexOf(delimiter);
+    if (index < 0) return;
+    content = content.slice(index + delimiter.length).trim();
+  }
+  if (!content.startsWith(opening) || !content.endsWith(closing)) return;
+  try {
+    const parsed = JSON.parse(content.slice(opening.length, -closing.length));
+    const replies = Array.isArray(parsed) ? parsed : [parsed];
+    if (!replies.length || !replies.every(
+      (reply) => typeof reply === "object" && reply !== null && "questionItemId" in reply && typeof reply.questionItemId === "string" && Boolean(reply.questionItemId.trim()) && "question" in reply && typeof reply.question === "string" && "answer" in reply && typeof reply.answer === "string"
+    ))
+      return;
+    return replies.map(({ questionItemId, question, answer }) => ({
+      questionItemId,
+      question,
+      answer
+    }));
+  } catch {
+    return;
+  }
+}
+export {
+  asyncQuestionId,
+  encodeQuestionReplies,
+  parseQuestionReplies
+};
+//# sourceMappingURL=async-questions.js.map

package/dist/shared/async-questions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shared/async-questions.ts"],
+  "sourcesContent": ["import type { AsyncQuestionReply } from './types.js';\n\n// The native desktop/CLI envelope correlates ordinary user messages with async questions.\nconst opening = '<send_user_message_question_reply>';\nconst closing = '</send_user_message_question_reply>';\n\nexport function asyncQuestionId(itemId: string, index: number): string {\n  return JSON.stringify(['request_user_input_async', itemId, index]);\n}\n\nexport function encodeQuestionReplies(replies: AsyncQuestionReply[]): string {\n  return `${opening}${JSON.stringify(replies)}${closing}`;\n}\n\nexport function parseQuestionReplies(text: string): AsyncQuestionReply[] | undefined {\n  let content = text.trim();\n  if (content.startsWith('# Context from my IDE setup:\\n')) {\n    const delimiter = '\\n## My request for Codex:\\n';\n    const index = content.lastIndexOf(delimiter);\n    if (index < 0) return;\n    content = content.slice(index + delimiter.length).trim();\n  }\n  if (!content.startsWith(opening) || !content.endsWith(closing)) return;\n  try {\n    const parsed: unknown = JSON.parse(content.slice(opening.length, -closing.length));\n    const replies: unknown[] = Array.isArray(parsed) ? parsed : [parsed];\n    if (\n      !replies.length ||\n      !replies.every(\n        (reply): reply is AsyncQuestionReply =>\n          typeof reply === 'object' &&\n          reply !== null &&\n          'questionItemId' in reply &&\n          typeof reply.questionItemId === 'string' &&\n          Boolean(reply.questionItemId.trim()) &&\n          'question' in reply &&\n          typeof reply.question === 'string' &&\n          'answer' in reply &&\n          typeof reply.answer === 'string',\n      )\n    )\n      return;\n    return replies.map(({ questionItemId, question, answer }) => ({\n      questionItemId,\n      question,\n      answer,\n    }));\n  } catch {\n    return;\n  }\n}\n"],
+  "mappings": "AAGA,MAAM,UAAU;AAChB,MAAM,UAAU;AAET,SAAS,gBAAgB,QAAgB,OAAuB;AACrE,SAAO,KAAK,UAAU,CAAC,4BAA4B,QAAQ,KAAK,CAAC;AACnE;AAEO,SAAS,sBAAsB,SAAuC;AAC3E,SAAO,GAAG,OAAO,GAAG,KAAK,UAAU,OAAO,CAAC,GAAG,OAAO;AACvD;AAEO,SAAS,qBAAqB,MAAgD;AACnF,MAAI,UAAU,KAAK,KAAK;AACxB,MAAI,QAAQ,WAAW,gCAAgC,GAAG;AACxD,UAAM,YAAY;AAClB,UAAM,QAAQ,QAAQ,YAAY,SAAS;AAC3C,QAAI,QAAQ,EAAG;AACf,cAAU,QAAQ,MAAM,QAAQ,UAAU,MAAM,EAAE,KAAK;AAAA,EACzD;AACA,MAAI,CAAC,QAAQ,WAAW,OAAO,KAAK,CAAC,QAAQ,SAAS,OAAO,EAAG;AAChE,MAAI;AACF,UAAM,SAAkB,KAAK,MAAM,QAAQ,MAAM,QAAQ,QAAQ,CAAC,QAAQ,MAAM,CAAC;AACjF,UAAM,UAAqB,MAAM,QAAQ,MAAM,IAAI,SAAS,CAAC,MAAM;AACnE,QACE,CAAC,QAAQ,UACT,CAAC,QAAQ;AAAA,MACP,CAAC,UACC,OAAO,UAAU,YACjB,UAAU,QACV,oBAAoB,SACpB,OAAO,MAAM,mBAAmB,YAChC,QAAQ,MAAM,eAAe,KAAK,CAAC,KACnC,cAAc,SACd,OAAO,MAAM,aAAa,YAC1B,YAAY,SACZ,OAAO,MAAM,WAAW;AAAA,IAC5B;AAEA;AACF,WAAO,QAAQ,IAAI,CAAC,EAAE,gBAAgB,UAAU,OAAO,OAAO;AAAA,MAC5D;AAAA,MACA;AAAA,MACA;AAAA,IACF,EAAE;AAAA,EACJ,QAAQ;AACN;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/shared/codex-compatibility.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { validVersion } from "./versions.js";
+const version = z.string().max(128).refine(validVersion);
+const codexCompatibilitySchema = z.object({
+  recommended: version,
+  verified: z.array(version).min(1).max(100),
+  unsupported: z.array(z.object({ version, reason: z.string().min(1).max(500) }).strict()).max(100)
+}).strict().refine((value) => value.verified.includes(value.recommended), "Recommended must be verified").refine(
+  (value) => !value.unsupported.some((entry) => value.verified.includes(entry.version)),
+  "Verified and unsupported versions must not overlap"
+);
+function assessCodexCompatibility(metadata, running) {
+  const parsed = codexCompatibilitySchema.safeParse(metadata);
+  if (!parsed.success)
+    return {
+      version: running,
+      status: "unknown",
+      reason: "\u76EE\u6807\u5305\u7F3A\u5C11\u6709\u6548\u7684 Codex \u517C\u5BB9\u58F0\u660E\uFF0C\u65E0\u6CD5\u5347\u7EA7\u3002"
+    };
+  const manifest = parsed.data;
+  if (!running || !validVersion(running))
+    return {
+      version: running,
+      manifest,
+      status: "unknown",
+      reason: "\u65E0\u6CD5\u786E\u8BA4\u5F53\u524D Codex CLI \u7248\u672C\uFF0C\u8BF7\u5148\u6062\u590D Codex \u8FDE\u63A5\u540E\u91CD\u65B0\u68C0\u67E5\u3002"
+    };
+  const unsupported = manifest.unsupported.find((entry) => entry.version === running);
+  if (unsupported)
+    return {
+      version: running,
+      manifest,
+      status: "unsupported",
+      reason: `\u76EE\u6807\u7248\u672C\u4E0D\u652F\u6301 Codex ${running}\uFF1A${unsupported.reason}`
+    };
+  if (manifest.verified.includes(running))
+    return { version: running, manifest, status: "verified" };
+  return {
+    version: running,
+    manifest,
+    status: "unverified",
+    reason: `\u5F53\u524D Codex ${running} \u4E0E\u76EE\u6807 Covro \u7684\u7EC4\u5408\u5C1A\u672A\u9A8C\u8BC1\uFF1B\u81EA\u52A8\u5347\u7EA7\u5DF2\u6682\u505C\u3002`
+  };
+}
+function requireCodexCompatibility(metadata, running, confirmed = false) {
+  const result = assessCodexCompatibility(metadata, running);
+  if (result.status !== "verified" && !(confirmed && result.status === "unverified"))
+    throw new Error(result.reason);
+  return result;
+}
+export {
+  assessCodexCompatibility,
+  codexCompatibilitySchema,
+  requireCodexCompatibility
+};
+//# sourceMappingURL=codex-compatibility.js.map

package/dist/shared/codex-compatibility.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shared/codex-compatibility.ts"],
+  "sourcesContent": ["import { z } from 'zod';\nimport { validVersion } from './versions.js';\n\nconst version = z.string().max(128).refine(validVersion);\nexport const codexCompatibilitySchema = z\n  .object({\n    recommended: version,\n    verified: z.array(version).min(1).max(100),\n    unsupported: z\n      .array(z.object({ version, reason: z.string().min(1).max(500) }).strict())\n      .max(100),\n  })\n  .strict()\n  .refine((value) => value.verified.includes(value.recommended), 'Recommended must be verified')\n  .refine(\n    (value) => !value.unsupported.some((entry) => value.verified.includes(entry.version)),\n    'Verified and unsupported versions must not overlap',\n  );\nexport type CodexCompatibilityManifest = z.infer<typeof codexCompatibilitySchema>;\nexport interface CodexCompatibility {\n  version: string | null;\n  status: 'verified' | 'unverified' | 'unsupported' | 'unknown';\n  manifest?: CodexCompatibilityManifest;\n  reason?: string;\n}\nexport interface CodexUpdateConfirmation {\n  version: string;\n  target: string;\n}\nexport function assessCodexCompatibility(\n  metadata: unknown,\n  running: string | null,\n): CodexCompatibility {\n  const parsed = codexCompatibilitySchema.safeParse(metadata);\n  if (!parsed.success)\n    return {\n      version: running,\n      status: 'unknown',\n      reason: '\u76EE\u6807\u5305\u7F3A\u5C11\u6709\u6548\u7684 Codex \u517C\u5BB9\u58F0\u660E\uFF0C\u65E0\u6CD5\u5347\u7EA7\u3002',\n    };\n  const manifest = parsed.data;\n  if (!running || !validVersion(running))\n    return {\n      version: running,\n      manifest,\n      status: 'unknown',\n      reason: '\u65E0\u6CD5\u786E\u8BA4\u5F53\u524D Codex CLI \u7248\u672C\uFF0C\u8BF7\u5148\u6062\u590D Codex \u8FDE\u63A5\u540E\u91CD\u65B0\u68C0\u67E5\u3002',\n    };\n  const unsupported = manifest.unsupported.find((entry) => entry.version === running);\n  if (unsupported)\n    return {\n      version: running,\n      manifest,\n      status: 'unsupported',\n      reason: `\u76EE\u6807\u7248\u672C\u4E0D\u652F\u6301 Codex ${running}\uFF1A${unsupported.reason}`,\n    };\n  if (manifest.verified.includes(running))\n    return { version: running, manifest, status: 'verified' };\n  return {\n    version: running,\n    manifest,\n    status: 'unverified',\n    reason: `\u5F53\u524D Codex ${running} \u4E0E\u76EE\u6807 Covro \u7684\u7EC4\u5408\u5C1A\u672A\u9A8C\u8BC1\uFF1B\u81EA\u52A8\u5347\u7EA7\u5DF2\u6682\u505C\u3002`,\n  };\n}\nexport function requireCodexCompatibility(\n  metadata: unknown,\n  running: string | null,\n  confirmed = false,\n) {\n  const result = assessCodexCompatibility(metadata, running);\n  if (result.status !== 'verified' && !(confirmed && result.status === 'unverified'))\n    throw new Error(result.reason);\n  return result;\n}\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAClB,SAAS,oBAAoB;AAE7B,MAAM,UAAU,EAAE,OAAO,EAAE,IAAI,GAAG,EAAE,OAAO,YAAY;AAChD,MAAM,2BAA2B,EACrC,OAAO;AAAA,EACN,aAAa;AAAA,EACb,UAAU,EAAE,MAAM,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EACzC,aAAa,EACV,MAAM,EAAE,OAAO,EAAE,SAAS,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,EAAE,CAAC,EAAE,OAAO,CAAC,EACxE,IAAI,GAAG;AACZ,CAAC,EACA,OAAO,EACP,OAAO,CAAC,UAAU,MAAM,SAAS,SAAS,MAAM,WAAW,GAAG,8BAA8B,EAC5F;AAAA,EACC,CAAC,UAAU,CAAC,MAAM,YAAY,KAAK,CAAC,UAAU,MAAM,SAAS,SAAS,MAAM,OAAO,CAAC;AAAA,EACpF;AACF;AAYK,SAAS,yBACd,UACA,SACoB;AACpB,QAAM,SAAS,yBAAyB,UAAU,QAAQ;AAC1D,MAAI,CAAC,OAAO;AACV,WAAO;AAAA,MACL,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,QAAQ;AAAA,IACV;AACF,QAAM,WAAW,OAAO;AACxB,MAAI,CAAC,WAAW,CAAC,aAAa,OAAO;AACnC,WAAO;AAAA,MACL,SAAS;AAAA,MACT;AAAA,MACA,QAAQ;AAAA,MACR,QAAQ;AAAA,IACV;AACF,QAAM,cAAc,SAAS,YAAY,KAAK,CAAC,UAAU,MAAM,YAAY,OAAO;AAClF,MAAI;AACF,WAAO;AAAA,MACL,SAAS;AAAA,MACT;AAAA,MACA,QAAQ;AAAA,MACR,QAAQ,oDAAiB,OAAO,SAAI,YAAY,MAAM;AAAA,IACxD;AACF,MAAI,SAAS,SAAS,SAAS,OAAO;AACpC,WAAO,EAAE,SAAS,SAAS,UAAU,QAAQ,WAAW;AAC1D,SAAO;AAAA,IACL,SAAS;AAAA,IACT;AAAA,IACA,QAAQ;AAAA,IACR,QAAQ,sBAAY,OAAO;AAAA,EAC7B;AACF;AACO,SAAS,0BACd,UACA,SACA,YAAY,OACZ;AACA,QAAM,SAAS,yBAAyB,UAAU,OAAO;AACzD,MAAI,OAAO,WAAW,cAAc,EAAE,aAAa,OAAO,WAAW;AACnE,UAAM,IAAI,MAAM,OAAO,MAAM;AAC/B,SAAO;AACT;",
+  "names": []
+}

package/dist/shared/elicitation.js

@@ -0,0 +1,314 @@
+import { AppError } from "./errors.js";
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const has = (value, key) => Object.hasOwn(value, key);
+const fail = (message) => {
+  throw new AppError("VALIDATION_ERROR", message);
+};
+function onlyKeys(value, keys, context) {
+  const unknown = Object.keys(value).find((key) => !keys.includes(key));
+  if (unknown !== void 0) fail(`${context}\u5305\u542B\u5C1A\u4E0D\u652F\u6301\u7684\u7EA6\u675F\uFF1A${unknown}`);
+}
+function optionalText(value, key) {
+  if (!has(value, key)) return void 0;
+  if (typeof value[key] !== "string") fail(`${key} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  return value[key];
+}
+function limit(value, key, integer) {
+  if (!has(value, key)) return void 0;
+  const number = value[key];
+  if (typeof number !== "number" || !Number.isFinite(number) || integer && (!Number.isSafeInteger(number) || number < 0))
+    fail(`${key} \u4E0D\u662F\u6709\u6548\u7684${integer ? "\u975E\u8D1F\u6574\u6570" : "\u6570\u503C"}`);
+  return number;
+}
+function enumOptions(schema, variant = "oneOf") {
+  let options;
+  if (has(schema, "enum")) {
+    const values = schema.enum;
+    if (!Array.isArray(values) || values.some((value) => typeof value !== "string"))
+      fail("\u679A\u4E3E\u9009\u9879\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u5217\u8868");
+    const names = schema.enumNames;
+    if (names !== void 0 && (!Array.isArray(names) || names.length !== values.length || names.some((name) => typeof name !== "string")))
+      fail("\u679A\u4E3E\u6807\u9898\u5FC5\u987B\u4E0E\u9009\u9879\u4E00\u4E00\u5BF9\u5E94");
+    if (has(schema, variant)) fail("\u4E0D\u80FD\u540C\u65F6\u63D0\u4F9B\u591A\u79CD\u679A\u4E3E\u7EA6\u675F");
+    options = values.map((value, index) => ({
+      value,
+      label: names?.[index] ?? value
+    }));
+  } else {
+    if (has(schema, "enumNames")) fail("\u679A\u4E3E\u6807\u9898\u7F3A\u5C11 enum \u9009\u9879");
+    const values = schema[variant];
+    if (!Array.isArray(values)) fail("\u7F3A\u5C11\u53EF\u7528\u7684\u679A\u4E3E\u9009\u9879");
+    options = values.map((value) => {
+      if (!record(value)) fail("\u679A\u4E3E\u9009\u9879\u683C\u5F0F\u4E0D\u53D7\u652F\u6301");
+      const option = value;
+      onlyKeys(option, ["const", "title", "description", "type"], "\u679A\u4E3E\u9009\u9879");
+      if (typeof option.const !== "string" || has(option, "type") && option.type !== "string")
+        fail("\u4EC5\u652F\u6301\u5B57\u7B26\u4E32\u679A\u4E3E\u9009\u9879");
+      optionalText(option, "description");
+      return {
+        value: option.const,
+        label: optionalText(option, "title") ?? String(option.const)
+      };
+    });
+  }
+  if (!options.length || new Set(options.map((option) => option.value)).size !== options.length)
+    fail("\u679A\u4E3E\u9009\u9879\u4E0D\u80FD\u4E3A\u7A7A\u6216\u91CD\u590D");
+  if (options.some((option) => option.value.length > 1e4)) fail("\u679A\u4E3E\u503C\u8D85\u8FC7\u53EF\u63D0\u4EA4\u7684\u957F\u5EA6\u4E0A\u9650");
+  return options;
+}
+function dateValid(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+  const date = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+function formatValid(format, value) {
+  switch (format) {
+    case "email":
+      return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+    case "uri":
+      try {
+        return !/\s/.test(value) && Boolean(new URL(value).protocol);
+      } catch {
+        return false;
+      }
+    case "date":
+      return dateValid(value);
+    case "date-time": {
+      const match = /^(\d{4}-\d{2}-\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:[Zz]|[+-](\d{2}):(\d{2}))$/.exec(
+        value
+      );
+      return Boolean(
+        match && dateValid(match[1]) && Number(match[2]) <= 23 && Number(match[3]) <= 59 && Number(match[4]) <= 59 && (match[5] === void 0 || Number(match[5]) <= 23) && (match[6] === void 0 || Number(match[6]) <= 59) && Number.isFinite(Date.parse(value))
+      );
+    }
+    default:
+      return true;
+  }
+}
+function validateElicitationFieldValue(field, value) {
+  const invalid = () => fail(`\u201C${field.title}\u201D\u7684\u56DE\u7B54\u4E0D\u7B26\u5408\u5B57\u6BB5\u8981\u6C42`);
+  switch (field.type) {
+    case "string":
+      if (typeof value !== "string") invalid();
+      else {
+        const length = [...value].length;
+        if (field.minLength !== void 0 && length < field.minLength || field.maxLength !== void 0 && length > field.maxLength || value.length > 1e4 || !formatValid(field.format, value))
+          invalid();
+      }
+      break;
+    case "number":
+    case "integer":
+      if (typeof value !== "number" || !Number.isFinite(value) || field.type === "integer" && !Number.isSafeInteger(value) || field.minimum !== void 0 && value < field.minimum || field.maximum !== void 0 && value > field.maximum)
+        invalid();
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") invalid();
+      break;
+    case "enum":
+      if (typeof value !== "string" || value.length > 1e4 || !field.options?.some((option) => option.value === value))
+        invalid();
+      break;
+    case "multiEnum":
+      if (!Array.isArray(value) || value.some(
+        (item) => typeof item !== "string" || item.length > 1e4 || !field.options?.some((option) => option.value === item)
+      ) || value.length > 500 || new Set(value).size !== value.length || field.minItems !== void 0 && value.length < field.minItems || field.maxItems !== void 0 && value.length > field.maxItems)
+        invalid();
+      break;
+  }
+}
+function normalizeField(name, value, required) {
+  if (name === "__proto__") fail("\u5B57\u6BB5\u540D\u79F0 __proto__ \u4E0D\u53D7\u5F53\u524D\u8868\u5355\u4F20\u8F93\u652F\u6301");
+  if (name.length > 1e3) fail("\u5B57\u6BB5\u540D\u79F0\u8D85\u8FC7\u53EF\u63D0\u4EA4\u7684\u957F\u5EA6\u4E0A\u9650");
+  if (!record(value)) fail(`\u5B57\u6BB5 ${name} \u7684\u5B9A\u4E49\u683C\u5F0F\u4E0D\u53D7\u652F\u6301`);
+  const schema = value;
+  const commonKeys = ["type", "title", "description", "default"];
+  const field = {
+    name,
+    title: optionalText(schema, "title") ?? name,
+    description: optionalText(schema, "description"),
+    required,
+    type: "string"
+  };
+  switch (schema.type) {
+    case "string":
+      if (has(schema, "enum") || has(schema, "oneOf") || has(schema, "enumNames")) {
+        onlyKeys(schema, [...commonKeys, "enum", "enumNames", "oneOf"], `\u5B57\u6BB5 ${name}`);
+        field.type = "enum";
+        field.options = enumOptions(schema);
+      } else {
+        onlyKeys(schema, [...commonKeys, "minLength", "maxLength", "format"], `\u5B57\u6BB5 ${name}`);
+        field.minLength = limit(schema, "minLength", true);
+        field.maxLength = limit(schema, "maxLength", true);
+        if (field.minLength !== void 0 && field.minLength > 1e4)
+          fail(`\u5B57\u6BB5 ${name} \u7684\u6700\u5C0F\u957F\u5EA6\u8D85\u8FC7\u53EF\u63D0\u4EA4\u7684\u957F\u5EA6\u4E0A\u9650`);
+        if (field.minLength !== void 0 && field.maxLength !== void 0 && field.minLength > field.maxLength)
+          fail(`\u5B57\u6BB5 ${name} \u7684\u957F\u5EA6\u8303\u56F4\u65E0\u6548`);
+        if (has(schema, "format")) {
+          if (!["email", "uri", "date", "date-time"].includes(String(schema.format)))
+            fail(`\u5B57\u6BB5 ${name} \u7684 format \u4E0D\u53D7\u652F\u6301`);
+          field.format = schema.format;
+        }
+      }
+      break;
+    case "number":
+    case "integer":
+      onlyKeys(schema, [...commonKeys, "minimum", "maximum"], `\u5B57\u6BB5 ${name}`);
+      field.type = schema.type;
+      field.minimum = limit(schema, "minimum", false);
+      field.maximum = limit(schema, "maximum", false);
+      if (field.minimum !== void 0 && field.maximum !== void 0 && field.minimum > field.maximum)
+        fail(`\u5B57\u6BB5 ${name} \u7684\u6570\u503C\u8303\u56F4\u65E0\u6548`);
+      break;
+    case "boolean":
+      onlyKeys(schema, commonKeys, `\u5B57\u6BB5 ${name}`);
+      field.type = "boolean";
+      break;
+    case "array": {
+      onlyKeys(
+        schema,
+        [...commonKeys, "items", "minItems", "maxItems", "uniqueItems"],
+        `\u5B57\u6BB5 ${name}`
+      );
+      if (has(schema, "uniqueItems") && schema.uniqueItems !== true)
+        fail(`\u5B57\u6BB5 ${name} \u4EC5\u652F\u6301\u4E0D\u91CD\u590D\u7684\u591A\u9009\u9879`);
+      if (!record(schema.items)) fail(`\u5B57\u6BB5 ${name} \u7F3A\u5C11\u6709\u6548\u7684\u591A\u9009\u9879`);
+      const items = schema.items;
+      onlyKeys(items, ["type", "enum", "enumNames", "anyOf"], `\u5B57\u6BB5 ${name} \u7684\u591A\u9009\u9879`);
+      if (has(items, "type") && items.type !== "string") fail(`\u5B57\u6BB5 ${name} \u4EC5\u652F\u6301\u5B57\u7B26\u4E32\u591A\u9009\u9879`);
+      field.type = "multiEnum";
+      field.options = enumOptions(items, "anyOf");
+      field.minItems = limit(schema, "minItems", true);
+      field.maxItems = limit(schema, "maxItems", true);
+      if (field.minItems !== void 0 && field.minItems > 500)
+        fail(`\u5B57\u6BB5 ${name} \u7684\u6700\u5C11\u9009\u9879\u6570\u8D85\u8FC7\u53EF\u63D0\u4EA4\u7684\u6570\u91CF\u4E0A\u9650`);
+      if (field.minItems !== void 0 && field.maxItems !== void 0 && field.minItems > field.maxItems)
+        fail(`\u5B57\u6BB5 ${name} \u7684\u9009\u9879\u6570\u91CF\u8303\u56F4\u65E0\u6548`);
+      break;
+    }
+    default:
+      fail(`\u5B57\u6BB5 ${name} \u7684\u7C7B\u578B\u4E0D\u53D7\u652F\u6301\uFF1A${String(schema.type)}`);
+  }
+  if (has(schema, "default")) {
+    validateElicitationFieldValue(field, schema.default);
+    field.default = schema.default;
+  }
+  return field;
+}
+function normalizeElicitationSchema(schema) {
+  try {
+    if (!record(schema)) fail("\u8868\u5355\u7ED3\u6784\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+    const root = schema;
+    onlyKeys(
+      root,
+      ["$schema", "type", "title", "description", "properties", "required", "additionalProperties"],
+      "\u8868\u5355"
+    );
+    if (root.type !== "object" || !record(root.properties))
+      fail("\u4EC5\u652F\u6301\u5305\u542B properties \u7684\u6241\u5E73\u5BF9\u8C61\u8868\u5355");
+    optionalText(root, "$schema");
+    optionalText(root, "title");
+    optionalText(root, "description");
+    if (has(root, "additionalProperties") && typeof root.additionalProperties !== "boolean")
+      fail("additionalProperties \u7EA6\u675F\u4E0D\u53D7\u652F\u6301");
+    const properties = root.properties;
+    const required = has(root, "required") ? root.required : [];
+    if (!Array.isArray(required) || required.some((name) => typeof name !== "string" || !has(properties, name)) || new Set(required).size !== required.length)
+      fail("\u5FC5\u586B\u5B57\u6BB5\u5FC5\u987B\u5B58\u5728\u4E8E\u8868\u5355\u4E2D");
+    return {
+      fields: Object.entries(properties).map(
+        ([name, value]) => normalizeField(name, value, required.includes(name))
+      )
+    };
+  } catch (error) {
+    return { fields: [], schemaError: error instanceof Error ? error.message : "\u8868\u5355\u7ED3\u6784\u4E0D\u53D7\u652F\u6301" };
+  }
+}
+function normalizeElicitationRequest(params) {
+  const base = { serverName: typeof params.serverName === "string" ? params.serverName : "MCP" };
+  if (params.mode === "url") {
+    const url = typeof params.url === "string" ? params.url : "";
+    try {
+      const parsed = new URL(url);
+      if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password)
+        throw new Error("unsupported URL");
+      return { ...base, mode: "url", url };
+    } catch {
+      return {
+        ...base,
+        mode: "url",
+        url,
+        schemaError: "\u6B64\u8BF7\u6C42\u7684\u94FE\u63A5\u65E0\u6548\uFF1B\u4EC5\u652F\u6301 HTTP \u6216 HTTPS \u94FE\u63A5"
+      };
+    }
+  }
+  if (["form", "openai/form", "openaiForm"].includes(String(params.mode))) {
+    const schema = params.requestedSchema;
+    const form = schema === null ? { fields: [] } : normalizeElicitationSchema(schema);
+    const meta = record(params._meta) ? params._meta : void 0;
+    const allowSession = meta?.persist === "session" || Array.isArray(meta?.persist) && meta.persist.includes("session");
+    const approval = !form.schemaError && form.fields?.length === 0 && (meta?.codex_approval_kind === "mcp_tool_call" || allowSession) ? { allowSession } : void 0;
+    return { ...base, mode: "form", ...form, ...approval ? { approval } : {} };
+  }
+  return {
+    ...base,
+    mode: "form",
+    fields: [],
+    schemaError: `\u5C1A\u4E0D\u652F\u6301\u7684\u4EA4\u4E92\u6A21\u5F0F\uFF1A${String(params.mode)}`
+  };
+}
+function validateElicitationResolution(request, resolution) {
+  if (!record(resolution)) fail("\u8BF7\u63D0\u4EA4\u6709\u6548\u7684\u4EA4\u4E92\u56DE\u7B54");
+  onlyKeys(resolution, ["decision", "content", "persist"], "\u4EA4\u4E92\u56DE\u7B54");
+  if (!("decision" in resolution) || !["accept", "decline", "cancel"].includes(resolution.decision))
+    fail("\u6B64\u8BF7\u6C42\u4E0D\u652F\u6301\u6240\u63D0\u4EA4\u7684\u51B3\u5B9A");
+  const answer = resolution;
+  if (has(answer, "persist") && (answer.persist !== "session" || answer.decision !== "accept" || request?.mode !== "form" || !request.approval?.allowSession))
+    fail("\u6B64\u8BF7\u6C42\u4E0D\u652F\u6301\u6240\u9009\u6388\u6743\u8303\u56F4");
+  if (answer.decision !== "accept") {
+    if (has(answer, "content")) fail("\u62D2\u7EDD\u6216\u53D6\u6D88\u65F6\u4E0D\u80FD\u63D0\u4EA4\u8868\u5355\u5185\u5BB9");
+    return null;
+  }
+  if (!request || request.schemaError) fail(request?.schemaError ?? "\u4EA4\u4E92\u8BF7\u6C42\u7F3A\u5C11\u8868\u5355\u4FE1\u606F");
+  const elicitation = request;
+  if (elicitation.approval) {
+    if (has(answer, "content")) fail("\u5DE5\u5177\u5BA1\u6279\u4E0D\u80FD\u63D0\u4EA4\u8868\u5355\u5185\u5BB9");
+    return null;
+  }
+  if (elicitation.mode === "url") {
+    const checked = normalizeElicitationRequest({
+      mode: "url",
+      serverName: elicitation.serverName,
+      url: elicitation.url
+    });
+    if (checked.schemaError) fail(checked.schemaError);
+    if (has(answer, "content")) fail("\u94FE\u63A5\u786E\u8BA4\u4E0D\u80FD\u63D0\u4EA4\u8868\u5355\u5185\u5BB9");
+    return null;
+  }
+  if (!record(answer.content)) fail("\u8BF7\u63D0\u4EA4\u7ED3\u6784\u5316\u7684\u8868\u5355\u56DE\u7B54");
+  const content = answer.content;
+  if (!Array.isArray(elicitation.fields)) fail("\u4EA4\u4E92\u8BF7\u6C42\u7F3A\u5C11\u8868\u5355\u5B57\u6BB5");
+  const fields = elicitation.fields;
+  if (Object.keys(content).some((name) => !fields.some((field) => field.name === name)))
+    fail("\u56DE\u7B54\u5305\u542B\u672A\u77E5\u5B57\u6BB5");
+  for (const field of fields) {
+    if (!has(content, field.name)) {
+      if (field.required) fail(`\u8BF7\u586B\u5199\u201C${field.title}\u201D`);
+    } else validateElicitationFieldValue(field, content[field.name]);
+  }
+  return structuredClone(content);
+}
+function validatePermissionResolution(resolution) {
+  if (!record(resolution)) fail("\u8BF7\u63D0\u4EA4\u6709\u6548\u7684\u6743\u9650\u51B3\u5B9A");
+  onlyKeys(resolution, ["decision"], "\u6743\u9650\u56DE\u7B54");
+  if (!("decision" in resolution) || !["accept", "acceptForSession", "decline"].includes(resolution.decision))
+    fail("\u8BF7\u9009\u62E9\u5F53\u524D\u4EFB\u52A1\u5141\u8BB8\u3001\u4F1A\u8BDD\u5141\u8BB8\u6216\u62D2\u7EDD");
+  return resolution.decision;
+}
+export {
+  normalizeElicitationRequest,
+  normalizeElicitationSchema,
+  validateElicitationFieldValue,
+  validateElicitationResolution,
+  validatePermissionResolution
+};
+//# sourceMappingURL=elicitation.js.map