waitspin 0.1.0

package/dist/cli.js

@@ -0,0 +1,675 @@
+#!/usr/bin/env node
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { constants as fsConstants } from "node:fs";
+import { access, cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const DEFAULT_BASE_URL = process.env.WAITSPIN_BASE_URL?.trim() || "https://api.waitspin.com";
+const REQUEST_TIMEOUT_MS = 30_000;
+const extensionTargets = {
+    vscode: "vscode",
+};
+export function usageText() {
+    return ([
+        "Usage:",
+        "  waitspin init --email you@example.com [--code CODE] [--key-profile control|publisher-extension] [--base-url URL]",
+        "  waitspin bid create --line TEXT --url https://example.com --price-per-block CENTS --blocks N [--base-url URL] [--api-key KEY]",
+        "  waitspin bids list [--base-url URL] [--api-key KEY]",
+        "  waitspin bid checkout <campaign-id> [--base-url URL] [--api-key KEY]",
+        "  waitspin market [--base-url URL]",
+        "  waitspin wallet status [--base-url URL] [--api-key KEY]",
+        "  waitspin wallet connect [--base-url URL] [--api-key KEY]",
+        "  waitspin wallet ledger [--limit N] [--base-url URL] [--api-key KEY]",
+        "  waitspin wallet payout --dry-run [--base-url URL] [--api-key KEY]",
+        "  waitspin wallet payout --confirm-test-transfer [--base-url URL] [--api-key KEY]",
+        "  waitspin extension install [--target vscode] [--base-url URL] [--api-key KEY] [--dry-run]",
+        "  waitspin extension status [--target vscode]",
+        "  waitspin extension uninstall [--target vscode] [--dry-run]",
+        "",
+        "Defaults:",
+        "  API base: https://api.waitspin.com",
+        "  API key: WAITSPIN_API_KEY env var",
+        "  Public extension target: VS Code status-bar fallback",
+    ].join("\n") + "\n");
+}
+function usage(exitCode = 1) {
+    const output = usageText();
+    if (exitCode === 0) {
+        process.stdout.write(output);
+    }
+    else {
+        process.stderr.write(output);
+    }
+    process.exit(exitCode);
+}
+function parseArgs(argv) {
+    if (argv.length === 0) {
+        usage();
+    }
+    const [command, ...rest] = argv;
+    if (command === "help" || command === "--help" || command === "-h") {
+        usage(0);
+    }
+    const flags = new Map();
+    const positionals = [];
+    for (let index = 0; index < rest.length; index += 1) {
+        const token = rest[index];
+        if (!token)
+            continue;
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const key = token.slice(2);
+        if (key === "help") {
+            usage(0);
+        }
+        if (key === "dry-run" ||
+            key === "allow-debug-auto-verify" ||
+            key === "confirm-test-transfer") {
+            flags.set(key, ["true"]);
+            continue;
+        }
+        const next = rest[index + 1];
+        if (next === undefined) {
+            throw new Error(`Missing value for --${key}`);
+        }
+        const existing = flags.get(key) || [];
+        existing.push(next);
+        flags.set(key, existing);
+        index += 1;
+    }
+    return { command, flags, positionals };
+}
+function requireFlag(flags, name) {
+    const value = flags.get(name)?.[0]?.trim();
+    if (!value) {
+        throw new Error(`Missing required flag --${name}`);
+    }
+    return value;
+}
+function optionalFlag(flags, name) {
+    const value = flags.get(name)?.[0]?.trim();
+    return value || undefined;
+}
+function booleanFlag(flags, name) {
+    return flags.get(name)?.[0] === "true";
+}
+function resolveBaseUrl(flags) {
+    return optionalFlag(flags, "base-url") || DEFAULT_BASE_URL;
+}
+function resolveApiKey(flags) {
+    return optionalFlag(flags, "api-key") || process.env.WAITSPIN_API_KEY?.trim();
+}
+function resolveKeyIntendedUse(flags) {
+    const explicitProfile = optionalFlag(flags, "key-profile");
+    if (!explicitProfile) {
+        return null;
+    }
+    if (explicitProfile === "publisher-extension") {
+        return "key_profile:publisher_extension";
+    }
+    if (explicitProfile === "control") {
+        return "key_profile:control";
+    }
+    throw new Error("--key-profile must be control or publisher-extension");
+}
+function requireApiKey(flags) {
+    const apiKey = resolveApiKey(flags);
+    if (!apiKey) {
+        throw new Error("Missing API key. Set WAITSPIN_API_KEY or pass --api-key");
+    }
+    return apiKey;
+}
+function timeoutSignal() {
+    return AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+}
+class WaitSpinCliHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+async function requestJson(input, init) {
+    const response = await fetch(input, { ...init, signal: timeoutSignal() });
+    const text = await response.text();
+    if (response.status === 204 || !text) {
+        return { status: response.status, body: null };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(text);
+    }
+    catch {
+        if (!response.ok) {
+            throw new WaitSpinCliHttpError(response.status, `HTTP ${response.status}: upstream returned a non-JSON error response`);
+        }
+        throw new Error("Invalid JSON response from WaitSpin API");
+    }
+    if (!response.ok) {
+        throw new WaitSpinCliHttpError(response.status, `HTTP ${response.status}: ${JSON.stringify(payload).slice(0, 500)}`);
+    }
+    return { status: response.status, body: payload };
+}
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+async function runInit(flags) {
+    const baseUrl = resolveBaseUrl(flags);
+    const email = requireFlag(flags, "email");
+    const intendedUse = resolveKeyIntendedUse(flags);
+    const providedCode = optionalFlag(flags, "code") ||
+        process.env.WAITSPIN_VERIFICATION_CODE?.trim();
+    if (providedCode) {
+        const { body } = await requestJson(`${baseUrl}/v1/keys/verify`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                email,
+                code: providedCode,
+                ...(intendedUse ? { intended_use: intendedUse } : {}),
+            }),
+        });
+        printJson({ ok: true, base_url: baseUrl, ...body });
+        return;
+    }
+    const { body: requestResult } = await requestJson(`${baseUrl}/v1/keys/request`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            email,
+            ...(intendedUse ? { intended_use: intendedUse } : {}),
+        }),
+    });
+    const code = requestResult?.verification_debug_code;
+    const allowDebugAutoVerify = booleanFlag(flags, "allow-debug-auto-verify") ||
+        process.env.WAITSPIN_ALLOW_DEBUG_CODE_AUTO_VERIFY === "1";
+    if (!code || !allowDebugAutoVerify) {
+        printJson({
+            ok: true,
+            next: "check_email_for_code",
+            delivery: requestResult?.delivery,
+            email,
+            debug_code_available: Boolean(code),
+        });
+        return;
+    }
+    const { body: verifyResult } = await requestJson(`${baseUrl}/v1/keys/verify`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            email,
+            code,
+            ...(intendedUse ? { intended_use: intendedUse } : {}),
+        }),
+    });
+    printJson({ ok: true, base_url: baseUrl, ...verifyResult });
+}
+async function runBidCreate(flags) {
+    const baseUrl = resolveBaseUrl(flags);
+    const apiKey = requireApiKey(flags);
+    const adLine = requireFlag(flags, "line");
+    const destinationUrl = requireFlag(flags, "url");
+    const pricePerBlockCents = Number(requireFlag(flags, "price-per-block"));
+    const blocks = Number(requireFlag(flags, "blocks"));
+    if (!Number.isFinite(pricePerBlockCents) || pricePerBlockCents < 100) {
+        throw new Error("--price-per-block must be at least 100 cents");
+    }
+    if (!Number.isFinite(blocks) || blocks < 1) {
+        throw new Error("--blocks must be at least 1");
+    }
+    const { body } = await requestJson(`${baseUrl}/v1/campaigns`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+            "Idempotency-Key": randomUUID(),
+        },
+        body: JSON.stringify({
+            ad_line: adLine,
+            destination_url: destinationUrl,
+            price_per_block_cents: pricePerBlockCents,
+            blocks,
+        }),
+    });
+    printJson({ ok: true, ...body });
+}
+async function runBidsList(flags) {
+    const baseUrl = resolveBaseUrl(flags);
+    const apiKey = requireApiKey(flags);
+    const { body } = await requestJson(`${baseUrl}/v1/campaigns`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    printJson({ ok: true, campaigns: body?.campaigns ?? [] });
+}
+async function runBidCheckout(flags, positionals) {
+    const campaignId = positionals[0]?.trim();
+    if (!campaignId) {
+        throw new Error("Usage: waitspin bid checkout <campaign-id>");
+    }
+    const baseUrl = resolveBaseUrl(flags);
+    const apiKey = requireApiKey(flags);
+    const { body } = await requestJson(`${baseUrl}/v1/blocks/checkout`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({ campaign_id: campaignId }),
+    });
+    printJson({
+        ok: true,
+        ...body,
+        checkout_disclosure: {
+            terms_url: "https://waitspin.com/waitspin/terms",
+            privacy_url: "https://waitspin.com/waitspin/privacy",
+            refund_policy: "Unused prepaid blocks are account credit unless a cash refund is required by law or approved through support review. Self-serve cash refund requests are not shipped.",
+        },
+    });
+}
+async function runMarket(flags) {
+    const baseUrl = resolveBaseUrl(flags);
+    const { body } = await requestJson(`${baseUrl}/v1/market`, { method: "GET" });
+    printJson({ ok: true, ...body });
+}
+async function runWalletStatus(flags) {
+    const baseUrl = resolveBaseUrl(flags);
+    const apiKey = requireApiKey(flags);
+    const { body } = await requestJson(`${baseUrl}/v1/wallet/status`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    printJson({ ok: true, ...body });
+}
+async function runWalletConnect(flags) {
+    const baseUrl = resolveBaseUrl(flags);
+    const apiKey = requireApiKey(flags);
+    const { body } = await requestJson(`${baseUrl}/v1/wallet/connect`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    printJson({ ok: true, ...body });
+}
+async function runWalletLedger(flags) {
+    const baseUrl = resolveBaseUrl(flags);
+    const apiKey = requireApiKey(flags);
+    const limit = optionalFlag(flags, "limit");
+    const url = new URL(`${baseUrl}/v1/wallet/ledger`);
+    if (limit) {
+        url.searchParams.set("limit", limit);
+    }
+    const { body } = await requestJson(url.toString(), {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    printJson({ ok: true, ...body });
+}
+async function runWalletPayout(flags) {
+    const baseUrl = resolveBaseUrl(flags);
+    const apiKey = requireApiKey(flags);
+    const dryRun = booleanFlag(flags, "dry-run");
+    const confirmTestTransfer = booleanFlag(flags, "confirm-test-transfer");
+    if (!dryRun && !confirmTestTransfer) {
+        throw new Error("Use --dry-run first, then --confirm-test-transfer for a guarded test payout");
+    }
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+    };
+    if (!dryRun) {
+        headers["Idempotency-Key"] = randomUUID();
+    }
+    const { body } = await requestJson(`${baseUrl}/v1/wallet/payouts`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            dry_run: dryRun,
+            confirm_test_transfer: confirmTestTransfer,
+        }),
+    });
+    printJson({ ok: true, ...body });
+}
+export function generateInstallId() {
+    return `wins_${randomUUID().replace(/-/g, "")}`;
+}
+export function publisherTargetForExtension(target) {
+    return target === "vscode" ? "status-bar-fallback" : target;
+}
+function extensionInstallDir(_target) {
+    return path.join(os.homedir(), ".vscode", "extensions");
+}
+function vscodeExtensionInstallDir(manifest) {
+    return path.join(extensionInstallDir("vscode"), `waitspin.${manifest.name}-${manifest.version}`);
+}
+function installStatePath(target) {
+    return path.join(os.homedir(), ".waitspin", `${target}-install.json`);
+}
+function extensionMarkerPath(target) {
+    return path.join(extensionInstallDir(target), ".waitspin-install.json");
+}
+function resolveExtensionTarget(flags) {
+    const target = optionalFlag(flags, "target") || "vscode";
+    if (!(target in extensionTargets)) {
+        throw new Error(`Unsupported extension target: ${target}. Public WaitSpin installs currently support --target vscode only.`);
+    }
+    return target;
+}
+async function loadInstallState(statePath) {
+    try {
+        const raw = await readFile(statePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.install_id?.trim()) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function loadInstallMarker(markerPath) {
+    try {
+        return JSON.parse(await readFile(markerPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function assertManagedVscodeExtensionPath(input) {
+    const extensionRoot = path.resolve(extensionInstallDir("vscode"));
+    const resolved = path.resolve(input);
+    const name = path.basename(resolved);
+    if (!resolved.startsWith(`${extensionRoot}${path.sep}`) ||
+        !name.startsWith("waitspin.")) {
+        throw new Error("Refusing to manage an extension path outside the WaitSpin VS Code install directory.");
+    }
+    return resolved;
+}
+async function registerPublisherInstall(input) {
+    const { body } = await requestJson(`${input.baseUrl}/v1/publishers/register`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${input.apiKey}`,
+        },
+        body: JSON.stringify({
+            install_id: input.installId,
+            target: input.target,
+        }),
+    });
+    if (!body) {
+        throw new Error("Publisher registration returned empty body");
+    }
+    return body;
+}
+async function resolveExtensionDir() {
+    const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+    const candidates = [
+        path.join(process.cwd(), "packages/waitspin/assets/waitspin-vscode"),
+        path.join(process.cwd(), "extensions/waitspin-vscode"),
+        path.join(packageRoot, "assets", "waitspin-vscode"),
+        path.join(packageRoot, "../../extensions/waitspin-vscode"),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await access(path.join(candidate, "package.json"), fsConstants.F_OK);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error("WaitSpin extension package not found. Install from the monorepo checkout or use a build that ships assets/waitspin-vscode.");
+}
+async function installVscodeExtensionRuntime(input) {
+    const targetDir = vscodeExtensionInstallDir(input.manifest);
+    await access(path.join(input.sourceDir, "out", "extension.js"), fsConstants.F_OK);
+    await mkdir(targetDir, { recursive: true });
+    await cp(path.join(input.sourceDir, "package.json"), path.join(targetDir, "package.json"), {
+        force: true,
+    });
+    await cp(path.join(input.sourceDir, "out"), path.join(targetDir, "out"), {
+        recursive: true,
+        force: true,
+    });
+    return targetDir;
+}
+export async function runExtensionInstall(flags) {
+    const target = resolveExtensionTarget(flags);
+    const baseUrl = resolveBaseUrl(flags);
+    const publisherTarget = publisherTargetForExtension(target);
+    const extensionDir = await resolveExtensionDir();
+    const manifestPath = path.join(extensionDir, "package.json");
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    }
+    catch {
+        throw new Error(`Extension package not found at ${extensionDir}.`);
+    }
+    const installDir = extensionInstallDir(target);
+    const statePath = installStatePath(target);
+    const existingState = await loadInstallState(statePath);
+    const installId = existingState?.install_id || generateInstallId();
+    const summary = {
+        ok: true,
+        target,
+        extension: manifest.name,
+        version: manifest.version,
+        source: extensionDir,
+        install_hint: installDir,
+        install_id: installId,
+        publisher_target: publisherTarget,
+        state_path: statePath,
+        note: "Installs the WaitSpin VS Code status-bar fallback extension.",
+        next: {
+            create_publisher_key: "waitspin init --email you@example.com --key-profile publisher-extension",
+            set_vscode_settings: {
+                "waitspin.installId": installId,
+            },
+            credential_storage: "The VS Code extension migrates waitspin.apiKey user settings into SecretStorage; WAITSPIN_API_KEY remains env-only.",
+            optional_bootstrap_env: {
+                WAITSPIN_INSTALL_ID: installId,
+                WAITSPIN_API_KEY: "<temporary publisher-extension key for first activation>",
+            },
+        },
+    };
+    if (booleanFlag(flags, "dry-run")) {
+        printJson({ ...summary, dry_run: true, publisher_registered: false });
+        return;
+    }
+    const apiKey = requireApiKey(flags);
+    const registration = await registerPublisherInstall({
+        baseUrl,
+        apiKey,
+        installId,
+        target: publisherTarget,
+    });
+    const installState = {
+        install_id: registration.install_id,
+        publisher_id: registration.publisher_id,
+        publisher_target: registration.target,
+        registered_at: new Date().toISOString(),
+    };
+    await mkdir(path.dirname(statePath), { recursive: true });
+    await writeFile(statePath, `${JSON.stringify(installState, null, 2)}\n`, "utf8");
+    await mkdir(installDir, { recursive: true });
+    const markerPath = extensionMarkerPath(target);
+    const installedExtensionPath = await installVscodeExtensionRuntime({
+        sourceDir: extensionDir,
+        manifest,
+    });
+    await writeFile(markerPath, `${JSON.stringify({
+        ...summary,
+        ...installState,
+        extension_installed: Boolean(installedExtensionPath),
+        installed_extension_path: installedExtensionPath,
+        publisher_registered: true,
+    }, null, 2)}\n`, "utf8");
+    printJson({
+        ...summary,
+        ...installState,
+        extension_installed: Boolean(installedExtensionPath),
+        installed_extension_path: installedExtensionPath,
+        publisher_registered: true,
+    });
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function managedInstalledPath(marker) {
+    const markerPath = marker?.installed_extension_path?.trim();
+    return markerPath ? assertManagedVscodeExtensionPath(markerPath) : null;
+}
+function managedInstalledPathStatus(marker) {
+    try {
+        return { path: managedInstalledPath(marker), error: null };
+    }
+    catch {
+        return { path: null, error: "invalid_managed_extension_path" };
+    }
+}
+export async function runExtensionStatus(flags) {
+    const target = resolveExtensionTarget(flags);
+    const statePath = installStatePath(target);
+    const markerPath = extensionMarkerPath(target);
+    const [state, marker] = await Promise.all([
+        loadInstallState(statePath),
+        loadInstallMarker(markerPath),
+    ]);
+    const installedPathStatus = managedInstalledPathStatus(marker);
+    const installedExtensionPath = installedPathStatus.path;
+    const extensionInstalled = installedExtensionPath
+        ? await pathExists(path.join(installedExtensionPath, "package.json"))
+        : false;
+    printJson({
+        ok: true,
+        target,
+        mode: "status-bar-fallback",
+        installed: extensionInstalled,
+        publisher_registered: Boolean(state?.publisher_id || marker?.publisher_id),
+        install_id: state?.install_id || marker?.install_id || null,
+        publisher_id: state?.publisher_id || marker?.publisher_id || null,
+        publisher_target: state?.publisher_target ||
+            marker?.publisher_target ||
+            publisherTargetForExtension(target),
+        extension: marker?.extension || null,
+        version: marker?.version || null,
+        state_path: statePath,
+        marker_path: markerPath,
+        installed_extension_path: installedExtensionPath,
+        install_marker_error: installedPathStatus.error,
+    });
+}
+export async function runExtensionUninstall(flags) {
+    const target = resolveExtensionTarget(flags);
+    const statePath = installStatePath(target);
+    const markerPath = extensionMarkerPath(target);
+    const marker = await loadInstallMarker(markerPath);
+    const installedPathStatus = managedInstalledPathStatus(marker);
+    const installedExtensionPath = installedPathStatus.path;
+    const removePaths = [statePath, markerPath];
+    if (installedExtensionPath) {
+        removePaths.unshift(installedExtensionPath);
+    }
+    if (booleanFlag(flags, "dry-run")) {
+        printJson({
+            ok: true,
+            target,
+            dry_run: true,
+            would_remove: removePaths,
+            install_marker_error: installedPathStatus.error,
+        });
+        return;
+    }
+    await Promise.all(removePaths.map((filePath) => rm(filePath, { force: true, recursive: true })));
+    printJson({
+        ok: true,
+        target,
+        uninstalled: true,
+        removed: removePaths,
+        install_marker_error: installedPathStatus.error,
+    });
+}
+export async function main(argv = process.argv.slice(2)) {
+    const { command, flags, positionals } = parseArgs(argv);
+    if (command === "init") {
+        await runInit(flags);
+        return;
+    }
+    if (command === "bid" && positionals[0] === "create") {
+        await runBidCreate(flags);
+        return;
+    }
+    if (command === "bids" && positionals[0] === "list") {
+        await runBidsList(flags);
+        return;
+    }
+    if (command === "bid" && positionals[0] === "checkout") {
+        await runBidCheckout(flags, positionals.slice(1));
+        return;
+    }
+    if (command === "market") {
+        await runMarket(flags);
+        return;
+    }
+    if (command === "wallet" && positionals[0] === "status") {
+        await runWalletStatus(flags);
+        return;
+    }
+    if (command === "wallet" && positionals[0] === "connect") {
+        await runWalletConnect(flags);
+        return;
+    }
+    if (command === "wallet" && positionals[0] === "ledger") {
+        await runWalletLedger(flags);
+        return;
+    }
+    if (command === "wallet" && positionals[0] === "payout") {
+        await runWalletPayout(flags);
+        return;
+    }
+    if (command === "extension" && positionals[0] === "install") {
+        await runExtensionInstall(flags);
+        return;
+    }
+    if (command === "extension" && positionals[0] === "status") {
+        await runExtensionStatus(flags);
+        return;
+    }
+    if (command === "extension" && positionals[0] === "uninstall") {
+        await runExtensionUninstall(flags);
+        return;
+    }
+    usage();
+}
+function isDirectEntrypoint() {
+    if (!process.argv[1]) {
+        return false;
+    }
+    const modulePath = fileURLToPath(import.meta.url);
+    try {
+        return realpathSync(modulePath) === realpathSync(process.argv[1]);
+    }
+    catch {
+        return modulePath === process.argv[1];
+    }
+}
+if (isDirectEntrypoint()) {
+    main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.stderr.write(usageText());
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=cli.js.map