lark-agent-bridge 0.1.39

package/dist/agent/cursor/cursor-sdk-worker.js

@@ -0,0 +1,702 @@
+// src/agent/cursor/sdk-worker.ts
+import { Agent } from "@cursor/sdk";
+
+// src/agent/cursor/sdk-error.ts
+import { CursorAgentError } from "@cursor/sdk";
+var AUTH_HINT = 'Cursor \u9700\u8981 API Key\uFF1A\u5728 config.json \u914D\u7F6E preferences.agentCursorApiKey\uFF08\u63A8\u8350\u52A0\u5BC6\uFF1Alark-agent-bridge secrets set --id cursor-api-key\uFF09\uFF0C\u6216 export CURSOR_API_KEY\uFF1B\u4E5F\u53EF\u5C06 agentCursorRuntime \u8BBE\u4E3A "cli" \u4EE5\u4F7F\u7528 `agent login` \u4F1A\u8BDD\u3002';
+function getCause(err) {
+  if (!err || typeof err !== "object") return void 0;
+  if ("cause" in err && err.cause !== err) {
+    return err.cause;
+  }
+  return void 0;
+}
+function errorName(err) {
+  if (!err || typeof err !== "object") return "Error";
+  if ("name" in err && typeof err.name === "string") {
+    return err.name;
+  }
+  return "Error";
+}
+function errorMessage(err) {
+  if (err instanceof Error) return err.message || err.name;
+  if (typeof err === "string") return err;
+  return String(err);
+}
+function errorCode(err) {
+  if (!err || typeof err !== "object") return void 0;
+  if ("code" in err) {
+    const code = err.code;
+    if (typeof code === "string" || typeof code === "number") return code;
+  }
+  return void 0;
+}
+function connectRawMessage(err) {
+  if (!err || typeof err !== "object" || !("rawMessage" in err)) return void 0;
+  const raw = err.rawMessage;
+  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+function sdkExtras(err) {
+  if (!(err instanceof CursorAgentError)) return [];
+  const parts = [];
+  if (err.code) parts.push(`code=${err.code}`);
+  if (err.status !== void 0) parts.push(`status=${err.status}`);
+  if (err.operation) parts.push(`operation=${err.operation}`);
+  if (err.endpoint) parts.push(`endpoint=${err.endpoint}`);
+  if (err.requestId) parts.push(`requestId=${err.requestId}`);
+  parts.push(`retryable=${err.isRetryable}`);
+  return parts;
+}
+function classifyKind(err) {
+  if (err instanceof CursorAgentError) {
+    const name = errorName(err);
+    if (name === "AuthenticationError" || err.code === "unauthenticated") return "auth";
+    if (name === "RateLimitError") return "rate_limit";
+    if (name === "NetworkError") return "network";
+    if (name === "ConfigurationError") return "config";
+  }
+  if (errorName(err) === "ConfigurationError") return "config";
+  if (errorMessage(err).includes("Cannot use this model")) return "config";
+  const code = errorCode(err);
+  if (code === "unauthenticated" || code === 16) return "auth";
+  if (typeof code === "number" && code === 8) return "rate_limit";
+  const msg = errorMessage(err).toLowerCase();
+  if (msg.includes("unauthenticated") || msg.includes("authentication") || msg.includes("api key")) {
+    return "auth";
+  }
+  if (msg.includes("cancelled") || msg.includes("canceled")) return "cancelled";
+  if (msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("socket hang up") || msg.includes("network") || msg.includes("timeout")) {
+    return "network";
+  }
+  return "unknown";
+}
+function formatChainLine(err, depth) {
+  const name = errorName(err);
+  const msg = errorMessage(err);
+  const raw = connectRawMessage(err);
+  const code = errorCode(err);
+  const extras = sdkExtras(err);
+  const bits = [`${"  ".repeat(depth)}${name}: ${msg}`];
+  if (raw && raw !== msg) bits.push(`raw=${raw}`);
+  if (code !== void 0) bits.push(`code=${code}`);
+  if (extras.length > 0) bits.push(extras.join(", "));
+  return bits.join(" | ");
+}
+function headlineForKind(kind, root) {
+  const msg = errorMessage(root);
+  switch (kind) {
+    case "auth":
+      return msg && msg !== "Error" ? `Cursor API \u9274\u6743\u5931\u8D25: ${msg}` : "Cursor API \u9274\u6743\u5931\u8D25 (unauthenticated)";
+    case "rate_limit":
+      return `Cursor API \u9650\u6D41: ${msg}`;
+    case "network":
+      return `Cursor API \u7F51\u7EDC\u9519\u8BEF: ${msg}`;
+    case "config":
+      return `Cursor SDK \u914D\u7F6E\u9519\u8BEF: ${msg}`;
+    case "cancelled":
+      return "Cursor agent run cancelled";
+    default:
+      return msg || "Cursor SDK error";
+  }
+}
+function describeSdkError(err) {
+  const lines = [];
+  let current = err;
+  let depth = 0;
+  let kind = "unknown";
+  while (current && depth < 8) {
+    lines.push(formatChainLine(current, depth));
+    const k = classifyKind(current);
+    if (k !== "unknown") kind = k;
+    current = getCause(current);
+    depth += 1;
+  }
+  const headline = headlineForKind(kind, err);
+  const hint = kind === "auth" ? AUTH_HINT : kind === "rate_limit" ? "\u7A0D\u540E\u91CD\u8BD5\uFF0C\u6216\u964D\u4F4E\u5E76\u53D1\uFF08maxConcurrentRuns / agentSessionPoolSize\uFF09\u3002" : void 0;
+  const detail = [headline, ...lines, hint].filter(Boolean).join("\n");
+  return { kind, headline, detail, hint };
+}
+function isCursorAgentNotFoundError(err, agentId) {
+  const msg = errorMessage(err);
+  if (!msg.includes(`Agent ${agentId} not found`)) return false;
+  if (errorName(err) !== "ConfigurationError") return false;
+  if (err instanceof CursorAgentError && err.operation !== "Agent.resume") return false;
+  if (err && typeof err === "object" && "operation" in err && err.operation !== "Agent.resume") {
+    return false;
+  }
+  return true;
+}
+function isCursorAgentActiveRunError(err, agentId) {
+  const msg = errorMessage(err);
+  if (!msg.includes(`Agent ${agentId} already has active run`)) return false;
+  if (err instanceof CursorAgentError && err.operation !== "agent.send") return false;
+  if (err && typeof err === "object" && "operation" in err && err.operation !== "agent.send") {
+    return false;
+  }
+  return true;
+}
+function isCursorRateLimitError(err) {
+  return describeSdkError(err).kind === "rate_limit";
+}
+function isCursorNetworkError(err) {
+  return describeSdkError(err).kind === "network";
+}
+function formatSdkErrorForIpc(phase, err) {
+  const d = describeSdkError(err);
+  const parts = [`${phase}: ${d.headline}`];
+  const rest = d.detail.split("\n").filter((line) => line !== d.headline && line !== d.hint);
+  if (rest.length > 0) parts.push(...rest);
+  if (d.hint) parts.push(d.hint);
+  return parts.join("\n");
+}
+function formatSdkErrorForStderr(phase, err) {
+  const d = describeSdkError(err);
+  return [`[sdk-worker] ${phase}`, d.detail, d.hint].filter(Boolean).join("\n");
+}
+
+// src/agent/cursor/spawn-run.ts
+import { spawn as spawn2 } from "child_process";
+import { statSync } from "fs";
+import { createInterface as createInterface2 } from "readline";
+
+// src/core/logger.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createWriteStream, mkdirSync } from "fs";
+import { open, readdir, rm, stat } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/config/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var appDir = join(homedir(), ".lark-channel");
+var paths = {
+  appDir,
+  cacheDir: appDir,
+  configFile: join(appDir, "config.json"),
+  sessionsFile: join(appDir, "sessions.json"),
+  workspacesFile: join(appDir, "workspaces.json"),
+  processesFile: join(appDir, "processes.json"),
+  secretsFile: join(appDir, "secrets.enc"),
+  keystoreSaltFile: join(appDir, ".keystore.salt"),
+  /**
+   * Thin shell wrapper that lark-cli (and other openclaw-exec-protocol
+   * consumers) invoke to resolve secrets from the bridge's encrypted store.
+   * Written user-owned and non-symlinked so it passes lark-cli's
+   * AssertSecurePath audit on machines where `node` is a Homebrew/Volta
+   * symlink or root-owned (`/usr/bin/node`). Wrapper internals do the
+   * `node ... secrets get` invocation; lark-cli only audits the wrapper.
+   */
+  secretsGetterScript: join(appDir, "secrets-getter"),
+  mediaDir: join(appDir, "media")
+};
+var legacyPaths = {
+  appDir: join(
+    process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"),
+    "lark-channel-bridge"
+  ),
+  cacheDir: join(
+    process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"),
+    "lark-channel-bridge"
+  )
+};
+
+// src/core/logger.ts
+var LOG_RETENTION_DAYS = Math.max(
+  1,
+  Number(process.env.LARK_CHANNEL_LOG_DAYS ?? 7) || 7
+);
+var als = new AsyncLocalStorage();
+
+// src/agent/claude/adapter.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+var BRIDGE_SYSTEM_PROMPT = `# lark-agent-bridge \u8FD0\u884C\u7EA6\u5B9A
+
+\u4F60\u6B63\u5728 lark-agent-bridge \u91CC\u8DD1\uFF1A\u628A\u98DE\u4E66/Lark \u7528\u6237\u6D88\u606F\u6865\u5230\u672C\u5730\u547D\u4EE4\u884C coding agent\u3002
+
+## bridge_context
+
+\u6BCF\u6761 user message \u9876\u90E8\u4F1A\u5E26\u4E00\u4E2A \`<bridge_context>\` \u5757\uFF1A
+
+\`\`\`
+<bridge_context>
+chat_id: oc_xxx
+chat_type: p2p
+sender_id: ou_xxx
+sender_name: ...
+</bridge_context>
+\`\`\`
+
+\u91CC\u9762\u662F\u5F53\u524D\u5BF9\u8BDD\u7684 chat_id\u3001chat \u7C7B\u578B\uFF08p2p / group\uFF09\u3001\u53D1\u9001\u8005\u3002\u8FD9\u4E9B\u662F bridge \u6CE8\u5165\u7684\u5143\u6570\u636E\uFF0C**\u4E0D\u8981\u7167\u6284\u3001\u4E0D\u8981\u5728\u4F60\u7684\u56DE\u590D\u91CC\u6E32\u67D3**\u2014\u2014\u5B83\u5BF9\u7528\u6237\u4E0D\u53EF\u89C1\u3002
+
+## quoted_message
+
+\u5982\u679C\u7528\u6237\u7528"\u5F15\u7528\u56DE\u590D"\u6307\u5411\u67D0\u6761\u6D88\u606F\uFF0Cbridge \u4F1A\u5728 \`<bridge_context>\` \u540E\u6CE8\u5165\u4E00\u4E2A \`<quoted_message>\` \u5757\uFF1A
+
+\`\`\`
+<quoted_message id="om_xxx" sender_id="ou_xxx" sender_name="..." created_at="..." type="text|merge_forward|...">
+\uFF08\u88AB\u5F15\u7528\u6D88\u606F\u7684\u5185\u5BB9\uFF1Bmerge_forward \u7C7B\u578B\u4F1A\u5C55\u5F00\u6210 <forwarded_messages>...</forwarded_messages>\uFF09
+</quoted_message>
+\`\`\`
+
+\u8FD9\u662F\u7528\u6237**\u6307\u5411\u7684\u5BF9\u8C61**\u2014\u2014\u7528\u6237\u7684\u5B9E\u9645\u95EE\u9898\u5728\u5B83\u4E4B\u540E\u3002\u56DE\u7B54\u65F6\u56F4\u7ED5\u8FD9\u6BB5\u5185\u5BB9\u5C55\u5F00\uFF1B\u5B83\u4E5F\u662F bridge \u6CE8\u5165\u7684\u5143\u6570\u636E\uFF0C**\u4E0D\u8981\u7167\u6284 XML \u6807\u7B7E**\u5230\u56DE\u590D\u91CC\u3002
+
+## \u53D1\u4EA4\u4E92\u5361\u7247\uFF08\u6309\u94AE\u3001\u8868\u5355\uFF09\u7684\u56DE\u8C03\u7EA6\u5B9A
+
+\u4F60\u60F3\u53D1\u4E00\u5F20\u53EF\u4EA4\u4E92\u7684\u5361\u7247\u8BA9\u7528\u6237\u70B9\u9009\u65F6\uFF1A
+
+1. \u7528 \`lark-cli\` \u628A\u5361\u53D1\u5230 \`bridge_context.chat_id\`\uFF1A
+   \`lark-cli im send-card --chat-id <chat_id> --card '<json>'\`
+2. \u5361\u7247\u7528 CardKit 2.0 schema\uFF08\`schema: "2.0"\`\uFF09\u3002
+3. **\u5982\u679C\u4F60\u5E0C\u671B\u7528\u6237\u70B9\u6309\u94AE\u540E\u56DE\u8C03\u5230\u4F60\uFF08\u8BA9\u4F60\u5728\u540C\u4E00\u4F1A\u8BDD\u91CC\u7EE7\u7EED\u5904\u7406\uFF09**\uFF1A
+   - \u6309\u94AE\u7684 \`value\` \u5BF9\u8C61**\u5FC5\u987B**\u5305\u542B \`__claude_cb: true\`
+   - \u540C\u65F6\u53EF\u4EE5\u585E\u4EFB\u610F\u5176\u5B83\u5B57\u6BB5\uFF0C\u4F5C\u4E3A\u4F60\u9700\u8981\u5728\u56DE\u8C03\u65F6\u8BB0\u4F4F\u7684\u72B6\u6001\uFF08\u6BD4\u5982 \`{"__claude_cb": true, "choice": "a", "ticket_id": "T-123"}\`\uFF09
+4. \u7528\u6237\u70B9\u51FB\u540E\uFF0Cbridge \u4F1A\u628A payload\uFF08\u53BB\u6389 \`__claude_cb\` marker\uFF09\u4F5C\u4E3A \`[card-click] {...}\` \u6D88\u606F\u53D1\u56DE\u7ED9\u4F60\uFF1B\u4F60\u7684 session \u81EA\u52A8\u7EED\u4E0A\uFF0C\u80FD\u770B\u5230\u81EA\u5DF1\u4E0A\u8F6E\u53D1\u4E86\u4EC0\u4E48\u5361\u3002
+5. **\u5982\u679C\u53EA\u662F\u5C55\u793A\u5361\uFF08\u4E0D\u9700\u8981\u56DE\u8C03\uFF09**\uFF0C\u4E0D\u8981\u52A0 \`__claude_cb\`\uFF0C\u5426\u5219\u70B9\u51FB\u5C31\u4F1A\u89E6\u53D1\u989D\u5916\u7684\u4F1A\u8BDD\u8F6E\u6B21\u3002
+
+\u793A\u4F8B button\uFF1A
+\`\`\`json
+{
+  "tag": "button",
+  "text": { "tag": "plain_text", "content": "\u65B9\u6848 A" },
+  "behaviors": [{
+    "type": "callback",
+    "value": { "__claude_cb": true, "choice": "a" }
+  }]
+}
+\`\`\`
+
+## \u98DE\u4E66 OAuth \u6388\u6743\uFF08\`lark-cli auth login\`\uFF09
+
+\u6388\u6743\u6D41\u7A0B\u8981\u8BA9 \`lark-cli\` \u8FDB\u7A0B\u4E00\u76F4\u6D3B\u5230\u7528\u6237\u5728\u6D4F\u89C8\u5668\u91CC\u70B9\u5B8C\u4E3A\u6B62\u3002bridge \u5728\u4F60\u7684 run \u7ED3\u675F\u4E4B\u540E\u4F1A\u56DE\u6536 claude\uFF0C**\u4F60 spawn \u7684\u4EFB\u4F55\u540E\u53F0 bash \u4E5F\u4F1A\u8DDF\u7740\u6B7B**\u2014\u2014\u6240\u4EE5\u6388\u6743\u5FC5\u987B\u7528"\u524D\u53F0\u963B\u585E"\u7684\u65B9\u5F0F\u8DD1\uFF1A
+
+1. **\u4EC5\u5728 p2p \u91CC\u53D1\u8D77\u6388\u6743**\u3002\u4ECE \`bridge_context.chat_type\` \u770B\uFF1A
+   - \`chat_type: p2p\` \u2014\u2014 \u6B63\u5E38\u6309\u4E0B\u9762\u6D41\u7A0B\u8D70\u3002
+   - \`chat_type: group\`\uFF08\u542B topic \u7FA4\uFF09\u2014\u2014 **\u4E0D\u8981**\u8C03 \`lark-cli auth login\`\u3002device flow \u628A \`verification_url\` \u53D1\u5230\u7FA4\u91CC\uFF0C\u8C01\u5148\u70B9\u8C01\u62FF\u8D70 token\u2014\u2014\u4F1A\u7ED1\u5B9A\u5230\u9519\u7684\u8EAB\u4EFD\u3002\u6B63\u786E\u505A\u6CD5\u662F\u56DE\u590D\u7528\u6237\uFF1A"\u6388\u6743\u8981\u5728\u79C1\u804A\u91CC\u505A\uFF0C\u8BF7\u5355\u72EC\u79C1\u4FE1\u6211\u3002"
+2. **\u7981\u6B62** \u7528 \`run_in_background: true\` \u8C03 \`lark-cli auth login\`\u2014\u2014\u5B83\u4F1A\u88AB\u4F60 exit \u65F6\u4E00\u8D77\u5E26\u8D70\uFF0C\u7528\u6237\u8FD8\u6CA1\u70B9\u5B8C\u5C31\u4E22\u4E86\u3002
+3. **\u63A8\u8350\u4E24\u9636\u6BB5\u6D41**\uFF08lark-cli \u5728 \`--no-wait\` \u7684\u8F93\u51FA\u91CC\u4E5F\u4F1A\u544A\u8BC9\u4F60\u8FD9\u5957\uFF09\uFF1A
+   - \u5148\u8DD1 \`lark-cli auth login --no-wait --json [--recommend | --domain ... | --scope ...]\`\uFF0C**\u8FD9\u4E00\u6B65\u79D2\u8FD4\u56DE**\uFF0Cstdout \u91CC\u6709 \`verification_url\` \u548C \`device_code\`\u3002
+   - \u628A \`verification_url\` **\u539F\u6837**\u7528\u4EE3\u7801\u5757\u53D1\u7ED9\u7528\u6237\uFF08\u4E0D\u8981 Markdown \u94FE\u63A5\u5316\u3001\u4E0D\u8981 URL \u7F16\u7801\uFF09\u3002
+   - \u7D27\u63A5\u7740\u540C\u4E00\u8F6E\u91CC\u8DD1 \`lark-cli auth login --device-code <code>\`\uFF0C**\u8FD9\u4E00\u6B65\u524D\u53F0\u963B\u585E**\u76F4\u5230\u7528\u6237\u70B9\u5B8C\u6216 10 \u5206\u949F\u8D85\u65F6\u2014\u2014\u8FD9\u662F\u4F60\u5E94\u8BE5\u7B49\u7684\u5730\u65B9\uFF0C\u4E0D\u8981\u4E22\u5230\u540E\u53F0\u3002
+4. \u4F60\u524D\u53F0\u963B\u585E\u671F\u95F4\uFF0C\u7528\u6237\u53D1\u7684\u65B0\u6D88\u606F bridge \u4F1A\u81EA\u52A8\u6392\u961F\uFF0C**\u4E0D\u4F1A\u6253\u65AD\u4F60**\uFF1B\u7B49\u4F60 tool_result \u4E00\u56DE\u6765\uFF0C\u4E0B\u4E00\u6279\u6D88\u606F\u518D\u8FDB\u6765\u3002\u6240\u4EE5\u653E\u5FC3\u963B\u585E\u3002
+5. \u5982\u679C\u7528\u6237\u4E2D\u9014\u60F3\u53D6\u6D88\uFF0C\u4ED6\u4EEC\u4F1A\u53D1 \`/stop\`\u2014\u2014\u90A3\u65F6\u88AB kill \u662F\u9884\u671F\u884C\u4E3A\uFF0C\u4E0D\u7528\u515C\u5E95\u3002
+`;
+
+// src/agent/cursor/spawn-run.ts
+function buildCursorPrompt(prompt) {
+  return `<bridge_system_prompt>
+${BRIDGE_SYSTEM_PROMPT}
+</bridge_system_prompt>
+
+<user_prompt>
+${prompt}
+</user_prompt>`;
+}
+
+// src/agent/cursor/sdk-translate.ts
+function* translateSdkMessage(msg) {
+  if (msg.type === "system" && msg.subtype === "init") {
+    yield {
+      type: "system",
+      sessionId: msg.agent_id,
+      model: typeof msg.model?.id === "string" ? msg.model.id : void 0
+    };
+    return;
+  }
+  if (msg.type === "thinking" && typeof msg.text === "string" && msg.text) {
+    yield { type: "thinking", delta: msg.text };
+    return;
+  }
+  if (msg.type === "status" && typeof msg.status === "string") {
+    yield {
+      type: "progress",
+      phase: phaseForSdkStatus(msg.status),
+      label: labelForSdkStatus(msg.status, msg.text)
+    };
+    return;
+  }
+  if (msg.type === "task") {
+    const label = typeof msg.text === "string" && msg.text.trim() ? msg.text : msg.status;
+    if (typeof label === "string" && label.trim()) {
+      yield { type: "progress", phase: "thinking", label };
+    }
+    return;
+  }
+  if (msg.type === "assistant" && msg.message?.content) {
+    for (const block of msg.message.content) {
+      if (block.type === "text" && typeof block.text === "string" && block.text) {
+        yield { type: "text", delta: block.text };
+      }
+      if (block.type === "tool_use" && block.id && block.name) {
+        yield { type: "tool_use", id: block.id, name: block.name, input: block.input ?? {} };
+      }
+    }
+    return;
+  }
+  if (msg.type === "tool_call" && msg.call_id && msg.name) {
+    if (msg.status === "running") {
+      yield { type: "tool_use", id: msg.call_id, name: msg.name, input: msg.args ?? {} };
+    } else if (msg.status === "completed" || msg.status === "error") {
+      yield {
+        type: "tool_result",
+        id: msg.call_id,
+        output: stringifyResult(msg.result),
+        isError: msg.status === "error" || isErrorResult(msg.result)
+      };
+    }
+  }
+}
+function phaseForSdkStatus(status) {
+  switch (status) {
+    case "CREATING":
+      return "starting";
+    case "FINISHED":
+      return "streaming";
+    case "RUNNING":
+    case "ERROR":
+    case "CANCELLED":
+    case "EXPIRED":
+    default:
+      return "thinking";
+  }
+}
+function labelForSdkStatus(status, message) {
+  if (typeof message === "string" && message.trim()) return message;
+  switch (status) {
+    case "CREATING":
+      return "\u6B63\u5728\u521B\u5EFA Agent";
+    case "RUNNING":
+      return "Agent \u6B63\u5728\u8FD0\u884C";
+    case "FINISHED":
+      return "Agent \u6B63\u5728\u6536\u5C3E";
+    case "ERROR":
+      return "Agent \u72B6\u6001\u5F02\u5E38";
+    case "CANCELLED":
+      return "Agent \u5DF2\u53D6\u6D88";
+    case "EXPIRED":
+      return "Agent \u5DF2\u8FC7\u671F";
+    default:
+      return `Agent \u72B6\u6001: ${status}`;
+  }
+}
+function stringifyResult(result) {
+  if (typeof result === "string") return result;
+  if (result === void 0) return "";
+  try {
+    return JSON.stringify(result);
+  } catch {
+    return String(result);
+  }
+}
+function isErrorResult(result) {
+  if (!result || typeof result !== "object") return false;
+  const record = result;
+  return record.error === true || record.is_error === true || typeof record.error === "string";
+}
+
+// src/agent/cursor/sdk-worker.ts
+function readConfig() {
+  const raw = process.env.LARK_CURSOR_SDK_CONFIG;
+  if (!raw) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+var config = readConfig();
+var agent;
+var agentCwd;
+var activeRunId;
+var activeAbort;
+var ensureQueue = Promise.resolve();
+var runQueue = Promise.resolve();
+var pendingRunRecoveryNotes = [];
+var RATE_LIMIT_RETRY_DELAYS_MS = [1e3, 2500, 5e3];
+var RECOVERY_NOTE_MAX = 6;
+function send(msg) {
+  if (typeof process.send === "function") process.send(msg);
+}
+function reportWorkerError(phase, err, runId, recoveryNotes = [], fatal = false) {
+  process.stderr.write(`${formatSdkErrorForStderr(phase, err)}
+`);
+  send({
+    type: "error",
+    id: runId,
+    message: withWorkerRecoveryHint(withRecoverySummary(formatSdkErrorForIpc(phase, err), recoveryNotes), fatal),
+    fatal
+  });
+}
+async function withRecoverableRetry(label, task, recoveryNotes) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await task();
+    } catch (err) {
+      const delayMs = RATE_LIMIT_RETRY_DELAYS_MS[attempt];
+      const kind = isCursorRateLimitError(err) ? "\u9650\u6D41" : isCursorNetworkError(err) ? "\u7F51\u7EDC\u9519\u8BEF" : void 0;
+      if (delayMs === void 0 || !kind) throw err;
+      addRecoveryNote(
+        recoveryNotes,
+        `${label} \u9047\u5230${kind}\uFF0C\u5DF2\u81EA\u52A8\u91CD\u8BD5 ${attempt + 1}/${RATE_LIMIT_RETRY_DELAYS_MS.length} \u6B21`
+      );
+      process.stderr.write(
+        `[sdk-worker] ${label} recoverable ${kind}; retrying in ${delayMs}ms (attempt ${attempt + 2})
+`
+      );
+      await sleep(delayMs);
+    }
+  }
+}
+function agentOptions(cwd) {
+  return {
+    ...config?.apiKey ? { apiKey: config.apiKey } : {},
+    model: config.model,
+    local: { cwd }
+  };
+}
+function queueEnsure(task) {
+  ensureQueue = ensureQueue.then(task).catch((err) => {
+    reportWorkerError("sdk ensure failed", err);
+  });
+}
+function queueRun(id, task) {
+  runQueue = runQueue.then(task).catch((err) => {
+    reportWorkerError("sdk run queue failed", err, id);
+  });
+}
+async function ensureAgent(id, cwd, agentId, allowReplacement = true) {
+  if (!config) {
+    send({ type: "error", id, message: "sdk worker config missing" });
+    return;
+  }
+  if (agent && agent.agentId === agentId) {
+    send({ type: "agent", id, agentId: agent.agentId });
+    return;
+  }
+  if (agent) {
+    try {
+      agent.close();
+    } catch {
+    }
+    agent = void 0;
+  }
+  const opts = agentOptions(cwd);
+  const recoveryNotes = [];
+  try {
+    if (agentId) {
+      try {
+        agent = await withRecoverableRetry("Agent.resume", () => Agent.resume(agentId, opts), recoveryNotes);
+      } catch (err) {
+        if (!isCursorAgentNotFoundError(err, agentId)) throw err;
+        if (!allowReplacement) {
+          addRecoveryNote(
+            recoveryNotes,
+            `\u539F SDK session \u4E0D\u53EF\u6062\u590D\uFF0C\u672A\u81EA\u52A8\u521B\u5EFA replacement session`
+          );
+          throw err;
+        }
+        process.stderr.write(
+          `[sdk-worker] stale SDK agent ${agentId}; creating a replacement session
+`
+        );
+        addRecoveryNote(
+          recoveryNotes,
+          `\u65E7 SDK session \u4E0D\u53EF\u6062\u590D\uFF0C\u5DF2\u81EA\u52A8\u521B\u5EFA replacement session`
+        );
+        agent = await withRecoverableRetry("Agent.create", () => Agent.create(opts), recoveryNotes);
+      }
+    } else {
+      agent = await withRecoverableRetry("Agent.create", () => Agent.create(opts), recoveryNotes);
+    }
+    agentCwd = cwd;
+    if (id.startsWith("ensure-")) stashRunRecoveryNotes(recoveryNotes);
+    send({ type: "agent", id, agentId: agent.agentId });
+  } catch (err) {
+    reportWorkerError("sdk agent init failed", err, id);
+  }
+}
+async function sendPromptWithStaleSessionRecovery(id, prompt, recoveryNotes, allowReplacement = true) {
+  if (!agent) throw new Error("sdk worker agent not initialized");
+  try {
+    return await withRecoverableRetry("agent.send", () => agent.send(buildCursorPrompt(prompt)), recoveryNotes);
+  } catch (err) {
+    const staleAgentId = agent.agentId;
+    if (!agentCwd || !isCursorAgentActiveRunError(err, staleAgentId)) throw err;
+    if (!allowReplacement) {
+      addRecoveryNote(
+        recoveryNotes,
+        `\u539F SDK session \u4ECD\u6709 active run\uFF0C\u672A\u81EA\u52A8\u521B\u5EFA replacement session`
+      );
+      throw err;
+    }
+    const replacementCwd = agentCwd;
+    process.stderr.write(
+      `[sdk-worker] SDK agent ${staleAgentId} still has an active run; creating a replacement session
+`
+    );
+    addRecoveryNote(
+      recoveryNotes,
+      `\u68C0\u6D4B\u5230\u65E7 SDK session \u4ECD\u6709 active run\uFF0C\u5DF2\u81EA\u52A8\u521B\u5EFA replacement session`
+    );
+    try {
+      agent.close();
+    } catch {
+    }
+    agent = await withRecoverableRetry("Agent.create", () => Agent.create(agentOptions(replacementCwd)), recoveryNotes);
+    send({ type: "event", id, event: { type: "system", sessionId: agent.agentId, cwd: replacementCwd } });
+    return await withRecoverableRetry("agent.send", () => agent.send(buildCursorPrompt(prompt)), recoveryNotes);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function handleRun(id, prompt, allowReplacement = true) {
+  if (!agent) {
+    send({ type: "error", id, message: "sdk worker agent not initialized" });
+    return;
+  }
+  if (activeRunId) {
+    send({ type: "error", id, message: "run already active in sdk worker" });
+    return;
+  }
+  activeRunId = id;
+  const recoveryNotes = consumeRunRecoveryNotes();
+  let cancelled = false;
+  activeAbort = () => {
+    cancelled = true;
+  };
+  try {
+    const run = await sendPromptWithStaleSessionRecovery(id, prompt, recoveryNotes, allowReplacement);
+    activeAbort = () => {
+      cancelled = true;
+      void run.cancel().catch(() => {
+      });
+    };
+    try {
+      for await (const msg of run.stream()) {
+        if (cancelled) break;
+        for (const event of translateSdkMessage(msg)) {
+          send({ type: "event", id, event });
+        }
+      }
+    } catch (streamErr) {
+      reportWorkerError("sdk run stream failed", streamErr, id, recoveryNotes, true);
+      return;
+    }
+    if (cancelled) {
+      send({ type: "error", id, message: "run cancelled" });
+      return;
+    }
+    const result = await run.wait();
+    if (result.status === "error") {
+      const message = withWorkerRecoveryHint(withRecoverySummary(formatRunResultError(result), recoveryNotes), true);
+      process.stderr.write(`[sdk-worker] ${message}
+`);
+      send({
+        type: "error",
+        id,
+        message,
+        fatal: true
+      });
+      return;
+    }
+    send({ type: "done", id, agentId: agent.agentId });
+  } catch (err) {
+    reportWorkerError("sdk run failed", err, id, recoveryNotes, true);
+  } finally {
+    activeRunId = void 0;
+    activeAbort = void 0;
+  }
+}
+function formatRunResultError(result) {
+  const headline = `sdk run failed (runId=${result.id}, status=${result.status})`;
+  if (typeof result.result === "string" && result.result.trim()) {
+    return `${headline}: ${result.result.trim()}`;
+  }
+  const diagnostic = safeJson({
+    id: result.id,
+    status: result.status,
+    result: result.result
+  });
+  return `${headline}; Cursor returned no error detail${diagnostic ? ` | result=${diagnostic}` : ""}`;
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value).slice(0, 1200);
+  } catch {
+    return "";
+  }
+}
+function addRecoveryNote(notes, note) {
+  if (!notes || notes.includes(note)) return;
+  notes.push(note);
+  if (notes.length > RECOVERY_NOTE_MAX) notes.splice(0, notes.length - RECOVERY_NOTE_MAX);
+}
+function stashRunRecoveryNotes(notes) {
+  for (const note of notes) addRecoveryNote(pendingRunRecoveryNotes, note);
+}
+function consumeRunRecoveryNotes() {
+  const notes = pendingRunRecoveryNotes;
+  pendingRunRecoveryNotes = [];
+  return notes;
+}
+function withRecoverySummary(message, recoveryNotes) {
+  if (recoveryNotes.length === 0) return message;
+  return [
+    `\u5DF2\u81EA\u52A8\u6062\u590D/\u91CD\u8BD5 ${recoveryNotes.length} \u6B65\uFF1A`,
+    ...recoveryNotes.map((note) => `- ${note}`),
+    "",
+    `\u6700\u7EC8\u5931\u8D25\u539F\u56E0\uFF1A${message}`
+  ].join("\n");
+}
+function withWorkerRecoveryHint(message, fatal) {
+  if (!fatal) return message;
+  return `${message}
+
+\u5DF2\u81EA\u52A8\u4E22\u5F03\u5F53\u524D SDK worker\u3002bridge \u4F1A\u4F18\u5148\u7528\u539F session \u521B\u5EFA\u65B0 worker \u5E76\u7EE7\u7EED\u4E00\u6B21\uFF1B\u82E5\u539F session \u4E0D\u53EF\u6062\u590D\u6216\u4ECD\u6709 active run\uFF0C\u5C06\u505C\u6B62\u81EA\u52A8\u7EE7\u7EED\uFF0C\u4FDD\u7559\u4E00\u952E\u91CD\u8BD5/\u65B0 session \u5165\u53E3\u3002`;
+}
+process.on("uncaughtException", (err) => {
+  reportWorkerError("uncaughtException", err, activeRunId, [], true);
+  activeRunId = void 0;
+  activeAbort = void 0;
+});
+process.on("unhandledRejection", (reason) => {
+  reportWorkerError("unhandledRejection", reason, activeRunId, [], true);
+  activeRunId = void 0;
+  activeAbort = void 0;
+});
+process.on("message", (msg) => {
+  if (!msg || typeof msg !== "object") return;
+  switch (msg.type) {
+    case "ensure":
+      if (agent && msg.agentId !== void 0 && agent.agentId === msg.agentId) {
+        send({ type: "agent", id: msg.id, agentId: agent.agentId });
+        return;
+      }
+      queueEnsure(() => ensureAgent(msg.id, msg.cwd, msg.agentId, msg.allowReplacement));
+      return;
+    case "run":
+      queueRun(msg.id, () => handleRun(msg.id, msg.prompt, msg.allowReplacement));
+      return;
+    case "stop":
+      if (activeRunId === msg.id) activeAbort?.();
+      return;
+    case "shutdown":
+      if (activeRunId) activeAbort?.();
+      if (agent) {
+        try {
+          agent.close();
+        } catch {
+        }
+      }
+      process.exit(0);
+      return;
+    default:
+      return;
+  }
+});
+if (config) {
+  send({ type: "ready" });
+} else {
+  send({ type: "error", message: "sdk worker config missing" });
+}