@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-mcp-adapter/mcp-panel.js

@@ -54,6 +54,10 @@ function sanitizeRowContent(content) {
   }
   return result;
 }
+function serverDescription(definition, entry) {
+  return definition?.description?.trim() || entry?.instructions?.trim().split(`
+`, 1)[0] || undefined;
+}
 function estimateTokens(tool) {
   const schemaLen = JSON.stringify(tool.inputSchema ?? {}).length;
   const descLen = tool.description?.length ?? 0;
@@ -113,11 +117,20 @@ class McpPanelView {
           continue;
         if (item.type === "server") {
           this.addRow(this.renderServerRow(state, server, isCursor), innerWidth);
+          if (server.expanded && server.summary) {
+            this.addRow(`    ${this.theme.description(sanitizeDisplayText(server.summary))}`, innerWidth);
+          }
           if (isCursor && server.connectionStatus === "failed" && server.failureMessage) {
             for (const line of this.wrapText(sanitizeDisplayText(server.failureMessage), innerWidth - 6)) {
               this.addRow(`    ${this.theme.cancel(line)}`, innerWidth);
             }
           }
+          if ((isCursor || server.expanded) && server.ignoredSettings) {
+            const text = `Ignored DM mcp.json settings: ${server.ignoredSettings.join(", ")}`;
+            for (const line of this.wrapText(sanitizeDisplayText(text), innerWidth - 6)) {
+              this.addRow(`    ${this.theme.hint(line)}`, innerWidth);
+            }
+          }
         } else if (item.toolIndex !== undefined) {
           const tool = server.tools[item.toolIndex];
           if (tool)
@@ -171,6 +184,7 @@ class McpPanelView {
       this.theme.italic("ctrl+a") + " auth",
       this.theme.italic("ctrl+r") + " reconnect",
       this.theme.italic("ctrl+d") + " disable/enable",
+      ...state.canImportPiSignIns ? [this.theme.italic("ctrl+p") + " import sign-ins from DM"] : [],
       ...this.selectedServerHasFailureMessage(state) ? [this.theme.italic("ctrl+y") + " copy error"] : [],
       this.theme.italic("?") + " desc search",
       ...state.saveLabel ? [this.theme.italic(state.saveLabel) + " save"] : [],
@@ -296,6 +310,8 @@ class McpPanelView {
   renderConnectionStatus(state, server) {
     if (state.authInFlight === server.name)
       return `  ${this.theme.needsAuth("authenticating")}`;
+    if (server.connectionStatus === "blocked")
+      return `  ${this.theme.needsAuth("blocked by project trust")}`;
     if (server.disabled)
       return `  ${this.theme.description("disabled")}`;
     if (server.connectionStatus === "needs-auth")
@@ -341,6 +357,7 @@ class McpPanel {
   importNotice = null;
   authNotice = null;
   authInFlight = null;
+  piSignInsImported = false;
   inactivityTimeout = null;
   visibleItems = [];
   tui;
@@ -425,9 +442,12 @@ class McpPanel {
       }
       this.servers.push({
         name: serverName,
+        summary: serverDescription(definition, serverCache),
         expanded: false,
         source: prov?.kind ?? "user",
         ...prov?.importKind !== undefined ? { importKind: prov.importKind } : {},
+        ...prov?.ignoredSettings !== undefined ? { ignoredSettings: prov.ignoredSettings } : {},
+        ...typeof definition.auth === "object" ? { signInProvider: definition.auth.provider } : {},
         ...definition.includeTools !== undefined ? { includeTools: definition.includeTools } : {},
         ...definition.excludeTools !== undefined ? { excludeTools: definition.excludeTools } : {},
         exposeResources: definition.exposeResources !== false,
@@ -490,10 +510,12 @@ class McpPanel {
     }
     if (query && !this.authOnly) {
       this.visibleItems = this.visibleItems.filter((item) => {
-        if (item.type === "server") {
-          return this.visibleItems.some((other) => other.type === "tool" && other.serverIndex === item.serverIndex);
-        }
-        return true;
+        if (item.type !== "server")
+          return true;
+        const server = this.servers[item.serverIndex];
+        if (mode === "name" && server && fuzzyScore(query, server.name) > 0)
+          return true;
+        return this.visibleItems.some((other) => other.type === "tool" && other.serverIndex === item.serverIndex);
       });
     }
   }
@@ -613,7 +635,7 @@ class McpPanel {
       if (!item)
         return;
       const server = this.servers[item.serverIndex];
-      if (!server)
+      if (!server || server.connectionStatus === "blocked")
         return;
       if (item.type === "server") {
         if (server.connectionStatus === "disabled")
@@ -631,7 +653,7 @@ class McpPanel {
           return;
         this.toggleToolDirect(server, tool);
         if (tool.isDirect && server.source === "import") {
-          this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to user config on save`;
+          this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to adapter config on save`;
         }
         this.updateDirty();
       }
@@ -657,7 +679,7 @@ class McpPanel {
       if (!item || item.type !== "server" || this.authOnly)
         return;
       const server = this.servers[item.serverIndex];
-      if (!server)
+      if (!server || server.connectionStatus === "blocked")
         return;
       server.disabled = !server.disabled;
       this.updateDirty();
@@ -683,6 +705,12 @@ class McpPanel {
       });
       return;
     }
+    if (matchesKey(data, "ctrl+p")) {
+      if (!this.authOnly && !this.piSignInsImported && this.callbacks.importPiSignIns) {
+        this.importPiSignIns(this.callbacks.importPiSignIns);
+      }
+      return;
+    }
     if (data === "?") {
       if (this.authOnly)
         return;
@@ -712,12 +740,29 @@ class McpPanel {
     if (server)
       this.authenticateServer(server);
   }
+  importPiSignIns(importPiSignIns) {
+    const { imported, failed } = importPiSignIns();
+    this.piSignInsImported = failed.length === 0;
+    const notices = [
+      ...imported.length > 0 ? [`Imported sign-ins from DM for ${imported.map(sanitizeDisplayText).join(", ")}. Reconnecting...`] : [],
+      ...failed.map(({ server, error }) => `Failed to import the sign-in from DM for ${sanitizeDisplayText(server)}: ${sanitizeDisplayText(error)}`)
+    ];
+    this.authNotice = notices.length > 0 ? notices.join(" ") : "No sign-ins from DM left to import.";
+    for (const server of this.servers) {
+      if (imported.includes(server.name))
+        this.reconnectServer(server);
+    }
+  }
   authenticateServer(server) {
     if (this.authInFlight)
       return;
-    if (server.connectionStatus === "connecting" || server.connectionStatus === "disabled")
+    if (server.connectionStatus === "connecting" || server.connectionStatus === "disabled" || server.connectionStatus === "blocked")
       return;
     const serverName = sanitizeDisplayText(server.name);
+    if (server.signInProvider !== undefined) {
+      this.authNotice = `${serverName} signs in with DM: run /login ${sanitizeDisplayText(server.signInProvider)}, then press ctrl+r to reconnect.`;
+      return;
+    }
     if (!this.callbacks.canAuthenticate(server.name)) {
       this.authNotice = `${serverName} does not use OAuth authentication.`;
       return;
@@ -747,7 +792,7 @@ class McpPanel {
     });
   }
   reconnectServer(server, options = {}) {
-    if (server.connectionStatus === "connecting" || server.connectionStatus === "disabled")
+    if (server.connectionStatus === "connecting" || server.connectionStatus === "disabled" || server.connectionStatus === "blocked")
       return;
     const serverName = sanitizeDisplayText(server.name);
     server.connectionStatus = "connecting";
@@ -760,6 +805,7 @@ class McpPanel {
         if (entry) {
           this.cache ??= { version: 1, servers: {} };
           this.cache.servers[server.name] = entry;
+          server.summary = serverDescription(this.config.mcpServers[server.name], entry);
           this.rebuildServerTools(server, entry);
           server.hasCachedData = true;
         }
@@ -784,7 +830,7 @@ class McpPanel {
     if (item.type === "server") {
       const newState = !server.tools.every((t) => t.isDirect);
       if (server.source === "import" && newState) {
-        this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to user config on save`;
+        this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to adapter config on save`;
       }
       let directTokens = 0;
       for (const tool of server.tools) {
@@ -800,7 +846,7 @@ class McpPanel {
         return;
       this.toggleToolDirect(server, tool);
       if (tool.isDirect && server.source === "import") {
-        this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to user config on save`;
+        this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to adapter config on save`;
       }
     }
     this.updateDirty();
@@ -941,7 +987,8 @@ class McpPanel {
       authNotice: this.authNotice,
       authInFlight: this.authInFlight,
       authOnly: this.authOnly,
-      saveLabel: this.keys.saveLabel()
+      saveLabel: this.keys.saveLabel(),
+      canImportPiSignIns: !this.authOnly && !this.piSignInsImported && this.callbacks.importPiSignIns !== undefined
     };
   }
   render(width) {

package/extensions/dm-mcp-adapter/mcp-script-wasm.js

@@ -0,0 +1,22 @@
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+const cached = new Map;
+function resolveQuickJsWasmPath() {
+  return createRequire(import.meta.url).resolve("quickjs-wasi/quickjs.wasm");
+}
+export function resolveMcpScriptQuickJsUrl() {
+  return new URL("./dist/index.js", pathToFileURL(resolveQuickJsWasmPath())).href;
+}
+export function loadMcpScriptWasm(path = resolveQuickJsWasmPath()) {
+  let module = cached.get(path);
+  if (!module) {
+    const webAssembly = globalThis.WebAssembly;
+    module = readFile(path).then((bytes) => webAssembly.compile(bytes)).catch((error) => {
+      cached.delete(path);
+      throw error;
+    });
+    cached.set(path, module);
+  }
+  return module;
+}

package/extensions/dm-mcp-adapter/mcp-script-worker.mjs

@@ -1,130 +1,246 @@
 import { parentPort, workerData } from "node:worker_threads";
-import { formatWithOptions } from "node:util";
-import vm from "node:vm";
-const TOOLS_ENUMERATION_ERROR = "tools is not enumerable — use tools.search({ query })";
-const RESERVED_TOOL_PROPS = new Set(["then", "catch", "finally", "toJSON", "toString", "valueOf"]);
-function needsInspectableFormatting(value, stack = new WeakSet) {
-  if (value === undefined || typeof value === "bigint" || typeof value === "function" || typeof value === "symbol")
-    return true;
-  if (typeof value !== "object" || value === null)
-    return false;
-  if (stack.has(value))
-    return true;
-  if (value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet)
-    return true;
-  stack.add(value);
-  try {
-    return Object.values(value).some((entry) => needsInspectableFormatting(entry, stack));
-  } finally {
-    stack.delete(value);
+const MEMORY_LIMIT_BYTES = 64 * 1024 * 1024;
+const ERROR_MAX_BYTES = 64 * 1024;
+const ERROR_TRUNCATION_MARKER = `
+...[mcpScript error truncated]`;
+let JSException;
+function post(message) {
+  parentPort?.postMessage(message);
+}
+function errorText(error) {
+  if (JSException && error instanceof JSException) {
+    const head = error.message ? `${error.name}: ${error.message}` : error.name;
+    return error.stack ? `${head}
+${error.stack}` : head;
   }
+  return error instanceof Error ? error.message : String(error);
 }
-function formatValue(value) {
-  if (typeof value === "string")
-    return value;
-  try {
-    if (!needsInspectableFormatting(value)) {
-      const json = JSON.stringify(value, null, 2);
-      if (json !== undefined)
-        return json;
+function truncateErrorMessage(error) {
+  const message = typeof error === "string" ? error : errorText(error);
+  const bytes = Buffer.from(message, "utf8");
+  if (bytes.length <= ERROR_MAX_BYTES)
+    return message;
+  const marker = Buffer.from(ERROR_TRUNCATION_MARKER, "utf8");
+  const prefix = bytes.subarray(0, ERROR_MAX_BYTES - marker.length - 3).toString("utf8").replace(/\uFFFD$/, "");
+  return prefix + ERROR_TRUNCATION_MARKER;
+}
+function postError(error) {
+  post({ type: "error", message: truncateErrorMessage(error) });
+}
+function discardOutput(memory) {
+  return {
+    fd_write(_fd, iovsPtr, iovsLen, nwrittenPtr) {
+      const view = new DataView(memory.buffer);
+      let written = 0;
+      for (let index = 0;index < iovsLen; index++) {
+        written += view.getUint32(iovsPtr + index * 8 + 4, true);
+      }
+      view.setUint32(nwrittenPtr, written, true);
+      return 0;
     }
-    return formatWithOptions({ colors: false, depth: 6 }, value);
-  } catch {
-    return "[unserializable value]";
-  }
+  };
 }
-function toContentBlock(value) {
-  if (typeof value === "object" && value !== null) {
-    if (value.type === "text" && typeof value.text === "string") {
-      return { type: "text", text: value.text };
+const PRELUDE_SOURCE = `(function (bridge) {
+  "use strict";
+  const parse = JSON.parse;
+  const stringify = JSON.stringify;
+  const promiseThen = Promise.prototype.then;
+  const ErrorCtor = Error;
+  const reserved = new Set(["then", "catch", "finally", "toJSON", "toString", "valueOf"]);
+  const pending = new Map();
+  let nextId = 0;
+
+  function inspect(value, ancestors) {
+    if (typeof value === "string") return value;
+    if (value === undefined) return "undefined";
+    if (typeof value === "bigint") return String(value) + "n";
+    if (typeof value === "function") return "[Function" + (value.name ? ": " + value.name : "") + "]";
+    if (typeof value === "symbol") return String(value);
+    if (value === null || typeof value !== "object") return String(value);
+    if (value instanceof ErrorCtor) return value.name + (value.message ? ": " + value.message : "");
+    if (ancestors.includes(value)) return "[Circular]";
+    const next = ancestors.concat([value]);
+    if (value instanceof Map) {
+      const entries = [];
+      for (const [key, entry] of value) entries.push(inspectQuoted(key, next) + " => " + inspectQuoted(entry, next));
+      return "Map(" + value.size + ") { " + entries.join(", ") + " }";
     }
-    if (value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string") {
-      return { type: "image", data: value.data, mimeType: value.mimeType };
+    if (value instanceof Set) {
+      const entries = [];
+      for (const entry of value) entries.push(inspectQuoted(entry, next));
+      return "Set(" + value.size + ") { " + entries.join(", ") + " }";
     }
+    if (Array.isArray(value)) return "[ " + value.map((entry) => inspectQuoted(entry, next)).join(", ") + " ]";
+    let keys;
+    try { keys = Object.keys(value); } catch { return "[unserializable value]"; }
+    return "{ " + keys.map((key) => key + ": " + inspectQuoted(value[key], next)).join(", ") + " }";
   }
-  return { type: "text", text: formatValue(value) };
-}
-let nextRequestId = 0;
-const pending = new Map;
-parentPort.on("message", (message) => {
-  if (message?.type !== "result" || typeof message.id !== "number")
-    return;
-  const resolve = pending.get(message.id);
-  if (!resolve)
-    return;
-  pending.delete(message.id);
-  resolve("dataJson" in message ? { ok: true, data: JSON.parse(message.dataJson) } : message.envelope);
-});
-function request(type, payload) {
-  return new Promise((resolve) => {
-    const id = ++nextRequestId;
-    pending.set(id, resolve);
-    parentPort.postMessage({ type, id, ...payload });
-  });
-}
-const tools = new Proxy(Object.create(null), {
-  get(_target, property) {
-    if (property === "search") {
-      return async (input) => request("search", { input });
+
+  function inspectQuoted(value, ancestors) {
+    return typeof value === "string" ? "'" + value.replaceAll("'", "\\\\'") + "'" : inspect(value, ancestors);
+  }
+
+  function needsInspect(value, ancestors) {
+    if (value === undefined || typeof value === "bigint" || typeof value === "function" || typeof value === "symbol") return true;
+    if (value === null || typeof value !== "object") return false;
+    if (value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet || value instanceof ErrorCtor) return true;
+    if (ancestors.includes(value)) return true;
+    const next = ancestors.concat([value]);
+    try { return Object.values(value).some((entry) => needsInspect(entry, next)); } catch { return true; }
+  }
+
+  function format(value) {
+    if (typeof value === "string") return value;
+    try {
+      if (!needsInspect(value, [])) {
+        const json = stringify(value, null, 2);
+        if (json !== undefined) return json;
+      }
+      return inspect(value, []);
+    } catch { return "[unserializable value]"; }
+  }
+
+  function toBlock(value) {
+    if (value && typeof value === "object") {
+      if (value.type === "text" && typeof value.text === "string") return { type: "text", text: value.text };
+      if (value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string") {
+        return { type: "image", data: value.data, mimeType: value.mimeType };
+      }
     }
-    if (property === "call") {
-      return async (path, args) => {
+    return { type: "text", text: format(value) };
+  }
+
+  function request(type, payload) {
+    return new Promise((resolve) => {
+      const id = ++nextId;
+      pending.set(id, resolve);
+      bridge("request", type, id, stringify(payload));
+    });
+  }
+
+  const tools = new Proxy(Object.create(null), {
+    get(_target, property) {
+      if (property === "search") return (input) => request("search", { input });
+      if (property === "describe") return (input) => request("describe", { input });
+      if (property === "call") return (path, args, options) => {
         if (typeof path !== "string" || path.trim() === "") {
-          return {
-            ok: false,
-            error: {
-              code: "invalid_tool_path",
-              message: "tools.call(path, args) requires a non-empty tool path."
-            }
-          };
+          return Promise.resolve({ ok: false, error: { code: "invalid_tool_path", message: "tools.call(path, args) requires a non-empty tool path." } });
         }
-        return request("call", { path, args });
+        const server = options?.server;
+        if (server !== undefined && (typeof server !== "string" || server.trim() === "")) {
+          return Promise.resolve({ ok: false, error: { code: "invalid_tool_server", message: "tools.call(path, args, { server }) requires a non-empty server name." } });
+        }
+        return request("call", server === undefined ? { path, args } : { path, args, server });
       };
+      if (typeof property !== "string" || reserved.has(property)) return undefined;
+      return (args) => request("call", { path: property, args });
+    },
+    ownKeys() { throw new ErrorCtor("tools is not enumerable — use tools.search({ query })"); },
+  });
+
+  const jev = Object.freeze({ evaluate: (input) => request("evaluate", { input }) });
+  const emit = (value) => bridge("emit", stringify(toBlock(value)));
+  const console = {};
+  for (const level of ["log", "info", "warn", "error", "debug"]) {
+    console[level] = (...args) => emit("[console." + level + "] " + args.map(format).join(" "));
+  }
+  Object.freeze(console);
+  Object.defineProperties(globalThis, {
+    tools: { value: tools, enumerable: true },
+    jev: { value: jev, enumerable: true },
+    emit: { value: emit, enumerable: true },
+    console: { value: console, enumerable: true },
+  });
+
+  return {
+    settle(id, payload) {
+      const resolve = pending.get(id);
+      if (!resolve) return;
+      pending.delete(id);
+      resolve(parse(payload));
+    },
+    run(fn) {
+      let promise;
+      try { promise = fn(); }
+      catch (error) { bridge("error", format(error)); return; }
+      promiseThen.call(promise,
+        (value) => bridge("done", value === undefined ? undefined : stringify(toBlock(value))),
+        (error) => bridge("error", format(error)));
+    },
+  };
+})`;
+async function main() {
+  const quickjs = await import(workerData.quickjsUrl);
+  JSException = quickjs.JSException;
+  const { MAX_STACK_SIZE, QuickJS } = quickjs;
+  const interrupt = new Int32Array(workerData.interrupt);
+  let outputBytes = 0;
+  let outputExceeded = false;
+  const postOutput = (message, block) => {
+    if (outputExceeded)
+      return;
+    const bytes = Buffer.byteLength(JSON.stringify(block), "utf8");
+    if (bytes > workerData.outputMaxBytes - outputBytes) {
+      outputExceeded = true;
+      postError("mcpScript output exceeds the 16 MiB per-script budget");
+      Atomics.store(interrupt, 0, 1);
+      return;
     }
-    if (property === "describe") {
-      return async (input) => request("describe", { input });
+    outputBytes += bytes;
+    post(message);
+  };
+  const vm = await QuickJS.create({
+    wasm: workerData.wasm,
+    memoryLimit: MEMORY_LIMIT_BYTES,
+    maxStackSize: MAX_STACK_SIZE,
+    interruptHandler: () => Atomics.load(interrupt, 0) !== 0,
+    wasi: discardOutput
+  });
+  const bridge = vm.newFunction("bridge", (kind, a, b, c) => {
+    const messageType = kind.toString();
+    if (messageType === "request") {
+      const payload = JSON.parse(c.toString());
+      post({ type: a.toString(), id: b.toNumber(), ...payload });
+    } else if (messageType === "emit") {
+      const block = JSON.parse(a.toString());
+      postOutput({ type: "emit", block }, block);
+    } else if (messageType === "done") {
+      if (a === undefined || a.isUndefined) {
+        post({ type: "done" });
+      } else {
+        const returnBlock = JSON.parse(a.toString());
+        postOutput({ type: "done", returnBlock }, returnBlock);
+      }
+    } else if (messageType === "error") {
+      postError(a.toString());
     }
-    if (typeof property !== "string" || RESERVED_TOOL_PROPS.has(property))
+    return vm.undefined;
+  });
+  const api = vm.withScope((scope) => scope.escape(vm.callFunction(vm.evalCode(PRELUDE_SOURCE, "mcpScript-prelude.js"), vm.undefined, bridge)));
+  const settle = api.getProp("settle");
+  const run = api.getProp("run");
+  parentPort?.on("message", (message) => {
+    if (message?.type !== "result" || typeof message.id !== "number")
       return;
-    return (args) => request("call", { path: property, args });
-  },
-  ownKeys() {
-    throw new Error(TOOLS_ENUMERATION_ERROR);
-  }
-});
-const jev = Object.freeze({
-  evaluate: (input) => request("evaluate", { input })
-});
-const emit = (value) => {
-  parentPort.postMessage({ type: "emit", block: toContentBlock(value) });
-};
-const capturedConsole = Object.freeze({
-  log: (...args) => emit(`[console.log] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
-  info: (...args) => emit(`[console.info] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
-  warn: (...args) => emit(`[console.warn] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
-  error: (...args) => emit(`[console.error] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
-  debug: (...args) => emit(`[console.debug] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`)
-});
-(async () => {
+    try {
+      const payload = "dataJson" in message ? `{"ok":true,"data":${message.dataJson}}` : JSON.stringify(message.envelope);
+      vm.withScope(() => vm.callFunction(settle, api, vm.newNumber(message.id), vm.newString(payload)));
+      vm.executePendingJobs();
+    } catch (error) {
+      postError(error);
+    }
+  });
+  let fn;
   try {
-    const context = vm.createContext(Object.assign(Object.create(null), {
-      tools,
-      jev,
-      emit,
-      console: capturedConsole
-    }), {
-      codeGeneration: { strings: false, wasm: false },
-      name: "mcpScript"
-    });
-    const script = new vm.Script(`(async () => {
+    fn = vm.evalCode(`(async () => {
 ${workerData.code}
-})()`, { filename: "mcpScript.js" });
-    const returnValue = await Promise.resolve(script.runInContext(context));
-    parentPort.postMessage(returnValue === undefined ? { type: "done" } : { type: "done", returnBlock: toContentBlock(returnValue) });
+})`, "mcpScript.js");
+    vm.callFunction(run, api, fn).dispose();
+    fn.dispose();
+    vm.executePendingJobs();
   } catch (error) {
-    parentPort.postMessage({
-      type: "error",
-      message: error instanceof Error ? error.message : String(error)
-    });
+    postError(error);
   }
-})();
+}
+if (parentPort)
+  main().catch(postError);