@bli-cockpit/cli 0.1.0

package/dist/commands/local.js

@@ -0,0 +1,699 @@
+import { createCollectorServer } from "../server.js";
+import { DEFAULT_DASHBOARD_URL, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, startLocalWorkContext, } from "../local-state.js";
+import { syncLocalAmbientEnvelope } from "../upload.js";
+export const rootCommandNames = new Set([
+    "onboard",
+    "install",
+    "login",
+    "pair",
+    "logout",
+    "start",
+    "sync",
+    "status",
+    "serve",
+]);
+export async function runLocalCockpitCli(argv, io = defaultIo()) {
+    let command;
+    try {
+        command = parseLocalArgs(argv);
+    }
+    catch (error) {
+        writeLine(io.stderr, errorMessage(error));
+        writeLine(io.stderr, "");
+        writeLine(io.stderr, localCommandHelp());
+        return 1;
+    }
+    try {
+        switch (command.kind) {
+            case "install":
+                return await runInstall(command, io);
+            case "onboard":
+                return await runOnboard(command, io);
+            case "login":
+                return await runLogin(command, io);
+            case "logout":
+                return await runLogout(command, io);
+            case "start":
+                return await runStart(command, io);
+            case "sync":
+                return await runSync(command, io);
+            case "status":
+                return await runStatus(command, io);
+            case "serve":
+                return await runServe(command, io);
+        }
+    }
+    catch (error) {
+        writeLine(io.stderr, errorMessage(error));
+        return 1;
+    }
+}
+export function localCommandHelp() {
+    return [
+        "  cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--repo <path>]",
+        "  cockpit install [--dashboard-url <url>] [--repo <path>]",
+        "  cockpit login [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>]",
+        "  cockpit pair [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>]",
+        "  cockpit logout",
+        "  cockpit start [--ticket <id>] [--repo <path>] [--branch <name>]",
+        "  cockpit sync [--repo <path>] [--dashboard-url <url>]",
+        "  cockpit status [--repo <path>]",
+        "  cockpit serve [--port <port>] [--repo <path>]",
+    ].join("\n");
+}
+function parseLocalArgs(argv) {
+    const command = argv[0];
+    switch (command) {
+        case "onboard":
+            return parseOnboardArgs(argv.slice(1));
+        case "install":
+            return parseInstallArgs(argv.slice(1));
+        case "login":
+        case "pair":
+            return parseLoginArgs(argv.slice(1));
+        case "logout":
+            return parseLogoutArgs(argv.slice(1));
+        case "start":
+            return parseStartArgs(argv.slice(1));
+        case "sync":
+            return parseSyncArgs(argv.slice(1));
+        case "status":
+            return parseStatusArgs(argv.slice(1));
+        case "serve":
+            return parseServeArgs(argv.slice(1));
+        default:
+            throw new Error(`Unknown local command: ${command ?? ""}`);
+    }
+}
+function parseOnboardArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--repo",
+            "--dashboard-url",
+            "--email",
+            "--device-name",
+            "--ticket",
+            "--branch",
+            "--json",
+            "--poll-interval-ms",
+            "--timeout-ms",
+        ],
+        valueFlags: [
+            "--home",
+            "--repo",
+            "--dashboard-url",
+            "--email",
+            "--device-name",
+            "--ticket",
+            "--branch",
+            "--poll-interval-ms",
+            "--timeout-ms",
+        ],
+    });
+    assertNoPositionals(values.positionals, "onboard");
+    return {
+        kind: "onboard",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        repoRoot: optionalNonEmpty(values.flags.get("--repo")),
+        dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
+        claimedOwnerEmail: optionalEmail(values.flags.get("--email")),
+        deviceName: optionalNonEmpty(values.flags.get("--device-name")),
+        activeTicketId: optionalNonEmpty(values.flags.get("--ticket")),
+        branch: optionalNonEmpty(values.flags.get("--branch")),
+        json: values.booleans.has("--json"),
+        pollIntervalMs: optionalPositiveInteger(values.flags.get("--poll-interval-ms"), "--poll-interval-ms"),
+        timeoutMs: optionalPositiveInteger(values.flags.get("--timeout-ms"), "--timeout-ms"),
+    };
+}
+function parseInstallArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--repo",
+            "--dashboard-url",
+            "--supabase-url",
+            "--json",
+        ],
+        valueFlags: ["--home", "--repo", "--dashboard-url", "--supabase-url"],
+    });
+    assertNoPositionals(values.positionals, "install");
+    return {
+        kind: "install",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        repoRoot: optionalNonEmpty(values.flags.get("--repo")),
+        dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
+        supabaseUrl: optionalNonEmpty(values.flags.get("--supabase-url")),
+        json: values.booleans.has("--json"),
+    };
+}
+function parseLoginArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--email",
+            "--device-name",
+            "--json",
+            "--poll-interval-ms",
+            "--timeout-ms",
+        ],
+        valueFlags: [
+            "--home",
+            "--dashboard-url",
+            "--email",
+            "--device-name",
+            "--poll-interval-ms",
+            "--timeout-ms",
+        ],
+    });
+    assertNoPositionals(values.positionals, "login");
+    return {
+        kind: "login",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        claimedOwnerEmail: optionalEmail(values.flags.get("--email")),
+        deviceName: optionalNonEmpty(values.flags.get("--device-name")),
+        json: values.booleans.has("--json"),
+        pollIntervalMs: optionalPositiveInteger(values.flags.get("--poll-interval-ms"), "--poll-interval-ms"),
+        timeoutMs: optionalPositiveInteger(values.flags.get("--timeout-ms"), "--timeout-ms"),
+    };
+}
+function parseLogoutArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--json"],
+        valueFlags: ["--home"],
+    });
+    assertNoPositionals(values.positionals, "logout");
+    return {
+        kind: "logout",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        json: values.booleans.has("--json"),
+    };
+}
+function parseStartArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--repo",
+            "--branch",
+            "--ticket",
+            "--operator-id",
+            "--session-id",
+            "--json",
+        ],
+        valueFlags: [
+            "--home",
+            "--repo",
+            "--branch",
+            "--ticket",
+            "--operator-id",
+            "--session-id",
+        ],
+    });
+    assertNoPositionals(values.positionals, "start");
+    return {
+        kind: "start",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        repoRoot: optionalNonEmpty(values.flags.get("--repo")),
+        branch: optionalNonEmpty(values.flags.get("--branch")),
+        activeTicketId: optionalNonEmpty(values.flags.get("--ticket")),
+        operatorId: optionalNonEmpty(values.flags.get("--operator-id")),
+        sessionId: optionalNonEmpty(values.flags.get("--session-id")),
+        json: values.booleans.has("--json"),
+    };
+}
+function parseSyncArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--repo", "--dashboard-url", "--json"],
+        valueFlags: ["--home", "--repo", "--dashboard-url"],
+    });
+    assertNoPositionals(values.positionals, "sync");
+    return {
+        kind: "sync",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        repoRoot: optionalNonEmpty(values.flags.get("--repo")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        json: values.booleans.has("--json"),
+    };
+}
+function parseStatusArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--repo", "--json"],
+        valueFlags: ["--home", "--repo"],
+    });
+    assertNoPositionals(values.positionals, "status");
+    return {
+        kind: "status",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        repoRoot: optionalNonEmpty(values.flags.get("--repo")),
+        json: values.booleans.has("--json"),
+    };
+}
+function parseServeArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--repo", "--port"],
+        valueFlags: ["--home", "--repo", "--port"],
+    });
+    assertNoPositionals(values.positionals, "serve");
+    const port = Number(values.flags.get("--port") ?? "4174");
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error("--port must be a TCP port between 1 and 65535.");
+    }
+    return {
+        kind: "serve",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        repoRoot: optionalNonEmpty(values.flags.get("--repo")),
+        port,
+    };
+}
+function parseNamedArgs(args, options) {
+    const allowed = new Set(options.allowedFlags);
+    const valueFlags = new Set(options.valueFlags);
+    const flags = new Map();
+    const booleans = new Set();
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        rejectServiceRoleLikeArgument(arg);
+        if (!arg.startsWith("--")) {
+            positionals.push(arg);
+            continue;
+        }
+        const [flag, inlineValue] = arg.split("=", 2);
+        if (!allowed.has(flag))
+            throw new Error(`Unknown flag: ${flag}`);
+        if (valueFlags.has(flag)) {
+            const value = inlineValue ?? args[index + 1];
+            if (!value || value.startsWith("--")) {
+                throw new Error(`${flag} requires a value.`);
+            }
+            rejectServiceRoleLikeArgument(value);
+            flags.set(flag, value);
+            if (inlineValue === undefined)
+                index += 1;
+        }
+        else {
+            if (inlineValue !== undefined)
+                throw new Error(`${flag} does not accept a value.`);
+            booleans.add(flag);
+        }
+    }
+    return { flags, booleans, positionals };
+}
+async function runInstall(command, io) {
+    const result = await installLocalCollector(command);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(result, null, 2));
+        return 0;
+    }
+    writeLine(io.stdout, "Cockpit local collector installed.");
+    writeLine(io.stdout, `Config: ${result.paths.config_file}`);
+    writeLine(io.stdout, `Session: ${result.paths.session_file}`);
+    writeLine(io.stdout, "Auth: missing; upload stays local-only until pairing/login.");
+    writeLine(io.stdout, "Next: run `cockpit login`, then `cockpit start --ticket <id>`.");
+    return 0;
+}
+async function runOnboard(command, io) {
+    let install = null;
+    let pair = null;
+    let sync = null;
+    let status = null;
+    try {
+        if (!command.json) {
+            writeLine(io.stdout, "Cockpit harvest onboarding");
+            writeLine(io.stdout, `Dashboard: ${command.dashboardUrl}`);
+            writeLine(io.stdout, `Ticket: ${command.activeTicketId ?? "general ambient"}`);
+        }
+        install = await installLocalCollector({
+            homeDir: command.homeDir,
+            repoRoot: command.repoRoot,
+            dashboardUrl: command.dashboardUrl,
+            deviceName: command.deviceName,
+        });
+        if (!command.json) {
+            writeLine(io.stdout, "1/5 Installed local collector.");
+            writeLine(io.stdout, `Config: ${install.paths.config_file}`);
+        }
+        const installedStatus = await inspectLocalCollectorStatus({
+            homeDir: command.homeDir,
+            repoRoot: command.repoRoot,
+            branch: command.branch,
+        });
+        if (installedStatus.session_state === "valid") {
+            if (!command.json) {
+                writeLine(io.stdout, "2/5 Existing valid device session found; pairing skipped.");
+            }
+        }
+        else {
+            pair = await pairLocalCollector({
+                homeDir: command.homeDir,
+                dashboardUrl: command.dashboardUrl,
+                claimedOwnerEmail: command.claimedOwnerEmail,
+                deviceName: command.deviceName,
+                pollIntervalMs: command.pollIntervalMs,
+                timeoutMs: command.timeoutMs,
+                fetch: io.fetch,
+                onPairStarted: command.json
+                    ? undefined
+                    : (request) => writePairingInstructions(io, request),
+            });
+            if (!command.json) {
+                writeLine(io.stdout, "2/5 Device paired.");
+                writeLine(io.stdout, `User: ${pair.session.email ?? pair.session.auth_subject_id}`);
+                writeLine(io.stdout, `Device: ${pair.session.device_name ?? pair.session.device_id ?? "unknown"}`);
+            }
+        }
+        const context = await startLocalWorkContext({
+            homeDir: command.homeDir,
+            repoRoot: command.repoRoot,
+            branch: command.branch,
+            activeTicketId: command.activeTicketId,
+        });
+        if (!command.json) {
+            writeLine(io.stdout, "3/5 Work context active.");
+            writeLine(io.stdout, `Repo: ${context.repo}`);
+            writeLine(io.stdout, `Branch: ${context.branch}`);
+            writeLine(io.stdout, `Ticket: ${context.active_ticket_id ?? "general ambient"}`);
+            writeLine(io.stdout, `Context: ${context.work_context_id}`);
+        }
+        sync = await syncLocalAmbientEnvelope({
+            homeDir: command.homeDir,
+            repoRoot: command.repoRoot,
+            dashboardUrl: command.dashboardUrl,
+            fetch: io.fetch,
+        });
+        status = await inspectLocalCollectorStatus({
+            homeDir: command.homeDir,
+            repoRoot: command.repoRoot,
+            branch: command.branch,
+        });
+        if (sync.status !== "uploaded") {
+            if (command.json) {
+                writeLine(io.stdout, JSON.stringify(onboardResult("blocked", command, install, pair, sync, status), null, 2));
+            }
+            else {
+                writeLine(io.stderr, "BLOCKED: ambient upload failed; safe retry metadata was spooled.");
+                writeLine(io.stderr, `Failure: ${sync.failure_reason}`);
+                writeLine(io.stderr, `Retry: ${sync.retry_command}`);
+            }
+            return 1;
+        }
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify(onboardResult("pass", command, install, pair, sync, status), null, 2));
+            return 0;
+        }
+        writeLine(io.stdout, "4/5 Ambient metadata uploaded.");
+        writeLine(io.stdout, `HTTP: ${sync.http_status}`);
+        writeLine(io.stdout, `Facts: ${sync.event_count}`);
+        writeLine(io.stdout, `Sources: ${sync.source_scan_count}`);
+        writeLine(io.stdout, `Risk flags: ${sync.risk_flag_count}`);
+        writeLine(io.stdout, "5/5 Status ready.");
+        writeLine(io.stdout, `Upload state: ${status.upload_state}`);
+        writeLine(io.stdout, "PASS: Cockpit collector is ready for harvest.");
+        writeLine(io.stdout, `Open: ${command.dashboardUrl}/my-work`);
+        return 0;
+    }
+    catch (error) {
+        const message = errorMessage(error);
+        status = await inspectLocalCollectorStatus({
+            homeDir: command.homeDir,
+            repoRoot: command.repoRoot,
+            branch: command.branch,
+        }).catch(() => null);
+        const blocker = classifyOnboardBlocker(message);
+        const nextStep = nextStepForOnboardBlocker(blocker);
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                ...onboardResult("blocked", command, install, pair, sync, status),
+                blocker,
+                message,
+                next_step: nextStep,
+            }, null, 2));
+        }
+        else {
+            writeLine(io.stderr, `BLOCKED: ${message}`);
+            writeLine(io.stderr, `Next: ${nextStep}`);
+        }
+        return 1;
+    }
+}
+async function runLogin(command, io) {
+    const result = await pairLocalCollector({
+        homeDir: command.homeDir,
+        dashboardUrl: command.dashboardUrl,
+        claimedOwnerEmail: command.claimedOwnerEmail,
+        deviceName: command.deviceName,
+        pollIntervalMs: command.pollIntervalMs,
+        timeoutMs: command.timeoutMs,
+        fetch: io.fetch,
+        onPairStarted: command.json
+            ? undefined
+            : (request) => {
+                writeLine(io.stdout, "Cockpit device pairing started.");
+                writeLine(io.stdout, `Open: ${request.approve_url}`);
+                writeLine(io.stdout, `Code: ${request.user_code}`);
+                writeLine(io.stdout, "Waiting for dashboard approval...");
+            },
+    });
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(result, null, 2));
+        return 0;
+    }
+    writeLine(io.stdout, "Cockpit collector paired.");
+    writeLine(io.stdout, `Session: ${result.session_file}`);
+    writeLine(io.stdout, `User: ${result.session.email ?? result.session.auth_subject_id}`);
+    writeLine(io.stdout, `Device: ${result.session.device_name ?? result.session.device_id ?? "unknown"}`);
+    writeLine(io.stdout, "Next: run `cockpit start` inside the repo.");
+    return 0;
+}
+function writePairingInstructions(io, request) {
+    writeLine(io.stdout, "2/5 Device pairing started.");
+    writeLine(io.stdout, `Open: ${request.approve_url}`);
+    writeLine(io.stdout, `Code: ${request.user_code}`);
+    writeLine(io.stdout, "Waiting for dashboard approval...");
+}
+function onboardResult(resultStatus, command, install, pair, sync, status) {
+    return {
+        status: resultStatus,
+        dashboard_url: command.dashboardUrl,
+        ticket_id: sync?.ticket_id ?? command.activeTicketId ?? null,
+        work_context_id: sync?.work_context_id ?? status?.work_context_id ?? null,
+        config_file: install?.paths.config_file ?? status?.config_file ?? null,
+        session_file: install?.paths.session_file ?? status?.session_file ?? null,
+        paired_user: pair?.session.email ?? pair?.session.auth_subject_id ?? null,
+        paired_device: pair?.session.device_name ?? pair?.session.device_id ?? null,
+        upload_status: sync?.status ?? null,
+        upload_state: status?.upload_state ?? null,
+        event_count: sync?.event_count ?? null,
+        source_scan_count: sync?.source_scan_count ?? null,
+        risk_flag_count: sync?.risk_flag_count ?? null,
+        pending_upload_count: status?.pending_upload_count ?? null,
+        last_upload_success_at: status?.last_upload_success_at ?? null,
+        next_dashboard_path: `${command.dashboardUrl}/my-work`,
+    };
+}
+function classifyOnboardBlocker(message) {
+    if (/ticket/i.test(message))
+        return "ticket";
+    if (/pair|paired|approval|expired|revoked/i.test(message))
+        return "device_pairing";
+    if (/fetch|network|ENOTFOUND|ECONNREFUSED|HTTP/i.test(message))
+        return "network_or_ingest";
+    if (/config|install/i.test(message))
+        return "install";
+    if (/context|start/i.test(message))
+        return "work_context";
+    if (/bound|binding/i.test(message))
+        return "ticket_binding";
+    return "unknown";
+}
+function nextStepForOnboardBlocker(blocker) {
+    switch (blocker) {
+        case "ticket":
+        case "ticket_binding":
+            return "Run `cockpit start --ticket <id>` when actual ticket work begins, then run `cockpit sync`.";
+        case "device_pairing":
+            return "Open the pairing URL, approve the exact code in Cockpit, then rerun `cockpit onboard`.";
+        case "network_or_ingest":
+            return "Check dashboard URL/network, then run `cockpit sync --json` or rerun `cockpit onboard`.";
+        case "install":
+            return "Rerun `cockpit onboard` from the repo root; it will reinstall local config.";
+        case "work_context":
+            return "Run `cockpit start --ticket <id> --repo \"$PWD\"`, then retry `cockpit sync`.";
+        default:
+            return "Run `cockpit status --json` and report the blocker label plus last failure reason.";
+    }
+}
+async function runLogout(command, io) {
+    const result = await logoutLocalCollector({ homeDir: command.homeDir });
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(result, null, 2));
+        return 0;
+    }
+    writeLine(io.stdout, result.removed
+        ? "Cockpit collector session removed."
+        : "No Cockpit collector session found.");
+    return 0;
+}
+async function runStart(command, io) {
+    const context = await startLocalWorkContext(command);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(context, null, 2));
+        return 0;
+    }
+    writeLine(io.stdout, "Cockpit work context active.");
+    writeLine(io.stdout, `Repo: ${context.repo}`);
+    writeLine(io.stdout, `Branch: ${context.branch}`);
+    writeLine(io.stdout, `Ticket: ${displayTicketId(context.active_ticket_id)}`);
+    writeLine(io.stdout, `Context: ${context.work_context_id}`);
+    return 0;
+}
+async function runSync(command, io) {
+    const result = await syncLocalAmbientEnvelope({
+        homeDir: command.homeDir,
+        repoRoot: command.repoRoot,
+        dashboardUrl: command.dashboardUrl,
+        fetch: io.fetch,
+    });
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(result, null, 2));
+        return result.status === "uploaded" ? 0 : 1;
+    }
+    if (result.status === "uploaded") {
+        writeLine(io.stdout, "Cockpit ambient envelope uploaded.");
+        writeLine(io.stdout, `Ticket: ${displayTicketId(result.ticket_id)}`);
+        writeLine(io.stdout, `Context: ${result.work_context_id}`);
+        writeLine(io.stdout, `Facts: ${result.event_count}`);
+        writeLine(io.stdout, `Risk flags: ${result.risk_flag_count}`);
+        return 0;
+    }
+    writeLine(io.stderr, "Cockpit ambient upload failed; safe retry metadata was spooled.");
+    writeLine(io.stderr, `Ticket: ${displayTicketId(result.ticket_id)}`);
+    writeLine(io.stderr, `Failure: ${result.failure_reason}`);
+    writeLine(io.stderr, `Retry: ${result.retry_command}`);
+    return 1;
+}
+async function runStatus(command, io) {
+    const status = await inspectLocalCollectorStatus(command);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(status, null, 2));
+        return 0;
+    }
+    writeLine(io.stdout, "Cockpit local status");
+    writeLine(io.stdout, `installed: ${status.installed}`);
+    writeLine(io.stdout, `session_state: ${status.session_state}`);
+    writeLine(io.stdout, `repo: ${status.repo}`);
+    writeLine(io.stdout, `branch: ${status.branch}`);
+    writeLine(io.stdout, `ticket: ${displayTicketId(status.active_ticket_id)}`);
+    writeLine(io.stdout, `collector_freshness: ${status.collector_freshness}`);
+    writeLine(io.stdout, `upload_state: ${status.upload_state}`);
+    writeLine(io.stdout, `last_upload_attempt: ${status.last_upload_attempt_at ?? "never"}`);
+    writeLine(io.stdout, `last_upload_success: ${status.last_upload_success_at ?? "never"}`);
+    writeLine(io.stdout, `last_upload_failure: ${status.last_upload_failure_reason ?? "none"}`);
+    writeLine(io.stdout, `pending_uploads: ${status.pending_upload_count}`);
+    for (const detail of status.details)
+        writeLine(io.stdout, `- ${detail}`);
+    return 0;
+}
+function displayTicketId(ticketId) {
+    return ticketId ?? "general ambient";
+}
+async function runServe(command, io) {
+    const server = createCollectorServer(command);
+    await new Promise((resolve) => {
+        server.listen(command.port, "127.0.0.1", resolve);
+    });
+    writeLine(io.stdout, `Cockpit collector serving on http://127.0.0.1:${command.port}`);
+    await new Promise((resolve) => {
+        server.on("close", resolve);
+    });
+    return 0;
+}
+function assertNoPositionals(positionals, command) {
+    if (positionals.length > 0) {
+        throw new Error(`${command} does not accept positional arguments.`);
+    }
+}
+function optionalNonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function optionalUrl(value) {
+    return value === undefined ? undefined : normalizeUrl(value);
+}
+function optionalEmail(value) {
+    const trimmed = value?.trim().toLowerCase();
+    if (!trimmed)
+        return undefined;
+    if (!trimmed.includes("@")) {
+        throw new Error("--email must be a valid email address.");
+    }
+    return trimmed;
+}
+function optionalPositiveInteger(value, flag) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`${flag} must be a positive integer.`);
+    }
+    return parsed;
+}
+function normalizeUrl(value) {
+    const trimmed = value.trim().replace(/\/+$/, "");
+    if (!trimmed)
+        throw new Error("URL value cannot be empty.");
+    return trimmed;
+}
+function rejectServiceRoleLikeArgument(value) {
+    if (!looksLikeServiceRoleSecret(value))
+        return;
+    throw new Error("Service-role credentials are not accepted by local collector commands.");
+}
+function looksLikeServiceRoleSecret(value) {
+    if (serviceCredentialNamePattern().test(value))
+        return true;
+    const parts = value.split(".");
+    if (parts.length !== 3)
+        return false;
+    try {
+        const payload = Buffer.from(base64UrlToBase64(parts[1] ?? ""), "base64").toString("utf8");
+        return serviceCredentialPayloadPattern().test(payload);
+    }
+    catch {
+        return false;
+    }
+}
+function serviceCredentialNamePattern() {
+    return new RegExp([
+        ["SUPABASE", "SERVICE", "ROLE", "KEY"].join("[_-]?"),
+        ["service", "role"].join("[_-]?"),
+    ].join("|"), "i");
+}
+function serviceCredentialPayloadPattern() {
+    const privilegedRole = ["service", "role"].join("_");
+    return new RegExp(`"role"\\s*:\\s*"${privilegedRole}"`);
+}
+function base64UrlToBase64(value) {
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    return `${normalized}${"=".repeat((4 - (normalized.length % 4)) % 4)}`;
+}
+function defaultIo() {
+    if (!globalThis.fetch) {
+        throw new Error("global fetch is unavailable; use Node.js 20 or newer.");
+    }
+    return {
+        stdin: process.stdin,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        env: process.env,
+        fetch: globalThis.fetch.bind(globalThis),
+    };
+}
+function writeLine(stream, text) {
+    stream.write(`${text}\n`);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}