harnery 0.40.0 → 0.41.0

package/src/commands/browse.ts

@@ -1,7 +1,9 @@
+import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, resolve } from "node:path";
 import type { Command } from "commander";
+import { chromium } from "playwright";
 import { PNG } from "pngjs";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
 import { resolveBinName } from "../core/config.ts";
@@ -24,15 +26,19 @@ import {
   type CritiqueResult,
   type CritiqueTile,
   captureDevOverlay,
+  chromeMajorFromExecutable,
   DEFAULT_CRITIQUE_RUBRIC,
   type DevOverlayResult,
   type Diagnostics,
   extractObservedIp,
+  installedChromeChannel,
+  installedChromePath,
   type LayoutAxis,
   type LayoutLintResult,
   type OverflowResult,
   parseAssertSpec,
   type RuntsResult,
+  resolveUserAgent,
   runCritique,
   type StandaloneHtmlResult,
   type TargetSizeProfile,
@@ -108,6 +114,7 @@ import {
   saveBaseline,
 } from "../lib/browser/visual-diff.ts";
 import { applyExtraCookies, CookieJar } from "../lib/cookies/index.ts";
+import { commandPaceGate } from "../lib/pace/index.ts";
 
 /**
  * `harn browse <url>`: Playwright-backed page navigation with shared
@@ -162,13 +169,17 @@ interface BrowseOpts {
   batch?: string;
   networkHar?: string;
   login?: boolean;
+  plain?: boolean;
   loginCloseFile?: string;
   controlFile?: string;
   headed?: boolean;
   browserArg?: string[];
+  browserChannel?: string;
+  userAgent?: string;
   proxyFromEnv?: boolean;
   exportCookies?: string;
   cookies?: boolean;
+  pace?: boolean;
   store?: string;
   profile?: string;
   viewport?: string;
@@ -339,8 +350,7 @@ export function registerBrowseCommand(
     .option("--network-har <path>", "Record network traffic to a HAR file (finalized on close)")
     .option(
       "--viewport <preset|WxH>",
-      "Viewport: mobile (390x844), tablet (820x1180), desktop (1280x800), hd (1920x1080), or explicit '1920x1080'",
-      "desktop",
+      "Viewport: mobile (390x844), tablet (820x1180), desktop (1280x800), hd (1920x1080), or explicit '1920x1080'. Default: real window in headed mode, desktop in headless mode",
     )
     .option(
       "--color-scheme <scheme>",
@@ -349,6 +359,14 @@ export function registerBrowseCommand(
         "Absent = browser default (unchanged behavior).",
     )
     .option("--login", "Headed mode for one-time auth flow (cookies persist in profile)")
+    .option(
+      "--plain",
+      "With --login: open the URL in the installed Google Chrome with nothing attached (no DevTools " +
+        "protocol, no Playwright) on the same persistent profile. Use it for sign-in flows whose " +
+        "verification step detects automation itself (X does). Sign in, then close the window or " +
+        "create the --login-close-file; later browse and browse-session runs reuse the profile's cookies. " +
+        "Not compatible with --control-file, because nothing is attached to drive.",
+    )
     .option(
       "--login-close-file <path>",
       "With --login, wait for this file instead of terminal Enter, then remove it and close cleanly",
@@ -358,13 +376,27 @@ export function registerBrowseCommand(
       "With --login, publish an owner-only descriptor for repeated browse-session control",
     )
     .option("--headed", "Headed mode for one-off (no auth-flow framing)")
+    .option(
+      "--browser-channel <name>",
+      "Browser to launch: chrome | chrome-beta | msedge | chromium. Headed launches (--login, --headed) " +
+        "default to the installed Google Chrome with the automation signals removed, because the bundled " +
+        '"Chrome for Testing" build advertises itself and sign-in flows refuse clicks; chromium forces the ' +
+        "bundled build. HARNERY_BROWSER_CHANNEL sets the default machine-wide.",
+    )
+    .option(
+      "--user-agent <ua|auto|native>",
+      "User agent to present. Default: a normal Windows (or macOS on a Mac) Chrome user agent at the launched " +
+        "Chrome's major version, stored at ~/.cache/harnery/user-agent.json and reused by every surface; never " +
+        "Linux, never HeadlessChrome. A string rewrites the store, auto refreshes it, native uses the browser's own. " +
+        "HARNERY_BROWSER_UA overrides for one environment.",
+    )
     .option(
       "--browser-arg <flag>",
       "Extra Chromium launch flag, passed straight to the browser (repeatable). " +
         "e.g. --browser-arg --disable-gpu. Also settable machine-wide via the " +
-        "HARNERY_BROWSER_ARGS env var (whitespace-separated). Under WSL, headed " +
-        "launches auto-add --disable-gpu to fix blank-window paint; opt out with " +
-        "HARNERY_BROWSER_NO_WSL_DEFAULTS=1.",
+        "HARNERY_BROWSER_ARGS env var (whitespace-separated). Under WSL, set " +
+        "HARNERY_BROWSER_WSL_DISABLE_GPU=1 to add --disable-gpu when a headed window paints blank; " +
+        "it is off by default because software WebGL is a bot tell.",
       (value: string, prev: string[] = []) => [...prev, value],
       [] as string[],
     )
@@ -376,6 +408,11 @@ export function registerBrowseCommand(
         "the expected IP is verified before the requested URL opens.",
     )
     .option("--no-cookies", "Skip cookie-jar attach and persist")
+    .option(
+      "--no-pace",
+      "Skip the human-pace gap (3 to 9 s) between page loads of the same site for this run. " +
+        "HARNERY_PACE=off disables it machine-wide; local and private hosts never wait.",
+    )
     .option("--store <path>", `Cookie store path (default ${DEFAULT_STORE})`)
     .option("--profile <dir>", `Persistent Chromium profile dir (default ${DEFAULT_PROFILE})`)
     .option(
@@ -901,20 +938,58 @@ async function runBrowse(
     );
   }
 
+  const pace = commandPaceGate(opts.pace !== false, (message) => emit.log(message, "info"));
+  if (opts.plain) {
+    if (!opts.login) throw new Error("--plain requires --login.");
+    if (opts.controlFile) {
+      throw new Error(
+        "--plain cannot take --control-file: nothing is attached to drive the window.",
+      );
+    }
+    const plainExecutable = installedChromePath();
+    const plainUa = resolveUserAgent({
+      requested: opts.userAgent,
+      env: process.env.HARNERY_BROWSER_UA,
+      chromeMajor: plainExecutable ? chromeMajorFromExecutable(plainExecutable) : undefined,
+    });
+    await pace?.before(url);
+    await runPlainLogin(url, opts.profile ?? DEFAULT_PROFILE, loginCloseFile, plainUa, emit);
+    return;
+  }
+
+  const channel = resolveBrowserChannel(opts, Boolean(headed));
+  const userAgent = resolveUserAgent({
+    requested: opts.userAgent,
+    env: process.env.HARNERY_BROWSER_UA,
+    chromeMajor: launchedChromeMajor(channel),
+  });
   const browser = new Browser({
     profileDir: opts.profile ?? DEFAULT_PROFILE,
     headed,
     jar,
-    viewport,
+    viewport: headed && !opts.viewport ? null : viewport,
     ...(deviceScaleFactor !== undefined ? { deviceScaleFactor } : {}),
     ...(colorScheme ? { colorScheme } : {}),
     navigationTimeout: Number.parseInt(opts.timeout, 10),
     waitUntil: opts.waitUntil as BrowseOpts["waitUntil"] as never,
     recordHarPath: opts.networkHar ? resolve(opts.networkHar) : undefined,
     extraHeaders: context?.extraHeaders,
+    pace,
     launchArgs: resolveLaunchArgs(opts, Boolean(headed), Boolean(proxy)),
+    ...(channel ? { channel } : {}),
+    hideAutomation: Boolean(headed),
+    ...(userAgent ? { userAgent } : {}),
     proxy,
   });
+  if (userAgent) emit.log(`Presenting as: ${userAgent}`, "debug");
+  if (headed) {
+    emit.log(
+      channel && channel !== "chromium"
+        ? `Headed session uses the installed ${channel} channel with automation signals hidden.`
+        : "Headed session uses Playwright's bundled Chromium (no Google Chrome found); automation signals hidden.",
+      "info",
+    );
+  }
 
   // Print mode: --snapshot / --html / --json all suppress file writes.
   const printMode = opts.snapshot || opts.html || opts.json;
@@ -2967,15 +3042,57 @@ function summarizeDiagnostics(diag: Diagnostics): Record<string, unknown> {
 
 /**
  * Merge Chromium launch flags from three sources, in order, de-duped:
- *   1. WSLg headed default (`--disable-gpu`) — auto-applied for headed launches
- *      under WSL so the window actually paints. Opt out with
- *      HARNERY_BROWSER_NO_WSL_DEFAULTS=1.
+ *   1. WSLg `--disable-gpu`, only when HARNERY_BROWSER_WSL_DISABLE_GPU=1. It
+ *      was the default for headed launches, but software WebGL (SwiftShader)
+ *      is a bot tell that sign-in flows screen for, and current WSLg exposes
+ *      the host GPU through D3D12, so the flag is now opt-in for machines
+ *      that still paint a blank headed window without it.
  *   2. HARNERY_BROWSER_ARGS env (whitespace-separated) — a machine-wide default.
  *   3. --browser-arg flags on this invocation (repeatable).
  */
+const BROWSER_CHANNELS = new Set(["chrome", "chrome-beta", "msedge", "chromium"]);
+
+/**
+ * Pick the browser channel: `--browser-channel`, then `HARNERY_BROWSER_CHANNEL`,
+ * then (headed only) the installed Google Chrome when one exists. Headless runs
+ * keep the bundled Chromium unless told otherwise, so QA renders stay stable.
+ */
+function resolveBrowserChannel(
+  opts: BrowseOpts,
+  headed: boolean,
+): "chrome" | "chrome-beta" | "msedge" | "chromium" | undefined {
+  const requested = (opts.browserChannel ?? process.env.HARNERY_BROWSER_CHANNEL)?.trim();
+  if (requested) {
+    if (!BROWSER_CHANNELS.has(requested)) {
+      throw new Error(
+        `Unknown --browser-channel "${requested}". Use chrome, chrome-beta, msedge, or chromium.`,
+      );
+    }
+    return requested as "chrome" | "chrome-beta" | "msedge" | "chromium";
+  }
+  return headed ? installedChromeChannel() : undefined;
+}
+
+/**
+ * Major version of the Chrome that will launch: the installed Chrome for the
+ * `chrome` channel, else Playwright's bundled Chromium. Unknown when neither
+ * answers `--version`; the user-agent store then keeps its last value.
+ */
+function launchedChromeMajor(channel: string | undefined): number | undefined {
+  if (channel === "chrome") {
+    const exe = installedChromePath();
+    return exe ? chromeMajorFromExecutable(exe) : undefined;
+  }
+  try {
+    return chromeMajorFromExecutable(chromium.executablePath());
+  } catch {
+    return undefined;
+  }
+}
+
 function resolveLaunchArgs(opts: BrowseOpts, headed: boolean, proxyEnabled: boolean): string[] {
   const args: string[] = [];
-  if (headed && !process.env.HARNERY_BROWSER_NO_WSL_DEFAULTS) {
+  if (headed && process.env.HARNERY_BROWSER_WSL_DISABLE_GPU === "1") {
     args.push(...wslHeadedLaunchArgs());
   }
   const envArgs = process.env.HARNERY_BROWSER_ARGS?.trim();
@@ -3005,6 +3122,68 @@ async function verifyBrowserProxyGate(
   emit.log(`browser proxy gate: ${observedIp} · expected IP confirmed`, "info");
 }
 
+/**
+ * `--login --plain`: spawn the installed Google Chrome directly on the shared
+ * persistent profile, with no DevTools protocol attached. Playwright enables
+ * its runtime hooks in every frame it drives, and sign-in verification vendors
+ * (X's is the reported case) detect that and fail the flow with no explanation.
+ * The person signs in here; cookies land in the same profile that later
+ * `browse` and `browse-session` runs open, so read-only captures inherit the
+ * session without ever repeating the sign-in under automation.
+ */
+async function runPlainLogin(
+  url: string,
+  profileDir: string,
+  loginCloseFile: string | null,
+  userAgent: string | undefined,
+  emit: { log: (message: string, level: "info" | "warn" | "error" | "debug") => void },
+): Promise<void> {
+  const executable = installedChromePath();
+  if (!executable) {
+    throw new Error(
+      "--plain needs an installed Google Chrome at a standard path; none was found on this machine.",
+    );
+  }
+  mkdirSync(profileDir, { recursive: true });
+  const child = spawn(
+    executable,
+    [
+      `--user-data-dir=${profileDir}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      ...(userAgent ? [`--user-agent=${userAgent}`] : []),
+      url,
+    ],
+    { stdio: "ignore" },
+  );
+  const exited = new Promise<void>((resolveExit) => {
+    child.once("exit", () => resolveExit());
+    child.once("error", () => resolveExit());
+  });
+  const lifecycleAbort = new AbortController();
+  const waits: Promise<void>[] = [exited];
+  if (loginCloseFile) {
+    emit.log(
+      `[--login --plain] Plain Google Chrome is open with nothing attached. Sign in, then close the window or create ${loginCloseFile}.`,
+      "info",
+    );
+    waits.push(waitForLoginCloseFile(loginCloseFile, lifecycleAbort.signal));
+  } else {
+    emit.log(
+      "[--login --plain] Plain Google Chrome is open with nothing attached. Sign in, then close the window or press Enter here.",
+      "info",
+    );
+    waits.push(waitForTerminalEnter(lifecycleAbort.signal));
+  }
+  await Promise.race(waits);
+  lifecycleAbort.abort();
+  if (child.exitCode === null && child.signalCode === null) {
+    child.kill("SIGTERM");
+    await Promise.race([exited, new Promise((r) => setTimeout(r, 5000))]);
+  }
+  emit.log(`[--login --plain] Chrome closed; cookies persisted in ${profileDir}.`, "info");
+}
+
 async function waitForLoginCloseFile(path: string, signal?: AbortSignal): Promise<void> {
   while (!existsSync(path) && !signal?.aborted) {
     await new Promise((resolve) => setTimeout(resolve, 250));

package/src/commands/checkpoint.ts

@@ -1,6 +1,6 @@
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
-import type { Adapter } from "../core/adapter.ts";
+import { ADAPTERS, type Adapter, normalizeAdapter } from "../core/adapter.ts";
 import { monorepoRoot, resolveOwner } from "../core/agents/index.ts";
 import { readLiveCoordinationRow } from "../core/agents/state/live-coordination-view.ts";
 import {
@@ -76,7 +76,7 @@ export function registerCheckpointCommand(
     .description("Create a durable context-continuity capsule for the current work")
     .option("--session <id>", "Session id (defaults to the current agent heartbeat)")
     .option("--instance <id>", "Agent instance id (defaults to the current owner)")
-    .option("--adapter <id>", "claude-code, codex, or cursor (inferred from heartbeat)")
+    .option("--adapter <id>", `${ADAPTERS.join(", ")} (inferred from heartbeat)`)
     .option("--reason <reason>", "manual, pressure, pre_compact, or session_end", "manual")
     .option("--note <text>", "Short continuation note for the recovered agent")
     .option("--json", "Structured JSON output")
@@ -94,7 +94,7 @@ export function registerCheckpointCommand(
           const reason = parseCheckpointReason(opts.reason);
           const identity = resolveContinuityIdentity(context, opts);
           if (!identity.adapter) {
-            throw new Error("could not infer the adapter; pass --adapter claude-code|codex|cursor");
+            throw new Error(`could not infer the adapter; pass --adapter ${ADAPTERS.join("|")}`);
           }
           const result = checkpointContext(identity.coordRoot, {
             sessionId: identity.sessionId,
@@ -166,15 +166,13 @@ function resolveContinuityIdentity(
 }
 
 function adapterFromPlatform(platform: string | undefined): Adapter | null {
-  if (platform === "claude-code") return "claude-code";
-  if (platform === "cursor") return "cursor";
-  if (platform === "codex") return "codex";
-  return null;
+  return normalizeAdapter(platform);
 }
 
 function parseAdapter(value: string): Adapter {
-  if (value === "claude-code" || value === "codex" || value === "cursor") return value;
-  throw new Error(`invalid adapter "${value}"; expected claude-code, codex, or cursor`);
+  const adapter = normalizeAdapter(value);
+  if (adapter) return adapter;
+  throw new Error(`invalid adapter "${value}"; expected one of ${ADAPTERS.join(", ")}`);
 }
 
 function parseCheckpointReason(value: string): CheckpointReason {

package/src/commands/deinit.ts

@@ -4,7 +4,7 @@
  * `init` makes two kinds of change outside the harnery package:
  *   1. Merges `agent-hook` entries into the adapter settings file
  *      (Claude Code `.claude/settings.json`, Cursor `.cursor/hooks.json`, or
- *      Codex `.codex/hooks.json`).
+ *      Codex `.codex/hooks.json`), or installs the OpenCode plugin directory.
  *   2. Creates the `.harnery/` coord root (runtime state: events, councils,
  *      identities, journal) and stamps the host bin name into
  *      `.harnery/config.jsonc`.
@@ -34,6 +34,7 @@ import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
 import { DEFAULT_BIN_NAME } from "../core/config.ts";
 import { ADAPTER_SPECS, type AdapterId } from "../core/hooks/adapter/events.ts";
+import { removeOpenCodePlugin } from "../core/hooks/adapter/opencode-plugin.ts";
 import type { SettingsFile } from "../core/hooks/adapter/wiring.ts";
 import { removeIndexerExclusions } from "../lib/indexer-exclusions.ts";
 import { removeInstructions } from "../lib/instructions/apply.ts";
@@ -62,7 +63,7 @@ export function registerDeinitCommand(program: Command, emit: EmitContext, binNa
         ".harnery/ coord root (on a terminal it asks first). Idempotent; use " +
         "--dry-run to preview.",
     )
-    .option("--adapter <id>", "claude-code | cursor | codex", "claude-code")
+    .option("--adapter <id>", "claude-code | cursor | codex | opencode", "claude-code")
     .option("--dry-run", "Show what would change without writing")
     .option("--project-root <path>", "Project root (default: git toplevel, else cwd)")
     .option("--purge-state", "Also delete the .harnery/ coord root (runtime state, destructive)")
@@ -70,7 +71,9 @@ export function registerDeinitCommand(program: Command, emit: EmitContext, binNa
       const adapter = opts.adapter as AdapterId;
       const spec = ADAPTER_SPECS[adapter];
       if (!spec) {
-        emit.text(`Unknown adapter '${opts.adapter}'. Expected: claude-code | cursor | codex.`);
+        emit.text(
+          `Unknown adapter '${opts.adapter}'. Expected: claude-code | cursor | codex | opencode.`,
+        );
         emit.setExitCode(1);
         return;
       }
@@ -97,7 +100,9 @@ export function registerDeinitCommand(program: Command, emit: EmitContext, binNa
 
       // ── 1. unwire adapter hooks ────────────────────────────────────────────
       const settingsPath = resolve(projectRoot, spec.settingsFile);
-      if (!existsSync(settingsPath)) {
+      if (spec.installMode === "opencode-plugin") {
+        actions.push(...removeOpenCodePlugin(projectRoot, dryRun));
+      } else if (!existsSync(settingsPath)) {
         actions.push(`· ${rel(projectRoot, settingsPath)} doesn't exist; no hooks to remove`);
       } else {
         let settings: SettingsFile;

package/src/commands/docs.ts

@@ -6,6 +6,7 @@ import { initDocsContext as initDocsLinks, runLinks } from "../lib/docs-links.ts
 import { initDocsContext as initDocsLint, runLint } from "../lib/docs-lint.ts";
 import { readDocsMetadata, readDocsMetadataKey } from "../lib/docs-meta.ts";
 import { initDocsMetadataAuditContext, runDocsMetadataAudit } from "../lib/docs-metadata-audit.ts";
+import { initDocsMetadataExclusions } from "../lib/docs-metadata-managed.ts";
 import { initDocsMetadataSyncContext, runDocsMetadataSync } from "../lib/docs-metadata-sync.ts";
 import { createDocsFile } from "../lib/docs-new.ts";
 import {
@@ -27,6 +28,7 @@ function ensureContext(context: HarneryProgramContext | undefined): void {
     docsRootAllowlist: context.docsRootAllowlist,
   });
   initDocsLinks({ ...opts, extraExcludedPrefixes: context.extraDocsExcludedPrefixes });
+  initDocsMetadataExclusions(context.extraDocsExcludedPrefixes);
   initDocsMetadataAuditContext(opts);
   initDocsMetadataSyncContext(opts);
   initDocsSweep(opts);

package/src/commands/doctor.ts

@@ -557,13 +557,22 @@ function checkAdapterHooks(installedAdapters: AdapterId[] = []): Check {
     if (d.invalidEventKeys.length > 0) {
       bits.push(`unsupported events (${d.invalidEventKeys.join(", ")})`);
     }
+    if (d.pluginIssues && d.pluginIssues.length > 0) {
+      // Plugin issues already name their file; render them as-is.
+      return d.pluginIssues.join("; ");
+    }
     return `${d.settingsFile}: ${bits.join("; ")}`;
   });
   for (const id of unwired) {
-    parts.push(`${ADAPTER_SPECS[id].settingsFile}: ${id} CLI installed, no harnery hooks wired`);
+    const what = ADAPTER_SPECS[id].installMode === "opencode-plugin" ? "plugin" : "hooks";
+    parts.push(`${ADAPTER_SPECS[id].settingsFile}: ${id} CLI installed, no harnery ${what} wired`);
   }
   const needsManualRepair = drift.some(
-    (d) => d.parseError || d.invalidTopLevelKeys.length > 0 || d.invalidEventKeys.length > 0,
+    (d) =>
+      d.parseError ||
+      d.invalidTopLevelKeys.length > 0 ||
+      d.invalidEventKeys.length > 0 ||
+      d.pluginIssues?.some((issue) => issue.includes("without harnery's ownership header")),
   );
   const wireHints = unwired.map((id) => `\`${bin} init --adapter ${id}\``);
   let hint: string;

package/src/commands/fetch.ts

@@ -3,8 +3,10 @@ import { homedir } from "node:os";
 import { resolve } from "node:path";
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
+import { resolveUserAgent } from "../lib/browser/user-agent.js";
 import { CookieJar } from "../lib/cookies/index.ts";
 import { fetchWithJar } from "../lib/http/index.ts";
+import { commandPaceGate } from "../lib/pace/index.ts";
 
 /**
  * `harn fetch`: HTTP request with cookie-jar attach + persist.
@@ -23,6 +25,7 @@ interface FetchOpts {
   output?: string;
   store?: string;
   cookies?: boolean;
+  pace?: boolean;
   redirect: string;
   timeout: string;
   status?: boolean;
@@ -47,6 +50,11 @@ export function registerFetchCommand(
     .option("-o, --output <file>", "Write response body to file (default: stdout)")
     .option("--store <path>", `Cookie store path (default ${DEFAULT_STORE})`)
     .option("--no-cookies", "Skip cookie-jar attach + persist")
+    .option(
+      "--no-pace",
+      "Skip the human-pace gap (3 to 9 s) between requests to the same site for this run. " +
+        "HARNERY_PACE=off disables it machine-wide; local and private hosts never wait.",
+    )
     .option("--redirect <mode>", "Redirect handling: follow | error | manual", "follow")
     .option("--timeout <ms>", "Request timeout in milliseconds", "30000")
     .option("--status", "Print status to stderr")
@@ -70,6 +78,10 @@ async function runFetch(
   context: HarneryProgramContext | undefined,
 ): Promise<void> {
   const headers: Record<string, string> = {};
+  {
+    const ua = resolveUserAgent({ env: process.env.HARNERY_BROWSER_UA });
+    if (ua) headers["User-Agent"] = ua;
+  }
   for (const h of opts.header ?? []) {
     const idx = h.indexOf(":");
     if (idx < 0) {
@@ -83,6 +95,8 @@ async function runFetch(
       ? new CookieJar({ path: opts.store ?? DEFAULT_STORE, source: "harn-fetch" })
       : null;
 
+  await commandPaceGate(opts.pace !== false, (message) => emit.log(message, "info"))?.before(url);
+
   const timeoutMs = Number.parseInt(opts.timeout, 10);
   const ac = new AbortController();
   const timer = setTimeout(() => ac.abort(), timeoutMs);