@layoutplatforms/cli 0.1.0

package/dist/context.js

@@ -0,0 +1,66 @@
+import { Api, defaultHttpDeps } from "./http.js";
+import { Output } from "./output.js";
+import { apiBase, hostKey, readSession, writeSession } from "./config.js";
+import { chooseStore, spawnRunner, storeOfKind } from "./credentials.js";
+import { CliError, EXIT, usageError } from "./errors.js";
+import { str } from "./args.js";
+export function makeCtx(p, args) {
+    const env = p.streams.env;
+    const base = apiBase(env);
+    return { p, args, out: new Output(p.streams, args.flags.json === true), env, base, api: new Api(base, p.http) };
+}
+export function defaultPlatform(streams) {
+    return {
+        streams,
+        platform: process.platform,
+        run: spawnRunner,
+        http: defaultHttpDeps(),
+        openUrl: () => false,
+        hostname: () => "",
+        onInterrupt: (fn) => {
+            process.once("SIGINT", fn);
+            return () => process.off("SIGINT", fn);
+        },
+        now: () => Date.now(),
+        sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    };
+}
+export function signedIn(ctx) {
+    const record = readSession(ctx.env, ctx.base);
+    if (!record)
+        throw new CliError("not_signed_in", "Not signed in. Run layout login.", EXIT.auth);
+    const token = storeOfKind(record.store, ctx.env, ctx.p.run).get(hostKey(ctx.base));
+    if (!token)
+        throw new CliError("not_signed_in", "Not signed in. Run layout login.", EXIT.auth);
+    return { token, record };
+}
+export function forget(ctx, record) {
+    if (record)
+        storeOfKind(record.store, ctx.env, ctx.p.run).remove(hostKey(ctx.base));
+    writeSession(ctx.env, ctx.base, null);
+}
+export async function authed(ctx, path, opts = {}) {
+    const s = signedIn(ctx);
+    try {
+        return (await ctx.api.request(path, { ...opts, auth: s.token })).data;
+    }
+    catch (err) {
+        if (err instanceof CliError && err.exit === EXIT.auth) {
+            forget(ctx, s.record);
+            throw new CliError(err.code, `${err.message.replace(/\s*Sign in with layout login\.?$/, "")} Run layout login.`.trim(), EXIT.auth);
+        }
+        throw err;
+    }
+}
+export async function pickApp(ctx) {
+    const chosen = str(ctx.args, "app") ?? ctx.env.LAYOUT_APP?.trim();
+    if (chosen)
+        return chosen;
+    const { apps } = await authed(ctx, "/v1/cli/apps");
+    if (apps.length === 1)
+        return apps[0].id;
+    if (apps.length === 0)
+        throw new CliError("no_apps", "This account has no applications. Create one with layout apps create <name>.", EXIT.notFound);
+    throw usageError(`This account has ${apps.length} applications. Pick one with --app:\n${apps.map((a) => `  ${a.id}  ${a.name}`).join("\n")}`);
+}
+export { chooseStore };

package/dist/credentials.js

@@ -0,0 +1,109 @@
+import { spawnSync } from "node:child_process";
+import { chmodSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { configDir, readJson, writePrivateJson } from "./config.js";
+export const spawnRunner = (cmd, args, input) => {
+    const r = spawnSync(cmd, args, { input, encoding: "utf8", stdio: ["pipe", "pipe", "ignore"], timeout: 15_000 });
+    return { status: r.error ? null : r.status, stdout: r.stdout ?? "" };
+};
+const SERVICE = "layout-cli";
+const SAFE = /^[A-Za-z0-9_.:\-[\]]+$/;
+const TOKEN = /^lcli_[A-Za-z0-9_-]{43}$/;
+export function keychainStore(run) {
+    return {
+        kind: "keychain",
+        get(account) {
+            if (!SAFE.test(account))
+                return null;
+            const r = run("security", ["find-generic-password", "-a", account, "-s", SERVICE, "-w"]);
+            const v = r.stdout.trim();
+            return r.status === 0 && TOKEN.test(v) ? v : null;
+        },
+        set(account, token) {
+            if (!SAFE.test(account) || !TOKEN.test(token))
+                return false;
+            const r = run("security", ["-i"], `add-generic-password -U -a ${account} -s ${SERVICE} -l "Layout CLI" -w ${token}\n`);
+            return r.status === 0 && this.get(account) === token;
+        },
+        remove(account) {
+            if (SAFE.test(account))
+                run("security", ["delete-generic-password", "-a", account, "-s", SERVICE]);
+        },
+    };
+}
+export function secretToolStore(run) {
+    return {
+        kind: "secret-tool",
+        get(account) {
+            const r = run("secret-tool", ["lookup", "service", SERVICE, "account", account]);
+            const v = r.stdout.trim();
+            return r.status === 0 && TOKEN.test(v) ? v : null;
+        },
+        set(account, token) {
+            if (!TOKEN.test(token))
+                return false;
+            const r = run("secret-tool", ["store", "--label=Layout CLI", "service", SERVICE, "account", account], token);
+            return r.status === 0 && this.get(account) === token;
+        },
+        remove(account) {
+            run("secret-tool", ["clear", "service", SERVICE, "account", account]);
+        },
+    };
+}
+export function fileStore(env) {
+    const path = join(configDir(env), "credentials.json");
+    const read = () => readJson(path) ?? {};
+    return {
+        kind: "file",
+        path,
+        get(account) {
+            try {
+                if ((statSync(path).mode & 0o077) !== 0)
+                    chmodSync(path, 0o600);
+            }
+            catch {
+                return null;
+            }
+            const v = read()[account];
+            return typeof v === "string" && TOKEN.test(v) ? v : null;
+        },
+        set(account, token) {
+            if (!TOKEN.test(token))
+                return false;
+            writePrivateJson(path, { ...read(), [account]: token });
+            return true;
+        },
+        remove(account) {
+            const all = read();
+            if (!(account in all))
+                return;
+            delete all[account];
+            writePrivateJson(path, all);
+        },
+    };
+}
+function available(run, cmd, args) {
+    return run(cmd, args).status !== null;
+}
+export function chooseStore(env, platform, run = spawnRunner) {
+    const forced = env.LAYOUT_CREDENTIAL_STORE;
+    const file = fileStore(env);
+    if (forced === "file")
+        return { store: file, warning: null };
+    if (forced === "keychain")
+        return { store: keychainStore(run), warning: null };
+    if (forced === "secret-tool")
+        return { store: secretToolStore(run), warning: null };
+    if (platform === "darwin" && available(run, "security", ["help"]))
+        return { store: keychainStore(run), warning: null };
+    if (platform === "linux" && available(run, "secret-tool", ["--version"]))
+        return { store: secretToolStore(run), warning: null };
+    return { store: file, warning: `No OS keychain found, so the CLI token is stored in ${file.path} (readable only by you).` };
+}
+export function storeOfKind(kind, env, run = spawnRunner) {
+    if (kind === "keychain")
+        return keychainStore(run);
+    if (kind === "secret-tool")
+        return secretToolStore(run);
+    return fileStore(env);
+}

package/dist/errors.js

@@ -0,0 +1,44 @@
+export const EXIT = {
+    ok: 0,
+    error: 1,
+    usage: 2,
+    auth: 3,
+    refused: 4,
+    notFound: 5,
+    rateLimited: 6,
+    unavailable: 7,
+    conflict: 8,
+    interrupted: 130,
+};
+export class CliError extends Error {
+    code;
+    exit;
+    detail;
+    constructor(code, message, exit = EXIT.error, detail = {}) {
+        super(message);
+        this.code = code;
+        this.exit = exit;
+        this.detail = detail;
+        this.name = "CliError";
+    }
+}
+export function usageError(message) {
+    return new CliError("usage", message, EXIT.usage);
+}
+export function exitForStatus(status) {
+    if (status === 400 || status === 422)
+        return EXIT.usage;
+    if (status === 401)
+        return EXIT.auth;
+    if (status === 403)
+        return EXIT.refused;
+    if (status === 404)
+        return EXIT.notFound;
+    if (status === 409)
+        return EXIT.conflict;
+    if (status === 429)
+        return EXIT.rateLimited;
+    if (status === 0 || status >= 500)
+        return EXIT.unavailable;
+    return EXIT.error;
+}

package/dist/http.js

@@ -0,0 +1,85 @@
+import { randomUUID } from "node:crypto";
+import { CliError, EXIT, exitForStatus } from "./errors.js";
+import { VERSION } from "./version.js";
+export const realSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export const defaultHttpDeps = () => ({ fetch: globalThis.fetch, sleep: realSleep, attempts: 4 });
+export function userAgent() {
+    return `layout-cli/${VERSION} (node ${process.versions.node}; ${process.platform})`;
+}
+function backoffMs(attempt, retryAfter) {
+    const hinted = retryAfter ? Number(retryAfter) : NaN;
+    if (Number.isFinite(hinted) && hinted >= 0)
+        return Math.min(hinted, 10) * 1000;
+    return Math.min(500 * 2 ** attempt, 8_000) + Math.floor(Math.random() * 250);
+}
+function errorFrom(status, data) {
+    const body = (data ?? {});
+    if (body.error && typeof body.error === "object") {
+        const e = body.error;
+        const { code: _c, message: _m, ...rest } = e;
+        return new CliError(String(e.code ?? "error"), String(e.message ?? `Layout answered ${status}.`), exitForStatus(status), rest);
+    }
+    if (typeof body.error === "string") {
+        return new CliError(body.error, String(body.error_description ?? `Layout answered ${status}.`), exitForStatus(status));
+    }
+    return new CliError(status >= 500 ? "unavailable" : "error", `Layout answered ${status}.`, exitForStatus(status));
+}
+export class Api {
+    base;
+    deps;
+    constructor(base, deps = defaultHttpDeps()) {
+        this.base = base;
+        this.deps = deps;
+    }
+    async request(path, opts = {}) {
+        const method = opts.method ?? "GET";
+        const retry = opts.retry ?? method === "GET";
+        const idemKey = method === "POST" && opts.idempotent ? randomUUID() : null;
+        const headers = { accept: "application/json", "user-agent": userAgent() };
+        if (opts.auth)
+            headers.authorization = `Bearer ${opts.auth}`;
+        if (opts.body !== undefined)
+            headers["content-type"] = "application/json";
+        if (idemKey)
+            headers["idempotency-key"] = idemKey;
+        const attempts = retry ? Math.max(1, this.deps.attempts) : 1;
+        let last = null;
+        for (let attempt = 0; attempt < attempts; attempt++) {
+            let res;
+            try {
+                res = await this.deps.fetch(`${this.base}${path}`, {
+                    method,
+                    headers,
+                    ...(opts.body === undefined ? {} : { body: JSON.stringify(opts.body) }),
+                    signal: AbortSignal.timeout(opts.timeoutMs ?? 30_000),
+                    redirect: "error",
+                });
+            }
+            catch {
+                last = new CliError("network", `Could not reach ${new URL(this.base).host}. Check your connection and retry.`, EXIT.unavailable);
+                if (attempt + 1 < attempts)
+                    await this.deps.sleep(backoffMs(attempt, null));
+                continue;
+            }
+            const text = await res.text();
+            let data = null;
+            try {
+                data = text ? JSON.parse(text) : null;
+            }
+            catch {
+                data = null;
+            }
+            if (res.ok || opts.okStatuses?.includes(res.status))
+                return { status: res.status, data: data, headers: res.headers };
+            last = errorFrom(res.status, data);
+            const transient = res.status === 503 || res.status === 502 || res.status === 504 || (res.status === 429 && method === "GET")
+                || (idemKey !== null && res.status === 409 && last.code === "in_progress");
+            if (transient && attempt + 1 < attempts) {
+                await this.deps.sleep(backoffMs(attempt, res.headers.get("retry-after")));
+                continue;
+            }
+            throw last;
+        }
+        throw last ?? new CliError("network", "Layout could not be reached.", EXIT.unavailable);
+    }
+}

package/dist/listen.js

@@ -0,0 +1,89 @@
+import { createHmac, randomBytes } from "node:crypto";
+import { CliError, EXIT } from "./errors.js";
+export function mintLocalSecret() {
+    return `whsec_cli_${randomBytes(24).toString("hex")}`;
+}
+export function signWebhook(secret, timestampSec, rawBody) {
+    return createHmac("sha256", secret).update(`${timestampSec}.${rawBody}`, "utf8").digest("hex");
+}
+export function signatureHeader(secret, timestampSec, rawBody) {
+    return `t=${timestampSec},v1=${signWebhook(secret, timestampSec, rawBody)}`;
+}
+function field(payload, key) {
+    const v = payload && typeof payload === "object" ? payload[key] : undefined;
+    return typeof v === "string" ? v : null;
+}
+export function forwardHeaders(secret, ev, body, nowSec) {
+    return {
+        "content-type": "application/json",
+        "user-agent": "Layout-Webhooks/1 (layout-cli)",
+        "x-layout-signature": signatureHeader(secret, nowSec, body),
+        "x-layout-event": ev.event,
+        "x-layout-delivery": field(ev.payload, "delivery_id") ?? ev.cursor,
+        "x-layout-environment": "sandbox",
+        "x-layout-forwarded-by": "layout-cli",
+    };
+}
+const backoff = (attempt, max) => Math.min(1_000 * 2 ** attempt, max);
+export async function runListener(start, opts, deps) {
+    let cursor = start;
+    const seen = new Set();
+    let feedFailures = 0;
+    while (!deps.stopped()) {
+        let page;
+        try {
+            page = await deps.fetchPage(cursor);
+            feedFailures = 0;
+        }
+        catch (err) {
+            if (err instanceof CliError && (err.exit === EXIT.auth || err.exit === EXIT.refused || err.exit === EXIT.notFound || err.exit === EXIT.usage))
+                throw err;
+            const wait = backoff(feedFailures++, opts.maxBackoffMs);
+            deps.report({ kind: "feed_unavailable", retryInMs: wait });
+            await deps.sleep(wait);
+            continue;
+        }
+        for (const ev of page.events) {
+            if (deps.stopped())
+                return cursor;
+            if (seen.has(ev.cursor)) {
+                cursor = ev.cursor;
+                continue;
+            }
+            if (opts.events && !opts.events.has(ev.event)) {
+                seen.add(ev.cursor);
+                cursor = ev.cursor;
+                deps.saveCursor(cursor);
+                deps.report({ kind: "skipped", cursor, event: ev.event });
+                continue;
+            }
+            const body = JSON.stringify(ev.payload);
+            let attempts = 0;
+            for (;;) {
+                if (deps.stopped())
+                    return cursor;
+                attempts++;
+                let res;
+                try {
+                    res = await deps.forward(opts.forwardTo, body, forwardHeaders(opts.secret, ev, body, deps.nowSec()));
+                }
+                catch {
+                    res = { ok: false, status: 0 };
+                }
+                if (res.ok) {
+                    seen.add(ev.cursor);
+                    cursor = ev.cursor;
+                    deps.saveCursor(cursor);
+                    deps.report({ kind: "forwarded", cursor, event: ev.event, eventId: field(ev.payload, "event_id"), status: res.status, attempts });
+                    break;
+                }
+                const wait = backoff(attempts - 1, opts.maxBackoffMs);
+                deps.report({ kind: "forward_failed", event: ev.event, status: res.status, retryInMs: wait });
+                await deps.sleep(wait);
+            }
+        }
+        if (!page.nextCursor)
+            await deps.sleep(opts.pollMs);
+    }
+    return cursor;
+}

package/dist/main.js

@@ -0,0 +1,126 @@
+import { parseArgs } from "./args.js";
+import { CliError, EXIT, usageError } from "./errors.js";
+import { makeCtx } from "./context.js";
+import { Output } from "./output.js";
+import { VERSION } from "./version.js";
+import { login, logout, whoami } from "./commands/session.js";
+import { appsCreate, appsList, deliveries, docs, keysCreate, keysList, keysRevoke, requestLiveAccess, trigger, usage, webhooksList, } from "./commands/resources.js";
+import { listen } from "./commands/listen.js";
+import { testOrder } from "./commands/test-order.js";
+const s = (name) => ({ name, type: "string" });
+const b = (name) => ({ name, type: "boolean" });
+export const COMMANDS = [
+    { path: ["login"], usage: "layout login [--device-name <name>] [--no-browser]", summary: "Sign in with a code you approve in the console.", flags: [s("device-name"), b("no-browser")],
+        flagHelp: [["--device-name <name>", "What the console shows as the computer asking. Default: this computer's name."], ["--no-browser", "Print the link without opening a browser."]], run: login },
+    { path: ["logout"], usage: "layout logout", summary: "Revoke this CLI session and forget it here.", flags: [], run: logout },
+    { path: ["whoami"], usage: "layout whoami", summary: "The developer account and this CLI session.", flags: [], run: whoami },
+    { path: ["apps", "list"], usage: "layout apps list", summary: "Your applications.", flags: [], run: appsList },
+    { path: ["apps", "create"], usage: "layout apps create <name>", summary: "A new application. Prints its sandbox key once.", flags: [], run: appsCreate },
+    { path: ["keys", "list"], usage: "layout keys list", summary: "The application's sandbox key.", flags: [], run: keysList },
+    { path: ["keys", "create"], usage: "layout keys create [--replace]", summary: "A new sandbox key, printed once.", flags: [b("replace")],
+        flagHelp: [["--replace", "Retire the current sandbox key and make another."]], run: keysCreate },
+    { path: ["keys", "revoke"], usage: "layout keys revoke --yes", summary: "Revoke the sandbox key and its sandbox build grants.", flags: [b("yes")],
+        flagHelp: [["--yes", "Confirm. Nothing is revoked without it."]], run: keysRevoke },
+    { path: ["webhooks", "list"], usage: "layout webhooks list", summary: "Endpoints (managed in the console) and the sandbox signing secret.", flags: [], run: webhooksList },
+    { path: ["listen"], usage: "layout listen --forward-to <url> [--events <a,b>] [--from-start]", summary: "Forward sandbox events to a local URL.", flags: [s("forward-to"), s("events"), b("from-start")],
+        flagHelp: [["--forward-to <url>", "Where to POST each event, signed with a secret made for this run."], ["--events <a,b>", "Only these events."], ["--from-start", "Forward the whole feed, not only what happens from now."]], run: listen },
+    { path: ["trigger"], usage: "layout trigger <event> [--order <ord_id>]", summary: "Fire a signed test event at your endpoints.", flags: [s("order")], run: trigger },
+    { path: ["usage"], usage: "layout usage", summary: "Today's allowances and counts.", flags: [], run: usage },
+    { path: ["deliveries"], usage: "layout deliveries [--limit <n>]", summary: "Recent sandbox webhook deliveries.", flags: [s("limit")], run: deliveries },
+    { path: ["test-order"], usage: "layout test-order [--place <test_place_id>]", summary: "Run a whole sandbox order and print each step.", flags: [s("place")],
+        flagHelp: [["--place <id>", "A sandbox test restaurant. Default: test_place_placed."]], run: testOrder },
+    { path: ["request-live-access"], usage: "layout request-live-access [--note <text>]", summary: "Ask Layout to review production access.", flags: [s("note")], run: requestLiveAccess },
+    { path: ["docs"], usage: "layout docs [cli|quickstart|sandbox|webhooks|events|api]", summary: "Open the docs.", flags: [], run: docs },
+];
+const GLOBAL_HELP = [
+    ["--json", "Machine output: one JSON object on stdout, errors as JSON on stderr."],
+    ["--app <id>", "The application (or LAYOUT_APP). With one application it is picked for you."],
+    ["--help", "Help for any command."],
+    ["--version", "The CLI version."],
+];
+function find(positionals) {
+    let best = null;
+    for (const c of COMMANDS) {
+        if (c.path.every((part, i) => positionals[i] === part) && (!best || c.path.length > best.path.length))
+            best = c;
+    }
+    return best;
+}
+function group(positionals) {
+    return positionals[0] ? COMMANDS.filter((c) => c.path[0] === positionals[0] && c.path.length > 1) : [];
+}
+function pad(rows) {
+    const w = Math.max(...rows.map(([a]) => a.length));
+    return rows.map(([a, d]) => `  ${a.padEnd(w)}  ${d}`);
+}
+function help(o, cmd, sub) {
+    if (cmd) {
+        o.line(o.wordmark());
+        o.line();
+        o.line(`${cmd.summary}`);
+        o.line();
+        o.line(`Usage: ${cmd.usage}`);
+        o.line();
+        if (cmd.flagHelp?.length) {
+            o.line("Flags:");
+            for (const l of pad(cmd.flagHelp))
+                o.line(l);
+            o.line();
+        }
+        o.line("Global flags:");
+        for (const l of pad([...GLOBAL_HELP]))
+            o.line(l);
+        return;
+    }
+    const list = sub.length ? sub : COMMANDS;
+    o.line(o.wordmark());
+    o.line();
+    o.line("Sign in, then build against the Layout sandbox. Never touches production.");
+    o.line();
+    o.line("Commands:");
+    for (const l of pad(list.map((c) => [c.path.join(" "), c.summary])))
+        o.line(l);
+    o.line();
+    o.line("Global flags:");
+    for (const l of pad([...GLOBAL_HELP]))
+        o.line(l);
+    o.line();
+    o.line("Docs: https://developer.layout.link/reference/cli");
+}
+export async function main(argv, p) {
+    const json = argv.includes("--json");
+    const fallback = new Output(p.streams, json);
+    try {
+        const loose = parseArgs(argv, COMMANDS.flatMap((c) => c.flags));
+        const positionals = loose.positionals;
+        const cmd = find(positionals);
+        const sub = cmd ? [] : group(positionals);
+        const args = cmd ? parseArgs(argv, cmd.flags) : loose;
+        if (args.flags.version) {
+            fallback.result({ version: VERSION }, () => fallback.line(VERSION));
+            return EXIT.ok;
+        }
+        if (args.flags.help || !cmd) {
+            if (json) {
+                fallback.data({ commands: (sub.length ? sub : cmd ? [cmd] : COMMANDS).map((c) => ({ command: c.path.join(" "), usage: c.usage, summary: c.summary })) });
+            }
+            else {
+                help(new Output({ ...p.streams, out: p.streams.out }, false), cmd, sub);
+            }
+            if (!cmd && sub.length === 0 && positionals.length > 0 && !args.flags.help) {
+                throw usageError(`Unknown command: ${positionals.join(" ")}.`);
+            }
+            return EXIT.ok;
+        }
+        const extra = args.positionals.slice(cmd.path.length);
+        const takesArgs = ["apps create", "trigger", "docs"].includes(cmd.path.join(" "));
+        if (!takesArgs && extra.length > 0)
+            throw usageError(`Unexpected argument: ${extra[0]}. Run layout ${cmd.path.join(" ")} --help.`);
+        return await cmd.run(makeCtx(p, args));
+    }
+    catch (err) {
+        const e = err instanceof CliError ? err : new CliError("error", err instanceof Error ? err.message : String(err), EXIT.error);
+        fallback.error(e);
+        return e.exit;
+    }
+}

package/dist/output.js

@@ -0,0 +1,113 @@
+const BLUE = { truecolor: "\x1b[38;2;40;107;254m", "256": "\x1b[38;5;27m", basic: "\x1b[34m" };
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function colorDepth(stream, env) {
+    if (env.NO_COLOR !== undefined && env.NO_COLOR !== "")
+        return "none";
+    if (!stream.isTTY)
+        return "none";
+    if (env.TERM === "dumb")
+        return "none";
+    const ct = (env.COLORTERM ?? "").toLowerCase();
+    if (ct === "truecolor" || ct === "24bit")
+        return "truecolor";
+    if ((env.TERM ?? "").includes("256"))
+        return "256";
+    return "basic";
+}
+export class Output {
+    streams;
+    json;
+    depth;
+    errDepth;
+    constructor(streams, json) {
+        this.streams = streams;
+        this.json = json;
+        this.depth = colorDepth(streams.out, streams.env);
+        this.errDepth = colorDepth(streams.err, streams.env);
+    }
+    accent(text, stream = "out") {
+        const d = stream === "out" ? this.depth : this.errDepth;
+        return d === "none" ? text : `${BLUE[d]}${text}${RESET}`;
+    }
+    bold(text) {
+        return this.depth === "none" ? text : `${BOLD}${text}${RESET}`;
+    }
+    wordmark() {
+        return this.depth === "none" ? "Layout" : `${BOLD}${BLUE[this.depth]}Layout${RESET}`;
+    }
+    line(text = "") {
+        if (!this.json)
+            this.streams.out.write(`${text}\n`);
+    }
+    note(text) {
+        this.streams.err.write(`${text}\n`);
+    }
+    data(value) {
+        this.streams.out.write(`${JSON.stringify(value)}\n`);
+    }
+    result(value, human) {
+        if (this.json)
+            this.data(value);
+        else
+            human();
+    }
+    table(rows, header) {
+        if (this.json)
+            return;
+        const all = header ? [header, ...rows] : rows;
+        const widths = [];
+        for (const r of all)
+            r.forEach((c, i) => { widths[i] = Math.max(widths[i] ?? 0, Array.from(c).length); });
+        all.forEach((r, idx) => {
+            const text = r.map((c, i) => (i === r.length - 1 ? c : c + " ".repeat((widths[i] ?? 0) - Array.from(c).length))).join("  ");
+            this.line(header && idx === 0 ? this.bold(text) : text);
+        });
+    }
+    error(err) {
+        if (this.json) {
+            this.streams.err.write(`${JSON.stringify({ error: { code: err.code, message: err.message, ...err.detail } })}\n`);
+        }
+        else {
+            this.streams.err.write(`${err.message}\n`);
+        }
+    }
+    spinner(text) {
+        const live = !this.json && Boolean(this.streams.err.isTTY) && this.errDepth !== "none";
+        return new Spinner(this, text, live);
+    }
+}
+export class Spinner {
+    o;
+    text;
+    live;
+    timer = null;
+    frame = 0;
+    constructor(o, text, live) {
+        this.o = o;
+        this.text = text;
+        this.live = live;
+        if (live) {
+            this.render();
+            this.timer = setInterval(() => this.render(), 80);
+            this.timer.unref();
+        }
+    }
+    update(text) {
+        this.text = text;
+    }
+    render() {
+        const glyph = this.o.accent(FRAMES[this.frame++ % FRAMES.length], "err");
+        this.o.streams.err.write(`\r\x1b[2K${glyph} ${this.text}`);
+    }
+    stop(final) {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        if (this.live)
+            this.o.streams.err.write("\r\x1b[2K");
+        if (final)
+            this.o.line(final);
+    }
+}

package/dist/version.js

@@ -0,0 +1 @@
+export const VERSION = "0.1.0";

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@layoutplatforms/cli",
+  "version": "0.1.0",
+  "private": false,
+  "description": "The Layout developer CLI: sign in, sandbox apps and keys, forward webhooks, run test orders.",
+  "type": "module",
+  "bin": {
+    "layout": "dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo \"(lint not yet configured)\"",
+    "test": "tsx --test src/*.test.ts",
+    "prepublishOnly": "pnpm run build && pnpm run test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://developer.layout.link/reference/cli",
+  "license": "UNLICENSED",
+  "author": "Layout, Inc."
+}