codex-copilot-dx 0.6.21 → 0.7.1

package/src/pm-studio-status.mjs

@@ -1,369 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {
-  AUTH_PROFILE_CLAUDE,
-  readAuthProfileCredentials,
-} from "./auth-profile.mjs";
-import { PM_STUDIO_RECIPES } from "./pm-studio-asar.mjs";
-import {
-  assertPatchedBinaryRecord,
-  createPmStudioStatusOperationOverrides,
-  createPmStudioSetupOperations,
-  DEFAULT_PM_STUDIO_APP_PATH,
-  inspectPmStudioApp,
-  PM_STUDIO_CLAUDE_AUTH_COMMAND,
-  pmStudioBackupRoot,
-  pmStudioPatchManifestPath,
-  resolvePmStudioCompatibleRecipe,
-} from "./pm-studio-setup.mjs";
-import { readAdapterStatus } from "./cli-status.mjs";
-import {
-  PM_STUDIO_RELAY_MARKER_HEADER,
-  PM_STUDIO_RELAY_MARKER_VALUE,
-  PM_STUDIO_RELAY_PREFIX,
-} from "./pm-studio-relay.mjs";
-import { checkRunningAdapter } from "./running-adapter.mjs";
-import { status } from "./status.mjs";
-import {
-  cliOutputFormat,
-  cliOutputWidth,
-  formatResponsiveCliTable,
-  terminalCell,
-} from "./cli-table.mjs";
-
-const PM_RELAY_HOST = "127.0.0.1";
-const PM_RELAY_PORT = 2026;
-const PM_RELAY_PROBE_TIMEOUT_MS = 500;
-const PM_RELAY_CAPABILITY = "pm_studio_split_origin_v1";
-const PM_RELAY_ROUTE_NAMES = Object.freeze([
-  "pm_models",
-  "pm_chat_completions",
-]);
-
-function safeMessage(error) {
-  return String(error?.message || "inspection failed").replace(/\s+/g, " ").trim();
-}
-
-export async function probePmStudioRelay({
-  baseUrl,
-  fetchImpl = fetch,
-  timeoutMs = PM_RELAY_PROBE_TIMEOUT_MS,
-} = {}) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetchImpl(new URL(`${PM_STUDIO_RELAY_PREFIX}/models`, baseUrl).href, {
-      method: "GET",
-      headers: { Accept: "application/json" },
-      redirect: "error",
-      signal: controller.signal,
-    });
-    const result = {
-      status: response.status,
-      marker: response.headers.get(PM_STUDIO_RELAY_MARKER_HEADER) || "",
-    };
-    await response.body?.cancel().catch(() => {});
-    return result;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-function inspectClaudeProfile(home, readCredentials) {
-  try {
-    const credentials = readCredentials(AUTH_PROFILE_CLAUDE, { home });
-    return {
-      configured: credentials.configured === true,
-      valid: credentials.valid === true,
-      reason: credentials.reason || "",
-      login: credentials.identity?.login || "",
-    };
-  } catch (error) {
-    return { configured: true, valid: false, reason: safeMessage(error), login: "" };
-  }
-}
-
-function inspectAdapterRuntime(adapter, runtimeStatus) {
-  const data = runtimeStatus?.data;
-  const health = adapter?.data;
-  const issues = [];
-  if (!data || typeof data !== "object") {
-    return { ok: false, baseUrl: runtimeStatus?.baseUrl || adapter?.baseUrl, data: null, issues: ["runtime status payload is missing"] };
-  }
-  if (data.version !== health?.version
-    || data.protocol_version !== health?.protocol_version
-    || data.instance_id !== health?.instance_id
-    || data.pid !== health?.pid) {
-    issues.push("health and runtime status do not describe the same adapter instance");
-  }
-  const capabilities = new Set(Array.isArray(data.capabilities) ? data.capabilities : []);
-  if (!capabilities.has(PM_RELAY_CAPABILITY)) issues.push("PM Studio split-origin relay capability is missing");
-  if (data.profiles?.claude?.mode !== "isolated") issues.push("Claude profile mode is not isolated");
-  if (data.profiles?.claude?.profile_current !== true) {
-    issues.push("running Claude credentials do not match the current isolated profile");
-  }
-  if (data.routing?.responses !== "codex") issues.push("/v1/responses is not routed to Codex");
-  if (data.routing?.messages !== "claude") issues.push("/v1/messages is not routed to Claude");
-  const routes = data.requests?.by_route;
-  for (const routeName of PM_RELAY_ROUTE_NAMES) {
-    if (!routes || typeof routes !== "object" || !Object.hasOwn(routes, routeName)) {
-      issues.push(`runtime status does not expose ${routeName}`);
-    }
-  }
-  return {
-    ...runtimeStatus,
-    ok: issues.length === 0,
-    issues,
-  };
-}
-
-function inspectRelayProbe(runtime, probe) {
-  const relayProbe = {
-    status: probe?.status,
-    marker: String(probe?.marker || ""),
-  };
-  const issues = [...runtime.issues];
-  if (relayProbe.status !== 401) {
-    issues.push(`PM Studio relay probe returned HTTP ${relayProbe.status ?? "unknown"}; expected 401`);
-  }
-  if (relayProbe.marker !== PM_STUDIO_RELAY_MARKER_VALUE) {
-    issues.push("PM Studio relay compatibility marker is missing or incompatible");
-  }
-  return { ...runtime, relayProbe, ok: issues.length === 0, issues };
-}
-
-export async function inspectPmStudioStatus({
-  appPath = DEFAULT_PM_STUDIO_APP_PATH,
-  home = os.homedir(),
-  backupRoot = pmStudioBackupRoot(home),
-  recipes = PM_STUDIO_RECIPES,
-  operationOverrides = {},
-  existsSync = fs.existsSync,
-  inspectApp = inspectPmStudioApp,
-  verifyPatchRecord = assertPatchedBinaryRecord,
-  resolveCompatibleRecipe = resolvePmStudioCompatibleRecipe,
-  readClaudeCredentials = readAuthProfileCredentials,
-  checkRunningAdapterFn = checkRunningAdapter,
-  readAdapterStatusFn = readAdapterStatus,
-  probePmStudioRelayFn = probePmStudioRelay,
-} = {}) {
-  const operations = createPmStudioSetupOperations({
-    ...createPmStudioStatusOperationOverrides(),
-    ...operationOverrides,
-  });
-  let app;
-  if (!existsSync(appPath)) {
-    app = { state: "not_installed", metadata: null, issues: [] };
-  } else {
-    try {
-      const metadata = operations.readBundleMetadata({
-        appPath,
-        infoPlistPath: path.join(appPath, "Contents/Info.plist"),
-        processRunner: operations.processRunner,
-      });
-      const normalized = {
-        version: String(metadata.version),
-        build: String(metadata.build),
-        bundleIdentifier: String(metadata.bundleIdentifier),
-      };
-      let recipe = null;
-      let compatibilityError = null;
-      try {
-        recipe = resolveCompatibleRecipe({
-          appPath,
-          home,
-          backupRoot,
-          metadata: normalized,
-          recipes,
-          operations,
-          inspectApp,
-        });
-      } catch (error) {
-        compatibilityError = error;
-      }
-      if (recipe) {
-        app = { ...inspectApp({ appPath, recipe, operations }), recipe: recipe.id };
-        if (["patched", "predecessor"].includes(app.state)) {
-          const manifestPath = pmStudioPatchManifestPath({ home, backupRoot, recipe });
-          try {
-            verifyPatchRecord({
-              inspection: app,
-              manifestPath,
-              recipe,
-              recordState: app.state,
-            });
-            app.patchRecord = { valid: true, manifestPath, reason: "" };
-          } catch (error) {
-            const reason = safeMessage(error);
-            app.patchRecipeMatched = true;
-            app.patchRecord = { valid: false, manifestPath, reason };
-            app.state = "drift";
-            app.issues = [...(Array.isArray(app.issues) ? app.issues : []), reason];
-          }
-        }
-      } else {
-        app = {
-          state: "unsupported",
-          metadata: normalized,
-          issues: compatibilityError ? [safeMessage(compatibilityError)] : [],
-          recipe: "",
-        };
-      }
-    } catch (error) {
-      app = { state: "error", metadata: null, issues: [safeMessage(error)], recipe: "" };
-    }
-  }
-
-  const claude = inspectClaudeProfile(home, readClaudeCredentials);
-  let adapter;
-  try {
-    adapter = await checkRunningAdapterFn({ host: PM_RELAY_HOST, port: PM_RELAY_PORT });
-  } catch (error) {
-    adapter = { ok: false, error };
-  }
-  let runtime = { ok: false, baseUrl: adapter?.baseUrl, data: null, issues: ["adapter health check failed"] };
-  if (adapter?.ok === true) {
-    try {
-      runtime = inspectAdapterRuntime(adapter, await readAdapterStatusFn({
-        host: PM_RELAY_HOST,
-        port: PM_RELAY_PORT,
-      }));
-    } catch (error) {
-      runtime = { ok: false, baseUrl: adapter.baseUrl, data: null, issues: [safeMessage(error)] };
-    }
-    if (runtime.data) {
-      try {
-        runtime = inspectRelayProbe(runtime, await probePmStudioRelayFn({ baseUrl: adapter.baseUrl }));
-      } catch (error) {
-        runtime = {
-          ...runtime,
-          ok: false,
-          relayProbe: null,
-          issues: [...runtime.issues, `PM Studio relay probe failed: ${safeMessage(error)}`],
-        };
-      }
-    }
-  }
-  const operational = app.state === "patched"
-    && app.patchRecord?.valid === true
-    && claude.valid
-    && adapter?.ok === true
-    && runtime.ok === true;
-  return { ok: operational, appPath, app, claude, adapter, runtime };
-}
-
-function appStatusItem(result, commandName) {
-  const { app } = result;
-  const version = app.metadata ? `${app.metadata.version} build ${app.metadata.build}` : "";
-  if (app.state === "patched" && app.patchRecord?.valid === true) {
-    return { kind: "ok", component: "App patch", detail: `${version}; patched and verified`, message: `PM Studio ${version} is patched and verified against its installed patch record` };
-  }
-  if (app.state === "patched") {
-    const reason = app.patchRecord?.reason || "installed patch record is missing";
-    return { kind: "err", component: "App patch", detail: `${version}; patch record not verified`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${reason}` };
-  }
-  if (app.state === "predecessor" && app.patchRecord?.valid === true) {
-    return { kind: "warn", component: "App patch", detail: `${version}; verified predecessor split patch`, message: `PM Studio ${version} has a verified predecessor split patch; run ${commandName} pms setup to migrate` };
-  }
-  if (app.state === "legacy") {
-    return { kind: "err", component: "App patch", detail: `${version}; legacy global-origin patch`, message: `PM Studio ${version} has a legacy global-origin patch; run ${commandName} pms setup to migrate` };
-  }
-  if (app.state === "clean") return { kind: "warn", component: "App patch", detail: `${version}; compatible structure, not patched`, message: `PM Studio ${version} has a compatible local patch structure but is not patched; run ${commandName} pms setup` };
-  if (app.state === "unsupported") return { kind: "err", component: "App patch", detail: `${version}; structure incompatible`, message: `PM Studio ${version} does not expose one uniquely compatible patch structure; no files will be changed` };
-  if (app.state === "drift" && app.patchRecipeMatched) {
-    return { kind: "err", component: "App patch", detail: `${version}; patch record drift`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${app.issues.join("; ")}` };
-  }
-  if (app.state === "drift") return { kind: "err", component: "App patch", detail: `${version}; integrity drift`, message: `PM Studio ${version} does not match the clean or patched recipe: ${app.issues.join("; ")}` };
-  if (app.state === "not_installed") return { kind: "warn", component: "App patch", detail: "not installed", message: `PM Studio is not installed at ${result.appPath}` };
-  return { kind: "err", component: "App patch", detail: "inspection failed", message: `PM Studio could not be inspected: ${app.issues.join("; ")}` };
-}
-
-function pmStudioStatusItems(result, commandName) {
-  const items = [appStatusItem(result, commandName)];
-  if (result.claude.valid) {
-    const account = result.claude.login ? ` for ${result.claude.login}` : "";
-    const detail = result.claude.login ? `${result.claude.login}; isolated profile valid` : "isolated profile valid";
-    items.push({ kind: "ok", component: "Claude profile", detail, message: `Isolated Claude profile is valid${account}` });
-  } else {
-    const reason = result.claude.configured && result.claude.reason ? ` (${result.claude.reason})` : "";
-    items.push({ kind: "err", component: "Claude profile", detail: "not ready", message: `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}` });
-  }
-  if (result.adapter?.ok && result.runtime?.ok) {
-    items.push({ kind: "ok", component: "PM relay", detail: `verified at ${result.adapter.baseUrl}`, message: `PM model discovery and isolated Claude routing are verified at ${result.adapter.baseUrl}` });
-  } else if (result.adapter?.ok) {
-    const reason = result.runtime?.issues?.join("; ") || "runtime status is unavailable";
-    items.push({ kind: "err", component: "PM relay", detail: "running but routing not ready", message: `The adapter is running at ${result.adapter.baseUrl}, but PM relay routing is not ready: ${reason}; stop it and run ${commandName} start` });
-  } else if (result.adapter?.incompatible) {
-    items.push({ kind: "err", component: "PM relay", detail: `incompatible at ${result.adapter.baseUrl}`, message: `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start` });
-  } else {
-    items.push({ kind: "warn", component: "PM relay", detail: `not running at ${PM_RELAY_HOST}:${PM_RELAY_PORT}`, message: `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start` });
-  }
-  if (result.runtime?.ok) {
-    items.push({ kind: "info", component: "Routing", detail: "GPT -> native official; models/Claude -> local", message: "Routing: PM GPT uses its native official GitHub Copilot path; model discovery and eligible Claude chat use the local CCDX relay" });
-  } else {
-    items.push({ kind: "info", component: "Routing", detail: "expected: GPT -> native official; models/Claude -> local", message: "Expected routing: PM GPT uses its native official GitHub Copilot path; model discovery and eligible Claude chat use the local CCDX relay" });
-  }
-  return items;
-}
-
-function formatPmStudioStatusPlain(result, commandName, { sanitize = false } = {}) {
-  const lines = [
-    `${commandName} pms status`,
-    ...pmStudioStatusItems(result, commandName).map((item) => status(item.kind, item.message)),
-  ];
-  return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
-}
-
-function tableState(kind) {
-  return `[${String(kind).toUpperCase()}]`;
-}
-
-function formatPmStudioStatusTable(result, { commandName, output }) {
-  const items = pmStudioStatusItems(result, commandName);
-  const rows = items.map((item) => ({
-    component: item.component,
-    state: tableState(item.kind),
-    detail: item.detail,
-  }));
-  const table = formatResponsiveCliTable({
-    columns: [
-      { key: "component", label: "COMPONENT" },
-      { key: "state", label: "STATE" },
-      { key: "detail", label: "DETAIL" },
-    ],
-    compactColumns: [
-      { key: "component", label: "COMPONENT" },
-      { key: "state", label: "STATE" },
-    ],
-    rows,
-    width: cliOutputWidth(output),
-  });
-  const lines = [`${commandName} pms status`, table.output];
-  const details = table.compact ? items : items.filter((item) => item.kind === "warn" || item.kind === "err");
-  if (details.length) {
-    lines.push("", "Details:", ...details.map((item) => terminalCell(status(item.kind, item.message), { fallback: "" })));
-  }
-  return { output: lines.join("\n"), overflow: table.overflow };
-}
-
-export function formatPmStudioStatus(result, {
-  commandName = "ccdx",
-  format = "plain",
-  output = process.stdout,
-} = {}) {
-  if (cliOutputFormat(format, output) === "plain") {
-    return formatPmStudioStatusPlain(result, commandName);
-  }
-  const table = formatPmStudioStatusTable(result, { commandName, output });
-  return format === "auto" && table.overflow
-    ? formatPmStudioStatusPlain(result, commandName, { sanitize: true })
-    : table.output;
-}
-
-export async function runPmStudioStatus(options = {}) {
-  const result = await inspectPmStudioStatus(options);
-  const output = formatPmStudioStatus(result, options);
-  (options.log || console.log)(output);
-  return { ...result, output };
-}

package/src/token-counter-service.mjs

@@ -1,211 +0,0 @@
-import { Worker } from "node:worker_threads";
-import { anthropicTokenText } from "./anthropic.mjs";
-import { debugLog } from "./log.mjs";
-
-export const DEFAULT_TOKEN_COUNTER_TIMEOUT_MS = 120 * 1000;
-export const DEFAULT_TOKEN_COUNTER_MAX_QUEUED = 16;
-
-function serviceError(message, statusCode) {
-  return Object.assign(new Error(message), { statusCode });
-}
-
-const DIAGNOSTIC_PHASES = new Set(["create", "worker", "error", "exit", "postMessage"]);
-const DIAGNOSTIC_ERROR_NAMES = new Set(["Error", "TypeError", "RangeError", "SyntaxError", "WorkerExit"]);
-
-export function tokenCounterWorkerDiagnostic(phase, error) {
-  const safePhase = DIAGNOSTIC_PHASES.has(phase) ? phase : "unknown";
-  let rawName;
-  let rawCode;
-  try { rawName = error?.name; } catch {}
-  try { rawCode = error?.code; } catch {}
-  const safeName = DIAGNOSTIC_ERROR_NAMES.has(rawName) ? rawName : "Error";
-  if (typeof rawCode === "number") rawCode = String(rawCode);
-  const safeCode = typeof rawCode === "string" && /^(?:\d+|[A-Z][A-Z0-9_]{0,63})$/.test(rawCode)
-    ? rawCode
-    : "unknown";
-  return `Token counter worker failure: phase=${safePhase} name=${safeName} code=${safeCode}`;
-}
-
-function positiveInteger(value, fallback) {
-  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
-}
-
-function abortError(signal) {
-  if (signal?.reason instanceof Error) return signal.reason;
-  const error = new Error("The operation was aborted");
-  error.name = "AbortError";
-  return error;
-}
-
-export function tokenCounterWorkerExecArgv(execArgv = process.execArgv) {
-  const filtered = [];
-  for (let index = 0; index < execArgv.length; index += 1) {
-    const value = execArgv[index];
-    if (value === "--input-type") {
-      index += 1;
-      continue;
-    }
-    if (value.startsWith("--input-type=")) continue;
-    filtered.push(value);
-  }
-  return filtered;
-}
-
-function createTokenCounterWorker() {
-  const execArgv = tokenCounterWorkerExecArgv();
-  const options = execArgv.length === process.execArgv.length ? undefined : { execArgv };
-  return new Worker(new URL("./token-counter-worker.mjs", import.meta.url), options);
-}
-
-export function createTokenCounterService({
-  timeoutMs = DEFAULT_TOKEN_COUNTER_TIMEOUT_MS,
-  maxQueued = DEFAULT_TOKEN_COUNTER_MAX_QUEUED,
-  workerFactory = createTokenCounterWorker,
-} = {}) {
-  timeoutMs = positiveInteger(timeoutMs, DEFAULT_TOKEN_COUNTER_TIMEOUT_MS);
-  maxQueued = positiveInteger(maxQueued, DEFAULT_TOKEN_COUNTER_MAX_QUEUED);
-  const queue = [];
-  let worker = null;
-  let active = null;
-  let nextId = 1;
-  let closed = false;
-
-  const finish = (job, callback, value) => {
-    if (job.finished) return;
-    job.finished = true;
-    if (job.timer) clearTimeout(job.timer);
-    job.signal?.removeEventListener("abort", job.onAbort);
-    callback(value);
-  };
-
-  const retireWorker = () => {
-    const retired = worker;
-    worker = null;
-    if (!retired) return;
-    retired.removeAllListeners();
-    retired.on("error", () => {});
-    Promise.resolve(retired.terminate()).catch(() => {});
-  };
-
-  const pump = () => {
-    if (closed || active || queue.length === 0) return;
-    if (!worker) {
-      try {
-        worker = workerFactory();
-      } catch (error) {
-        debugLog(tokenCounterWorkerDiagnostic("create", error));
-        const job = queue.shift();
-        if (job) finish(job, job.reject, serviceError("Token counter worker failed", 500));
-        queueMicrotask(pump);
-        return;
-      }
-      worker.on("message", (message) => {
-        if (!active || message?.id !== active.id) return;
-        const job = active;
-        active = null;
-        if (message.error) {
-          debugLog(tokenCounterWorkerDiagnostic("worker", message.error));
-          retireWorker();
-          finish(job, job.reject, serviceError("Token counter worker failed", 500));
-        } else {
-          finish(job, job.resolve, message.result);
-        }
-        pump();
-      });
-      worker.on("error", (error) => {
-        debugLog(tokenCounterWorkerDiagnostic("error", error));
-        const job = active;
-        active = null;
-        retireWorker();
-        if (job) finish(job, job.reject, serviceError("Token counter worker failed", 500));
-        pump();
-      });
-      worker.on("exit", (code) => {
-        if (active) debugLog(tokenCounterWorkerDiagnostic("exit", { name: "WorkerExit", code }));
-        const job = active;
-        active = null;
-        worker = null;
-        if (job) finish(job, job.reject, serviceError("Token counter worker failed", 500));
-        pump();
-      });
-      worker.unref?.();
-    }
-    const job = queue.shift();
-    if (!job || job.finished) return pump();
-    active = job;
-    try {
-      worker.postMessage({ id: job.id, text: job.text });
-      job.text = null;
-    } catch (error) {
-      debugLog(tokenCounterWorkerDiagnostic("postMessage", error));
-      active = null;
-      retireWorker();
-      finish(job, job.reject, serviceError("Token counter worker failed", 500));
-      pump();
-    }
-  };
-
-  const cancel = (job, error) => {
-    if (job.finished) return;
-    const queuedIndex = queue.indexOf(job);
-    if (queuedIndex >= 0) queue.splice(queuedIndex, 1);
-    if (active === job) {
-      active = null;
-      retireWorker();
-    }
-    finish(job, job.reject, error);
-    pump();
-  };
-
-  return {
-    count(body, { signal, deadlineMs = timeoutMs } = {}) {
-      if (closed) return Promise.reject(serviceError("Token counter service is closed", 503));
-      if (signal?.aborted) return Promise.reject(abortError(signal));
-      let text;
-      try {
-        text = anthropicTokenText(body);
-      } catch {
-        return Promise.reject(serviceError("Invalid count_tokens request", 400));
-      }
-      if (active && queue.length >= maxQueued) {
-        return Promise.reject(serviceError(`Token counter queue is full (${maxQueued} waiting)`, 503));
-      }
-      return new Promise((resolve, reject) => {
-        deadlineMs = positiveInteger(deadlineMs, timeoutMs);
-        const job = {
-          id: nextId++,
-          text,
-          signal,
-          resolve,
-          reject,
-          finished: false,
-          timer: null,
-          onAbort: null,
-        };
-        job.onAbort = () => cancel(job, abortError(signal));
-        signal?.addEventListener("abort", job.onAbort, { once: true });
-        job.timer = setTimeout(() => {
-          cancel(job, serviceError(`Token counting timed out after ${deadlineMs}ms`, 504));
-        }, deadlineMs);
-        queue.push(job);
-        if (signal?.aborted) job.onAbort();
-        else pump();
-      });
-    },
-    close() {
-      if (closed) return;
-      closed = true;
-      const error = serviceError("Token counter service is closed", 503);
-      if (active) {
-        const job = active;
-        active = null;
-        finish(job, job.reject, error);
-      }
-      for (const job of queue.splice(0)) finish(job, job.reject, error);
-      retireWorker();
-    },
-    stats() {
-      return { active: active ? 1 : 0, queued: queue.length, worker: worker ? 1 : 0 };
-    },
-  };
-}

package/src/token-counter-worker.mjs

@@ -1,16 +0,0 @@
-import { parentPort } from "node:worker_threads";
-import { countTokenText } from "./anthropic.mjs";
-
-parentPort.on("message", async ({ id, text }) => {
-  try {
-    parentPort.postMessage({ id, result: await countTokenText(text) });
-  } catch (error) {
-    parentPort.postMessage({
-      id,
-      error: {
-        name: typeof error?.name === "string" ? error.name : "Error",
-        code: typeof error?.code === "string" ? error.code : "unknown",
-      },
-    });
-  }
-});