pome-sh 0.6.6

package/dist/src/cli/init-sdk.d.ts

@@ -0,0 +1,15 @@
+export declare const SUPPORTED_SDKS: readonly ["claude", "claude-managed"];
+export type SupportedSdk = (typeof SUPPORTED_SDKS)[number];
+export interface ScaffoldResult {
+    agentSdkValue: string;
+    agentCommand: string;
+    exampleAgentRelativePath: string;
+    postInstallHint: string;
+}
+export declare function writeSdkScaffold(sdk: SupportedSdk): Promise<ScaffoldResult>;
+export declare class ClaudeSdkDeferredError extends Error {
+    constructor();
+}
+export declare class ClaudeManagedDeferredError extends Error {
+    constructor();
+}

package/dist/src/cli/init-sdk.js

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Per-SDK scaffold writers for `pome init --sdk <name>`. Each writer produces
+// a minimal-but-runnable starter set so a Claude Agent SDK / OpenAI Agents /
+// other-framework user reaches a green hosted run in under five minutes.
+//
+// Both `claude` and `claude-managed` are deferral stubs right now:
+//   - `claude` scaffolds an import from `@pome-sh/adapter-claude-sdk`, which is
+//     held back from npm until OSS Launch Stage 1. Without the package, the
+//     scaffolded file dies at `pome run` with "Cannot find module …". Defer
+//     the flag until the publish unblocks it.
+//   - `claude-managed` is waiting on Anthropic's Managed Agents API (v2).
+// Add new SDKs by appending a writer in SCAFFOLDS below.
+//
+// See the Claude Agent SDK integration plan (internal docs).
+export const SUPPORTED_SDKS = ["claude", "claude-managed"];
+export async function writeSdkScaffold(sdk) {
+    switch (sdk) {
+        case "claude":
+            // Deferred — the scaffolded file imports `@pome-sh/adapter-claude-sdk`,
+            // which is held back from npm until OSS Launch Stage 1. Until then the
+            // scaffold dies at runtime with "Cannot find module …". Recommend the
+            // bundled scripted starter (`pome init` without --sdk) for now.
+            throw new ClaudeSdkDeferredError();
+        case "claude-managed":
+            // Deferred — surface reserved so v2 doesn't churn the flag.
+            throw new ClaudeManagedDeferredError();
+    }
+}
+export class ClaudeSdkDeferredError extends Error {
+    constructor() {
+        super("Claude Agent SDK scaffold is gated on the npm publish of " +
+            "`@pome-sh/adapter-claude-sdk`, tracked under OSS Launch Stage 1. " +
+            "Run `pome init` (without --sdk) for the bundled scripted starter, " +
+            "or write your own agent against POME_TASK / POME_GITHUB_REST_URL.");
+        this.name = "ClaudeSdkDeferredError";
+    }
+}
+export class ClaudeManagedDeferredError extends Error {
+    constructor() {
+        super("Claude Managed Agent is not yet supported — three blockers " +
+            "(no injection point inside Anthropic-hosted runtime, no sidechannel " +
+            "for adapter signals, Managed Agents API still moving). Follow the " +
+            "tracking issue for v2 timing. For now, use `pome init` (without --sdk).");
+        this.name = "ClaudeManagedDeferredError";
+    }
+}

package/dist/src/cli/install.d.ts

@@ -0,0 +1,30 @@
+import { type LoginOptions } from "./login.js";
+/** First message of the interactive session. The skill carries the wiring
+ *  knowledge; this only names it, sets adapter-first, and fixes the exit
+ *  contract (pome verifies with doctor after the session ends). */
+export declare const KICKOFF_PROMPT: string;
+/** Self-contained fallback prompt for users without a detected coding agent
+ *  (their agent won't have the pome-setup skill installed). */
+export declare const PASTE_PROMPT: string;
+export interface InstallOptions {
+    apiUrl: string;
+    dashboardUrl: string;
+    /** Repo root the session wires. Defaults to process.cwd(). */
+    cwd?: string;
+    /** Test seam — forwarded to resolveCredentials. */
+    credentialsPath?: string;
+    /** Test seam — defaults to process.stdin.isTTY. */
+    stdinIsTTY?: boolean;
+    /** Test seam — defaults to a readline [y/N] prompt on stderr. */
+    confirm?: (question: string) => Promise<boolean>;
+    /** Test seam — defaults to loginWithClerk (opens a browser). */
+    login?: (options: LoginOptions) => Promise<void>;
+}
+export declare function runInstall(options: InstallOptions): Promise<void>;
+export interface DetectedAgent {
+    bin: string;
+    label: string;
+    path: string;
+}
+/** First known coding agent found on PATH, or null. Exported for tests. */
+export declare function detectAgent(env?: Record<string, string | undefined>): DetectedAgent | null;

package/dist/src/cli/install.js

@@ -0,0 +1,233 @@
+// SPDX-License-Identifier: Apache-2.0
+// FDRS-642 — `pome install`: agent-driven wiring with the diff gate in the
+// coding agent's own edit-approval UI.
+//
+// v1 is skills-first thin orchestration (see the ticket's [DECISION]): the
+// wiring brain is the user's own coding agent, invoked interactively — not
+// an embedded SDK, not a pome-hosted LLM gateway. The CLI's job is the
+// bracket around that session:
+//
+//   auth check → detect agent → git-as-undo guard → ensure the pome-setup
+//   skill → interactive session (the user approves edits in the agent's own
+//   UI) → doctor verify to green (CLI moments 02, "verifying the wiring").
+//
+// No coding agent on PATH → print manual wiring steps + a paste-into-any-
+// agent prompt and exit 0 (the designed fallback, not a failure). Doctor
+// red after the session → named cause + fix, exit 1. The terminal-rendered
+// file-list + diff + [y/N] gate from moment 02 is deferred to FDRS-661; the
+// pome-setup skill written for this cut is the knowledge layer both reuse.
+import { execFile, spawn } from "node:child_process";
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { createInterface } from "node:readline";
+import { promisify } from "node:util";
+import { HostedAuthError } from "../hosted/errors.js";
+import { resolveCredentials } from "./credentials.js";
+import { loginWithClerk } from "./login.js";
+import { runSkillsInstall } from "./skills.js";
+const execFileAsync = promisify(execFile);
+/** Coding agents `pome install` can hand off to, in detection order. */
+const KNOWN_AGENTS = [{ bin: "claude", label: "Claude Code" }];
+/** First message of the interactive session. The skill carries the wiring
+ *  knowledge; this only names it, sets adapter-first, and fixes the exit
+ *  contract (pome verifies with doctor after the session ends). */
+export const KICKOFF_PROMPT = "Use the pome-setup skill to wire this repository to pome (adapter-first: " +
+    "withPome() + env-injected base URL). Follow the skill's steps and show me " +
+    "each edit for approval before applying. When the wiring is done, exit " +
+    "this session — pome will verify it with `pome doctor`.";
+/** Self-contained fallback prompt for users without a detected coding agent
+ *  (their agent won't have the pome-setup skill installed). */
+export const PASTE_PROMPT = [
+    "Wire this repository to pome (https://pome.sh) so its agent runs against a twin in test:",
+    "1. If pome.config.json is missing, run `pome init`; set agent.command to how this agent starts.",
+    "2. Claude Agent SDK repos: add @pome-sh/adapter-claude-sdk, import query/tool from it (drop-in replacements), and call withPome() once at startup.",
+    "3. Replace every hardcoded production API host (e.g. https://api.github.com) with the env the pome runner injects: read POME_GITHUB_REST_URL / POME_GITHUB_MCP_URL and POME_AUTH_TOKEN from process.env. Never write secrets or URLs into source.",
+    "4. Make minimal, targeted edits and show each diff for approval before applying.",
+    "5. Finish by running `pome doctor` and fixing its named cause until it exits green.",
+].join("\n");
+export async function runInstall(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const stdinIsTTY = options.stdinIsTTY ?? Boolean(process.stdin.isTTY);
+    const confirm = options.confirm ?? promptYesNo;
+    const login = options.login ?? loginWithClerk;
+    // Interactive by design: the whole point is handing THIS terminal to an
+    // agent session the user supervises. A pipe can't approve edits.
+    if (!stdinIsTTY) {
+        console.error("pome install is interactive — it hands your terminal to a coding agent session.");
+        console.error("Run it from a terminal. For unattended setups, wire manually: see `pome docs`.");
+        process.exitCode = 2;
+        return;
+    }
+    console.error("pome will wire your agent to a twin in test.");
+    console.error("");
+    // 1. Auth first — auth happens at this journey stage (Done-when bullet 1).
+    // Logging in here means neither the agent session nor anything after it
+    // trips over missing credentials.
+    try {
+        await resolveCredentials({
+            apiBaseUrl: options.apiUrl,
+            credentialsPath: options.credentialsPath,
+        });
+        console.error("✓ signed in");
+    }
+    catch (err) {
+        if (!(err instanceof HostedAuthError))
+            throw err;
+        console.error("no pome credentials found — routing through pome login first.");
+        await login({
+            apiUrl: options.apiUrl,
+            dashboardUrl: options.dashboardUrl,
+            keyName: "pome install",
+        });
+    }
+    // 2. Detect the coding agent before the git guard: the fallback path edits
+    // nothing, so an unclean tree shouldn't block it.
+    const agent = detectAgent(process.env);
+    if (!agent) {
+        printManualFallback();
+        return; // exit 0 — the designed no-agent outcome, not a failure.
+    }
+    // 3. Git-as-undo guard. The session edits files and git is the only
+    // rollback — make that precondition explicit instead of assuming it.
+    const tree = await inspectWorkingTree(cwd);
+    if (tree === "dirty") {
+        console.error("");
+        console.error("this repo has uncommitted changes. the agent session edits files, and its");
+        console.error("edits will mix with yours — git is the only undo for an agent mis-edit.");
+        if (!(await confirm("continue anyway? (commit or stash first is safer) [y/N] "))) {
+            console.error("aborted — nothing changed. commit or stash, then re-run pome install.");
+            return;
+        }
+    }
+    else if (tree === "not-a-repo") {
+        console.error("");
+        console.error("this directory is not a git repository — if the agent session mis-edits a");
+        console.error("file, there is NO undo.");
+        if (!(await confirm("continue without version control? [y/N] "))) {
+            console.error("aborted — nothing changed. git init && git add -A && git commit, then re-run.");
+            return;
+        }
+    }
+    // 4. Ensure the pome-setup skill is where the agent looks for it
+    // (~/.claude/skills/, symlinked to this install; skips if present).
+    console.error("");
+    await runSkillsInstall({});
+    if (process.exitCode === 2) {
+        // runSkillsInstall signals failure (no ~/.claude, packaging problem) via
+        // exitCode — the session would run without the skill, so hand the user
+        // the manual path instead. Keep exit 2: unlike the no-agent fallback,
+        // this is a real environment problem.
+        console.error("");
+        console.error("couldn't install the pome-setup skill — falling back to manual steps.");
+        printManualFallback();
+        return;
+    }
+    // 5. Hand off. stdio inherit = the user drives the agent in this terminal;
+    // the diff gate is the agent's own edit-approval UI (deliberately no
+    // --permission-mode override).
+    console.error("");
+    console.error(`handing off to ${agent.label} — review and approve its edits in the session.`);
+    console.error("exit the session when the wiring is done; pome verifies it after.");
+    console.error("");
+    const sessionExit = await runAgentSession(agent.path, [KICKOFF_PROMPT], cwd);
+    if (sessionExit !== 0) {
+        console.error(`(${agent.label} exited ${sessionExit} — verifying anyway; doctor is the source of truth.)`);
+    }
+    // 6. The ending pome's terminal owns: doctor verify to green (moment 02).
+    // Dynamic import keeps the twin harness out of the way until needed —
+    // same pattern as the `doctor` and `run` commands.
+    console.error("");
+    const { runDoctorChecks } = await import("../doctor/checks.js");
+    const { renderDoctorReport } = await import("../doctor/render.js");
+    const report = await runDoctorChecks({ mode: "full", cwd });
+    for (const line of renderDoctorReport(report, { header: "verifying the wiring …" })) {
+        console.error(line);
+    }
+    console.error("");
+    if (report.ok) {
+        console.error("wiring verified — your agent is ready.");
+        console.error("");
+        console.error("next: pome scenarios github --copy      # pull runnable scenarios into ./scenarios/");
+        console.error("      pome run scenarios/01-bug-happy-path.md");
+        return;
+    }
+    console.error("the agent session ended but the wiring isn't green — fix the cause above,");
+    console.error("or re-run pome install to hand the fix back to your agent.");
+    process.exitCode = 1;
+}
+/** First known coding agent found on PATH, or null. Exported for tests. */
+export function detectAgent(env = process.env) {
+    for (const agent of KNOWN_AGENTS) {
+        const found = findExecutableOnPath(agent.bin, env);
+        if (found)
+            return { ...agent, path: found };
+    }
+    return null;
+}
+function findExecutableOnPath(bin, env) {
+    const names = process.platform === "win32" ? [`${bin}.cmd`, `${bin}.exe`, bin] : [bin];
+    for (const dir of (env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of names) {
+            const candidate = join(dir, name);
+            try {
+                accessSync(candidate, constants.X_OK);
+                if (statSync(candidate).isFile())
+                    return candidate;
+            }
+            catch {
+                /* keep looking */
+            }
+        }
+    }
+    return null;
+}
+async function inspectWorkingTree(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["status", "--porcelain"], {
+            cwd,
+        });
+        return stdout.trim().length === 0 ? "clean" : "dirty";
+    }
+    catch {
+        // Not a git repo, or no git binary — either way there is no undo.
+        return "not-a-repo";
+    }
+}
+async function promptYesNo(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        const answer = await new Promise((resolve) => rl.question(question, resolve));
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+function runAgentSession(command, args, cwd) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(command, args, { cwd, stdio: "inherit" });
+        child.once("error", rejectPromise);
+        child.once("exit", (code, signal) => {
+            resolvePromise(code ?? (signal ? 1 : 0));
+        });
+    });
+}
+function printManualFallback() {
+    console.error(`no coding agent found on PATH (looked for: ${KNOWN_AGENTS.map((a) => a.bin).join(", ")}).`);
+    console.error("");
+    console.error("wire it manually:");
+    console.error("  1. config       pome init                  # if pome.config.json is missing;");
+    console.error("                                              # then set agent.command to your agent's start command");
+    console.error("  2. adapter      npm install @pome-sh/adapter-claude-sdk");
+    console.error('  3. hook + env   import { withPome } from "@pome-sh/adapter-claude-sdk"; withPome();');
+    console.error("                  read the twin URL from env, never hardcode:");
+    console.error("                  const { POME_GITHUB_REST_URL: baseUrl, POME_AUTH_TOKEN: token } = process.env;");
+    console.error("  4. verify       pome doctor                # must end green");
+    console.error("");
+    console.error("or paste this into any coding agent:");
+    console.error("─".repeat(72));
+    console.error(PASTE_PROMPT);
+    console.error("─".repeat(72));
+}

package/dist/src/cli/keychain.d.ts

@@ -0,0 +1,5 @@
+import type { CredentialsFile } from "./credentials.js";
+export declare function keychainSupported(): boolean;
+export declare function writeKeychainCredentials(creds: Required<Pick<CredentialsFile, "api_key" | "api_url" | "dashboard_url" | "team_id">>): Promise<void>;
+export declare function readKeychainCredentials(): Promise<CredentialsFile | null>;
+export declare function deleteKeychainCredentials(): Promise<boolean>;

package/dist/src/cli/keychain.js

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * macOS Keychain helpers for hosted credentials (no extra native npm deps).
+ * Uses the `security` CLI. On other platforms all functions no-op / return false.
+ *
+ * Service name is stable so `security` UI and docs can reference it.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const SERVICE = "sh.pome.cli";
+const ACCOUNT = "hosted";
+export function keychainSupported() {
+    if (process.env.POME_CLI_DISABLE_KEYCHAIN === "1")
+        return false;
+    return process.platform === "darwin";
+}
+export async function writeKeychainCredentials(creds) {
+    if (!keychainSupported())
+        return;
+    const payload = JSON.stringify({
+        api_key: creds.api_key,
+        api_url: creds.api_url,
+        dashboard_url: creds.dashboard_url,
+        team_id: creds.team_id,
+        created_at: new Date().toISOString(),
+    });
+    await execFileAsync("security", [
+        "add-generic-password",
+        "-U",
+        "-s",
+        SERVICE,
+        "-a",
+        ACCOUNT,
+        "-w",
+        payload,
+    ]);
+}
+export async function readKeychainCredentials() {
+    if (!keychainSupported())
+        return null;
+    try {
+        const { stdout } = await execFileAsync("security", [
+            "find-generic-password",
+            "-s",
+            SERVICE,
+            "-a",
+            ACCOUNT,
+            "-w",
+        ]);
+        const text = stdout.trim();
+        if (!text)
+            return null;
+        const parsed = JSON.parse(text);
+        if (typeof parsed.api_key !== "string" || !parsed.api_key.trim()) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function deleteKeychainCredentials() {
+    if (!keychainSupported())
+        return false;
+    try {
+        await execFileAsync("security", [
+            "delete-generic-password",
+            "-s",
+            SERVICE,
+            "-a",
+            ACCOUNT,
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/cli/login.d.ts

@@ -0,0 +1,6 @@
+export interface LoginOptions {
+    apiUrl: string;
+    dashboardUrl: string;
+    keyName: string;
+}
+export declare function loginWithClerk(options: LoginOptions): Promise<void>;

package/dist/src/cli/login.js

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: Apache-2.0
+import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { persistCredentialsAfterLogin } from "./credentials.js";
+export async function loginWithClerk(options) {
+    const state = randomBytes(16).toString("base64url");
+    const callback = await startCallbackServer(state);
+    const loginUrl = new URL("/cli/login", normalizeBaseUrl(options.dashboardUrl));
+    loginUrl.searchParams.set("redirect_uri", callback.redirectUri);
+    loginUrl.searchParams.set("state", state);
+    console.error("Opening Clerk sign-in in your browser…");
+    console.error(String(loginUrl));
+    await openBrowser(String(loginUrl));
+    let codeResult;
+    try {
+        codeResult = await callback.waitForCode();
+    }
+    finally {
+        await callback.close();
+    }
+    const exchanged = await exchangeCode({
+        apiUrl: normalizeBaseUrl(options.apiUrl),
+        code: codeResult.code,
+        keyName: options.keyName,
+    });
+    if (!exchanged.api_key?.full_key || !exchanged.team_id) {
+        throw new Error("CLI login exchange returned an unexpected response.");
+    }
+    const { stored, path } = await persistCredentialsAfterLogin({
+        api_key: exchanged.api_key.full_key,
+        api_url: normalizeBaseUrl(options.apiUrl),
+        dashboard_url: normalizeBaseUrl(options.dashboardUrl),
+        team_id: exchanged.team_id,
+    });
+    if (stored === "keychain") {
+        console.error("Saved Pome credentials in macOS Keychain.");
+    }
+    else if (path) {
+        console.error(`Saved Pome credentials to ${path}`);
+    }
+    console.error("Pome login complete.");
+    console.error("Next: `pome session create --twin github` or `pome run <scenario>.md`");
+}
+async function exchangeCode(input) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 60_000);
+    let response;
+    try {
+        response = await fetch(`${normalizeBaseUrl(input.apiUrl)}/v1/auth/cli/exchange`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ code: input.code, key_name: input.keyName }),
+            signal: ctrl.signal,
+        });
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+            throw new Error("CLI login exchange timed out (60s). Check network and API URL, then run `pome login` again.");
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    const raw = await response.text();
+    let json = {};
+    try {
+        json = raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        if (!response.ok) {
+            throw new Error(`CLI login exchange failed: HTTP ${response.status}`);
+        }
+        throw new Error("CLI login exchange returned invalid JSON.");
+    }
+    if (!response.ok) {
+        const message = json.error?.message ??
+            `HTTP ${response.status}`;
+        throw new Error(`CLI login exchange failed: ${message}. Run \`pome login\` again for a fresh code.`);
+    }
+    return json;
+}
+async function startCallbackServer(expectedState) {
+    let server = null;
+    let resolveCode = null;
+    let rejectCode = null;
+    let settled = false;
+    let deliveredCode = false;
+    const codePromise = new Promise((resolve, reject) => {
+        resolveCode = resolve;
+        rejectCode = reject;
+    });
+    const fail = (err) => {
+        if (settled)
+            return;
+        settled = true;
+        rejectCode?.(err);
+    };
+    const succeed = (code) => {
+        if (deliveredCode)
+            return;
+        deliveredCode = true;
+        if (settled)
+            return;
+        settled = true;
+        resolveCode?.({ code });
+    };
+    server = createServer((req, res) => {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error && state === expectedState) {
+            res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+            res.end("<h1>Pome login failed</h1><p>You can close this tab.</p>");
+            fail(new Error(`Browser reported error: ${error}`));
+            void closeServer(server);
+            return;
+        }
+        if (!code || state !== expectedState) {
+            res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+            res.end("<h1>Invalid login callback</h1><p>State did not match — close this tab and run <code>pome login</code> again.</p>");
+            return;
+        }
+        if (deliveredCode) {
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            res.end("<h1>Already complete</h1><p>You can close this tab.</p>");
+            return;
+        }
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end("<h1>Pome login complete</h1><p>You can close this tab.</p>");
+        succeed(code);
+        void closeServer(server);
+    });
+    await new Promise((resolve, reject) => {
+        server?.once("error", reject);
+        server?.listen(0, "127.0.0.1", resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("Failed to bind local login callback server.");
+    }
+    const timeout = setTimeout(() => {
+        fail(new Error("Timed out waiting for browser login (5 min). Run `pome login` again."));
+        void closeServer(server);
+    }, 5 * 60 * 1000);
+    timeout.unref();
+    const onInt = () => {
+        fail(new Error("Login cancelled (Ctrl+C). No credentials were changed."));
+        void closeServer(server);
+    };
+    process.once("SIGINT", onInt);
+    codePromise.finally(() => {
+        clearTimeout(timeout);
+        process.off("SIGINT", onInt);
+    });
+    return {
+        redirectUri: `http://127.0.0.1:${address.port}/callback`,
+        waitForCode() {
+            return codePromise;
+        },
+        async close() {
+            clearTimeout(timeout);
+            process.off("SIGINT", onInt);
+            await closeServer(server);
+        },
+    };
+}
+function closeServer(server) {
+    return new Promise((resolve) => {
+        server?.close(() => resolve());
+    });
+}
+async function openBrowser(url) {
+    const command = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "powershell.exe"
+            : "xdg-open";
+    const args = process.platform === "win32"
+        ? ["-NoProfile", "-Command", "Start-Process", url]
+        : [url];
+    await new Promise((resolve) => {
+        execFile(command, args, (error) => {
+            if (error) {
+                console.error("Could not open a browser automatically — copy the URL above into a browser.");
+            }
+            resolve();
+        });
+    });
+}
+function normalizeBaseUrl(raw) {
+    return new URL(raw).toString().replace(/\/$/, "");
+}

package/dist/src/cli/main.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+export declare function createProgram(): Command;