@stigmer/cli 3.0.8

package/src/resources/connect/discover.test.ts

@@ -0,0 +1,45 @@
+// Local discovery tests over a real stdio MCP subprocess fixture.
+//
+// Spawns the fixture server (node __fixtures__/stdio-server.mjs), connects via
+// the MCP SDK, and asserts the discovered tools + resource templates convert to
+// the DiscoveredCapabilities proto and render correctly. Also asserts a crashing
+// subprocess surfaces its stderr instead of hanging.
+
+import { create } from "@bufbuild/protobuf";
+import { McpServerSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/spec_pb";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { localDiscover } from "./discover.js";
+
+const FIXTURE = fileURLToPath(new URL("./__fixtures__/stdio-server.mjs", import.meta.url));
+const CRASH_FIXTURE = fileURLToPath(new URL("./__fixtures__/stdio-crash.mjs", import.meta.url));
+
+function stdioSpec(scriptPath: string) {
+  return create(McpServerSpecSchema, {
+    serverType: { case: "stdio", value: { command: process.execPath, args: [scriptPath] } },
+  });
+}
+
+describe("localDiscover (stdio subprocess)", () => {
+  it("discovers tools and resource templates and converts them to proto", async () => {
+    const caps = await localDiscover(stdioSpec(FIXTURE), [], 10_000);
+
+    expect(caps.tools.map((t) => t.name)).toEqual(["echo", "noop"]);
+    expect(caps.tools[0].description).toContain("token=unset");
+    expect(caps.tools[0].inputSchema).toBeDefined();
+
+    expect(caps.resourceTemplates).toHaveLength(1);
+    expect(caps.resourceTemplates[0].uriTemplate).toBe("file:///{path}");
+    expect(caps.resourceTemplates[0].name).toBe("local-file");
+    expect(caps.resourceTemplates[0].mimeType).toBe("text/plain");
+  }, 15_000);
+
+  it("propagates --env overrides into the spawned subprocess", async () => {
+    const caps = await localDiscover(stdioSpec(FIXTURE), ["FIXTURE_TOKEN=secret-123"], 10_000);
+    expect(caps.tools[0].description).toContain("token=secret-123");
+  }, 15_000);
+
+  it("surfaces subprocess stderr when the server crashes on startup", async () => {
+    await expect(localDiscover(stdioSpec(CRASH_FIXTURE), [], 10_000)).rejects.toThrow(/fixture boom: missing CONFIG/);
+  }, 15_000);
+});

package/src/resources/connect/discover.ts

@@ -0,0 +1,125 @@
+// Local MCP capability discovery for `connect mcp-server --dry-run`.
+//
+// Spawns/connects to the MCP server from the caller's machine (no backend push)
+// using the official @modelcontextprotocol/sdk client, lists its tools and
+// resource templates, and converts them to the same DiscoveredCapabilities proto
+// the backend returns — so dry-run and real connect render identically. Mirrors
+// Go's mcpdiscovery.Discover + CreateTransport (internal/cli/mcpdiscovery).
+//
+// stdio servers inherit process.env merged with --env overrides (override wins),
+// so credentials never leave the local machine. HTTP servers connect to the
+// configured URL with the server's static headers.
+
+import { create } from "@bufbuild/protobuf";
+import type { McpServerSpec } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/spec_pb";
+import {
+  type DiscoveredCapabilities,
+  DiscoveredCapabilitiesSchema,
+  DiscoveredResourceTemplateSchema,
+  DiscoveredToolSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/status_pb";
+import type { JsonObject } from "@bufbuild/protobuf";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { mergeProcessEnv } from "../mcp/runtime-env.js";
+
+/** Discover an MCP server's capabilities locally without persisting to the backend. */
+export async function localDiscover(
+  spec: McpServerSpec,
+  envOverrides: readonly string[],
+  timeoutMs: number,
+): Promise<DiscoveredCapabilities> {
+  const { transport, readStderr } = await buildTransport(spec, envOverrides);
+  const client = new Client({ name: "stigmer-cli", version: "1.0.0" });
+  const options = timeoutMs > 0 ? { timeout: timeoutMs } : undefined;
+
+  try {
+    await client.connect(transport, options);
+  } catch (error) {
+    // Append captured subprocess stderr so config/toolchain failures are
+    // diagnosable, mirroring Go's withStderr — without dumping raw output.
+    const stderr = readStderr();
+    const detail = stderr !== "" ? `\nsubprocess stderr:\n${stderr}` : "";
+    throw new Error(`failed to connect to MCP server: ${(error as Error).message}${detail}`);
+  }
+
+  try {
+    const { tools } = await client.listTools(undefined, options);
+    const resourceTemplates = (await client.getServerCapabilities())?.resources
+      ? (await client.listResourceTemplates(undefined, options)).resourceTemplates
+      : [];
+
+    return create(DiscoveredCapabilitiesSchema, {
+      tools: tools.map((tool) =>
+        create(DiscoveredToolSchema, {
+          name: tool.name,
+          description: tool.description ?? "",
+          inputSchema: (tool.inputSchema as JsonObject | undefined) ?? undefined,
+        }),
+      ),
+      resourceTemplates: resourceTemplates.map((template) =>
+        create(DiscoveredResourceTemplateSchema, {
+          uriTemplate: template.uriTemplate,
+          name: template.name,
+          description: template.description ?? "",
+          mimeType: template.mimeType ?? "",
+        }),
+      ),
+      lastDiscoveredAt: { seconds: BigInt(Math.floor(Date.now() / 1000)), nanos: 0 },
+    });
+  } finally {
+    await client.close();
+  }
+}
+
+interface BuiltTransport {
+  readonly transport: Transport;
+  /** Returns subprocess stderr captured so far (stdio only; "" otherwise). */
+  readStderr(): string;
+}
+
+async function buildTransport(spec: McpServerSpec, envOverrides: readonly string[]): Promise<BuiltTransport> {
+  if (spec.serverType?.case === "stdio") {
+    const { command, args, workingDir } = spec.serverType.value;
+    if (command === "") throw new Error("stdio transport requires a command");
+    const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+    const transport = new StdioClientTransport({
+      command,
+      args: [...args],
+      cwd: workingDir !== "" ? workingDir : undefined,
+      env: mergeProcessEnv([...envOverrides, ...goRunEnvOverrides(command, args)]),
+      // "pipe" exposes the child stderr as a PassThrough immediately, so we can
+      // capture diagnostics rather than leaking them to the user's terminal.
+      stderr: "pipe",
+    });
+
+    let captured = "";
+    transport.stderr?.on("data", (chunk: Buffer) => {
+      captured += chunk.toString("utf8");
+    });
+    return { transport, readStderr: () => captured.trim() };
+  }
+
+  if (spec.serverType?.case === "http") {
+    const { url, headers } = spec.serverType.value;
+    if (url === "") throw new Error("HTTP transport requires a URL");
+    const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    const requestInit = Object.keys(headers).length > 0 ? { headers: { ...headers } } : undefined;
+    const transport = new StreamableHTTPClientTransport(new URL(url), requestInit ? { requestInit } : undefined);
+    return { transport, readStderr: () => "" };
+  }
+
+  throw new Error("MCP server has no transport configured (expected stdio or http)");
+}
+
+// Go-toolchain overrides for `go run <module>@<version>` stdio commands so a
+// freshly-tagged version is usable before sum.golang.org indexes it. Mirrors
+// Go's goRunEnvOverrides. Safe: the command comes from operator-authored config.
+function goRunEnvOverrides(command: string, args: readonly string[]): string[] {
+  if (command !== "go" || args.length < 2 || args[0] !== "run") return [];
+  const pkg = args[1].split("@")[0];
+  const parts = pkg.split("/");
+  if (parts.length < 3) return [];
+  const prefix = `${parts[0]}/${parts[1]}/${parts[2]}/*`;
+  return [`GONOSUMDB=${prefix}`, `GONOSUMCHECK=${prefix}`];
+}

package/src/resources/connect/display.ts

@@ -0,0 +1,68 @@
+// Renders a connect result to the terminal. Port of Go's DisplayConnectResult
+// (connect_display.go): server identity + transport, the discovered tools and
+// resource templates, and a saved-vs-dry-run status line.
+
+import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import { styler } from "../../output/style.js";
+import type { ConnectResult } from "./connect.js";
+
+/** A sink for one display line (no trailing newline). */
+export type ConnectSink = (line: string) => void;
+
+const NAME_COLUMN = 30;
+
+export function renderConnectResult(result: ConnectResult, sink: ConnectSink, colorize: boolean): void {
+  const style = styler(colorize);
+  const meta = result.server.metadata;
+
+  sink("");
+  sink(style.cyan(`MCP Server: ${meta?.org ?? ""}/${meta?.name ?? ""}`));
+  sink(transportLine(result.server));
+  sink("");
+
+  renderTools(result, sink);
+  renderResourceTemplates(result, sink);
+
+  sink(result.updated !== undefined
+    ? style.green("✓ Connected — capabilities and tool approvals saved")
+    : style.yellow("⚠ Dry run — results not saved to backend"));
+  sink("");
+}
+
+function transportLine(server: McpServer): string {
+  const serverType = server.spec?.serverType;
+  if (serverType?.case === "stdio") return `Transport:  stdio (${serverType.value.command})`;
+  if (serverType?.case === "http") return `Transport:  http (${serverType.value.url})`;
+  return "Transport:  (unknown)";
+}
+
+function renderTools(result: ConnectResult, sink: ConnectSink): void {
+  const tools = result.capabilities?.tools ?? [];
+  sink(`Tools (${tools.length}):`);
+  if (tools.length === 0) {
+    sink("  (none)");
+  } else {
+    for (const tool of tools) {
+      sink(tool.description !== "" ? `  ${pad(tool.name)} ${tool.description}` : `  ${tool.name}`);
+    }
+  }
+  sink("");
+}
+
+function renderResourceTemplates(result: ConnectResult, sink: ConnectSink): void {
+  const templates = result.capabilities?.resourceTemplates ?? [];
+  sink(`Resource Templates (${templates.length}):`);
+  if (templates.length === 0) {
+    sink("  (none)");
+  } else {
+    for (const template of templates) {
+      sink(`  ${pad(template.name)} ${template.uriTemplate}`);
+    }
+  }
+  sink("");
+}
+
+// Left-justify a name to the fixed column width, mirroring Go's "%-30s".
+function pad(name: string): string {
+  return name.length >= NAME_COLUMN ? name : name + " ".repeat(NAME_COLUMN - name.length);
+}

package/src/resources/connect/oauth.test.ts

@@ -0,0 +1,155 @@
+import { create } from "@bufbuild/protobuf";
+import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import type { Stigmer } from "@stigmer/sdk";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { UsageError } from "../../errors/index.js";
+import {
+  browserCommand,
+  DEFAULT_CLOUD_CONSOLE_URL,
+  resolveConsoleURL,
+  runOAuthFlow,
+  waitForOAuthGrant,
+  type OAuthFlowDeps,
+} from "./oauth.js";
+
+const server = create(McpServerSchema, {
+  metadata: { id: "mcp_1", slug: "github", name: "GitHub" },
+});
+
+// A fake client whose getOAuthGrantStatus reports `connected` once the call
+// count reaches `connectOnCall` (1 = first poll). Records the call count.
+function fakeClient(connectOnCall: number): { client: Stigmer; calls: () => number } {
+  let calls = 0;
+  const client = {
+    mcpServer: {
+      getOAuthGrantStatus: async () => {
+        calls += 1;
+        return { connected: calls >= connectOnCall };
+      },
+    },
+  } as unknown as Stigmer;
+  return { client, calls: () => calls };
+}
+
+const noopSleep = async (): Promise<void> => {};
+
+describe("resolveConsoleURL", () => {
+  it("prefers the STIGMER_CONSOLE_URL override", () => {
+    expect(resolveConsoleURL("cloud", { STIGMER_CONSOLE_URL: "https://console.example" } as NodeJS.ProcessEnv)).toBe(
+      "https://console.example",
+    );
+  });
+
+  it("uses the local web-console port for the local backend", () => {
+    expect(resolveConsoleURL("local", {} as NodeJS.ProcessEnv)).toBe("http://localhost:8234");
+  });
+
+  it("uses the cloud console URL for the cloud backend", () => {
+    expect(resolveConsoleURL("cloud", {} as NodeJS.ProcessEnv)).toBe(DEFAULT_CLOUD_CONSOLE_URL);
+  });
+});
+
+describe("browserCommand", () => {
+  it("maps each supported platform to its opener", () => {
+    expect(browserCommand("darwin", "https://x")).toEqual(["open", ["https://x"]]);
+    expect(browserCommand("linux", "https://x")).toEqual(["xdg-open", ["https://x"]]);
+    expect(browserCommand("win32", "https://x")).toEqual(["rundll32", ["url.dll,FileProtocolHandler", "https://x"]]);
+  });
+
+  it("returns no command for unsupported platforms", () => {
+    expect(browserCommand("aix", "https://x")[0]).toBeUndefined();
+  });
+});
+
+describe("waitForOAuthGrant", () => {
+  it("resolves once the grant connects on a later poll", async () => {
+    const { client, calls } = fakeClient(3);
+    const deps: OAuthFlowDeps = {
+      client,
+      server,
+      org: "acme",
+      backendType: "cloud",
+      now: () => 0,
+      sleep: noopSleep,
+      log: () => {},
+    };
+    await expect(waitForOAuthGrant(deps)).resolves.toBeUndefined();
+    expect(calls()).toBe(3);
+  });
+
+  it("throws a UsageError when the poll window elapses", async () => {
+    const { client, calls } = fakeClient(Number.POSITIVE_INFINITY);
+    // First now() seeds the deadline; the next jumps past it to force a timeout
+    // before any grant check runs.
+    const clock = [0, 10 * 60 * 1000];
+    const deps: OAuthFlowDeps = {
+      client,
+      server,
+      org: "acme",
+      backendType: "cloud",
+      now: () => clock.shift() ?? 10 * 60 * 1000,
+      sleep: noopSleep,
+      log: () => {},
+    };
+    await expect(waitForOAuthGrant(deps)).rejects.toThrow(UsageError);
+    expect(calls()).toBe(0);
+  });
+});
+
+describe("runOAuthFlow", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("opens the org's MCP-server page then waits for the grant", async () => {
+    const { client } = fakeClient(1);
+    const openBrowser = vi.fn(async () => {});
+    await runOAuthFlow({
+      client,
+      server,
+      org: "acme",
+      backendType: "cloud",
+      openBrowser,
+      now: () => 0,
+      sleep: noopSleep,
+      log: () => {},
+    });
+    expect(openBrowser).toHaveBeenCalledWith("https://app.stigmer.ai/acme/mcp-servers/github");
+  });
+
+  it("aborts before opening the browser when the local console is unreachable", async () => {
+    const { client } = fakeClient(1);
+    const openBrowser = vi.fn(async () => {});
+    await expect(
+      runOAuthFlow({
+        client,
+        server,
+        org: "acme",
+        backendType: "local",
+        probeConsole: async () => false,
+        openBrowser,
+        now: () => 0,
+        sleep: noopSleep,
+        log: () => {},
+      }),
+    ).rejects.toThrow(UsageError);
+    expect(openBrowser).not.toHaveBeenCalled();
+  });
+
+  it("opens the local console page when the probe succeeds", async () => {
+    const { client } = fakeClient(1);
+    const openBrowser = vi.fn(async () => {});
+    await runOAuthFlow({
+      client,
+      server,
+      org: "acme",
+      backendType: "local",
+      probeConsole: async () => true,
+      openBrowser,
+      now: () => 0,
+      sleep: noopSleep,
+      log: () => {},
+    });
+    expect(openBrowser).toHaveBeenCalledWith("http://localhost:8234/acme/mcp-servers/github");
+  });
+});

package/src/resources/connect/oauth.ts

@@ -0,0 +1,191 @@
+// Interactive OAuth browser flow for `connect mcp-server`. Mirrors Go's
+// internal/cli/mcpserver/oauth.go: resolve the web console URL, (in local mode)
+// probe that the console is reachable, open the org's MCP-server page so the
+// user can grant access, then poll getOAuthGrantStatus until the grant lands or
+// a 5-minute timeout elapses.
+//
+// Token acquisition and audit identity stay server-side by design; the CLI only
+// shepherds the user to the console and waits for the backend to report success.
+//
+// Every side effect (browser open, console probe, clock, sleep, log sink) is
+// injectable so the poll loop and URL resolution are unit-testable without a
+// real browser, network, or wall-clock delay.
+
+import { create } from "@bufbuild/protobuf";
+import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import { GetOAuthGrantStatusInputSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/io_pb";
+import type { Stigmer } from "@stigmer/sdk";
+import type { BackendType } from "../../config/config.js";
+import { UsageError } from "../../errors/index.js";
+import { WEB_CONSOLE_PORT } from "../../local/constants.js";
+
+/** Well-known URL for the Stigmer Cloud web console. */
+export const DEFAULT_CLOUD_CONSOLE_URL = "https://app.stigmer.ai";
+
+const POLL_INTERVAL_MS = 3000;
+const POLL_TIMEOUT_MS = 5 * 60 * 1000;
+const CONSOLE_PROBE_TIMEOUT_MS = 2000;
+
+/** Injectable side effects + inputs for {@link runOAuthFlow}. */
+export interface OAuthFlowDeps {
+  readonly client: Stigmer;
+  readonly server: McpServer;
+  readonly org: string;
+  readonly backendType: BackendType;
+  /** Opens the page URL in the user's browser. Defaults to the OS opener. */
+  readonly openBrowser?: (url: string) => Promise<void>;
+  /** Probes whether the local web console is reachable. Defaults to a 2s GET. */
+  readonly probeConsole?: (url: string) => Promise<boolean>;
+  /** Current epoch ms. Injectable for deterministic timeout tests. */
+  readonly now?: () => number;
+  /** Sleep helper. Injectable so tests don't wait real seconds. */
+  readonly sleep?: (ms: number) => Promise<void>;
+  /** Human-facing log sink (stderr by default, so stdout stays machine-clean). */
+  readonly log?: (line: string) => void;
+}
+
+/**
+ * Run the full interactive OAuth flow: probe (local), open the console, and
+ * wait for the grant. Throws a {@link UsageError} if the local console is
+ * unreachable or the wait times out.
+ */
+export async function runOAuthFlow(deps: OAuthFlowDeps): Promise<void> {
+  const log = deps.log ?? stderrLog;
+  const consoleURL = resolveConsoleURL(deps.backendType);
+
+  if (deps.backendType === "local") {
+    const probe = deps.probeConsole ?? probeWebConsole;
+    if (!(await probe(consoleURL))) throw consoleUnavailableError(deps.server.metadata?.slug ?? "<slug>");
+  }
+
+  const slug = deps.server.metadata?.slug ?? "";
+  const name = deps.server.metadata?.name ?? slug;
+  const pageURL = `${consoleURL}/${deps.org}/mcp-servers/${slug}`;
+
+  log(`OAuth authentication required for '${name}'.`);
+  log("Opening web console to complete authentication...");
+  log(`\n  If the browser doesn't open automatically, visit:\n  ${pageURL}\n`);
+
+  const open = deps.openBrowser ?? openInBrowser;
+  try {
+    await open(pageURL);
+  } catch {
+    log("  Could not open browser automatically. Please open the URL above in your browser.");
+  }
+
+  await waitForOAuthGrant(deps);
+}
+
+/**
+ * Poll getOAuthGrantStatus every 3s until the grant is connected or the
+ * 5-minute timeout elapses. Throws a {@link UsageError} on timeout.
+ */
+export async function waitForOAuthGrant(deps: OAuthFlowDeps): Promise<void> {
+  const log = deps.log ?? stderrLog;
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? defaultSleep;
+  const serverId = deps.server.metadata?.id ?? "";
+  const deadline = now() + POLL_TIMEOUT_MS;
+
+  log("Waiting for OAuth connection... (press Ctrl+C to cancel)");
+
+  for (;;) {
+    await sleep(POLL_INTERVAL_MS);
+    if (now() >= deadline) {
+      throw new UsageError("timed out waiting for OAuth connection — please try again");
+    }
+    if (await checkOAuthGrant(deps.client, serverId, deps.org)) {
+      log("OAuth connection established.\n");
+      return;
+    }
+  }
+}
+
+/** Query the backend for an existing/just-created OAuth grant. */
+export async function checkOAuthGrant(client: Stigmer, mcpServerId: string, org: string): Promise<boolean> {
+  const status = await client.mcpServer.getOAuthGrantStatus(
+    create(GetOAuthGrantStatusInputSchema, { resourceId: mcpServerId, org }),
+  );
+  return status.connected;
+}
+
+/**
+ * Resolve the web console URL:
+ *   1. `STIGMER_CONSOLE_URL` (explicit override)
+ *   2. local backend → `http://localhost:{WEB_CONSOLE_PORT}`
+ *   3. cloud backend → {@link DEFAULT_CLOUD_CONSOLE_URL}
+ */
+export function resolveConsoleURL(backendType: BackendType, env: NodeJS.ProcessEnv = process.env): string {
+  const override = env.STIGMER_CONSOLE_URL;
+  if (override !== undefined && override !== "") return override;
+  if (backendType === "local") return `http://localhost:${WEB_CONSOLE_PORT}`;
+  return DEFAULT_CLOUD_CONSOLE_URL;
+}
+
+// Probe the local web console with a short-timeout GET. Any HTTP response (even
+// an error status) means it's serving; a network/timeout failure means it isn't.
+async function probeWebConsole(url: string): Promise<boolean> {
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(CONSOLE_PROBE_TIMEOUT_MS) });
+    // Drain the body so the socket can close promptly.
+    await response.body?.cancel();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Interactive OAuth needs a web console to host the grant page. The TS CLI does
+// not serve a local console, so for a local backend we steer the user to the two
+// real alternatives — manual credentials, or Stigmer Cloud's hosted console —
+// rather than telling them to enable a console that does not exist locally.
+function consoleUnavailableError(slug: string): UsageError {
+  return new UsageError(
+    "Interactive OAuth via the web console isn't available for a local backend.\n\n" +
+      "To connect this MCP server, either:\n" +
+      `  - Provide credentials directly: stigmer connect mcp-server ${slug} --env TOKEN=...\n` +
+      "  - Or use Stigmer Cloud's hosted console: stigmer config backend set cloud",
+  );
+}
+
+// Open a URL in the user's default browser. Mirrors Go's browser.Open: a
+// platform-specific launcher, no new dependency. Callers print the URL first so
+// a launch failure still leaves the user a way forward.
+function openInBrowser(url: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    void (async () => {
+      const { spawn } = await import("node:child_process");
+      const [command, args] = browserCommand(process.platform, url);
+      if (command === undefined) {
+        reject(new Error(`unsupported platform: ${process.platform}`));
+        return;
+      }
+      const child = spawn(command, args, { stdio: "ignore", detached: true });
+      child.once("error", reject);
+      child.unref();
+      resolve();
+    })().catch(reject);
+  });
+}
+
+/** The OS-specific command + args to open a URL. Exported for tests. */
+export function browserCommand(platform: NodeJS.Platform, url: string): [string | undefined, string[]] {
+  switch (platform) {
+    case "darwin":
+      return ["open", [url]];
+    case "win32":
+      return ["rundll32", ["url.dll,FileProtocolHandler", url]];
+    case "linux":
+      return ["xdg-open", [url]];
+    default:
+      return [undefined, []];
+  }
+}
+
+function defaultSleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function stderrLog(line: string): void {
+  process.stderr.write(`${line}\n`);
+}