@namiml/cli 3.4.11-dev.202609221916

package/dist/commands/login.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { LoginFlow } from "../screens/LoginFlow.js";
+/** Interactive sign-in. Returns the process exit code. */
+export async function login(opts, ctx) {
+    if (!ctx.isTTY) {
+        ctx.err("`nami login` needs an interactive terminal. In CI or scripts set NAMI_TOKEN instead, or pass --app-platform-id where supported.");
+        return 2;
+    }
+    let result = null;
+    let failed = false;
+    const app = render(_jsx(LoginFlow, { auth: ctx.auth, store: ctx.store, host: ctx.host, totpCode: opts.totpCode, org: opts.org, onDone: (s) => { result = s; }, onFail: () => { failed = true; } }));
+    await app.waitUntilExit();
+    if (failed || !result)
+        return 1;
+    if (opts.printToken) {
+        // Explicit opt-in only: lets a developer mint NAMI_TOKEN for CI. Not written anywhere by the CLI.
+        ctx.out(result.accessToken);
+    }
+    return 0;
+}

package/dist/commands/logout.js

@@ -0,0 +1,7 @@
+/** Forget the stored tokens. Returns the process exit code. */
+export async function logout(ctx) {
+    const had = (await ctx.store.load()) !== null;
+    await ctx.store.clear();
+    ctx.out(had ? `Signed out of ${ctx.host.name}.` : "You were not signed in.");
+    return 0;
+}

package/dist/commands/onboarding.js

@@ -0,0 +1,13 @@
+/** `nami onboarding [--reset]` — show or reset the onboarding state. Tokens are never touched. */
+export async function onboarding(opts, ctx) {
+    if (opts.reset) {
+        await ctx.config.resetOnboarding();
+        ctx.out("Onboarding reset — run nami to pick an app and platform again. Your sign-in was kept (nami logout removes it).");
+        return 0;
+    }
+    const { config } = await ctx.config.load();
+    ctx.out(`Onboarding step: ${config.onboarding.step}${config.onboarding.completedAt ? ` (completed ${config.onboarding.completedAt})` : ""}`);
+    if (config.onboarding.step !== "done")
+        ctx.out("Run nami to continue.");
+    return 0;
+}

package/dist/commands/platforms.js

@@ -0,0 +1,34 @@
+import { AuthError } from "../auth/errors.js";
+import { listApps } from "../control-center/apps.js";
+import { listPlatforms } from "../control-center/platforms.js";
+import { findApp, ResolveError } from "../control-center/resolve.js";
+import { renderTable } from "./list-output.js";
+/** `nami platforms --app <id|name>` — list an app's platforms. `id` is the App Platform ID. */
+export async function platforms(opts, ctx) {
+    try {
+        const app = findApp(await listApps(ctx.session, { includeArchived: true }), opts.app);
+        const items = await listPlatforms(ctx.session, app.id, { includeArchived: Boolean(opts.all) });
+        if (opts.json) {
+            ctx.out(JSON.stringify(items, null, 2));
+        }
+        else if (items.length === 0) {
+            ctx.out(`${app.name} has no platforms${opts.all ? "" : " (archived ones hidden; pass --all)"}.`);
+        }
+        else {
+            ctx.out(`Platforms for ${app.name} — the id column is the App Platform ID`);
+            ctx.out(renderTable(items, ["id", "name", "typeLabel", "sdkEnabled", "isConfigValid", "archived"]));
+        }
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof ResolveError) {
+            ctx.err(error.message);
+            return 2;
+        }
+        if (error instanceof AuthError) {
+            ctx.err(error.message);
+            return 1;
+        }
+        throw error;
+    }
+}

package/dist/commands/shell.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render, Box, Text } from "ink";
+import { App } from "../App.js";
+import { Shell } from "../screens/Shell.js";
+/** Bare `nami`: the interactive shell on a TTY; the static placeholder elsewhere. */
+export async function shell(opts, ctx) {
+    if (!ctx.isTTY) {
+        const app = render(_jsxs(Box, { flexDirection: "column", children: [_jsx(App, { demo: false }), _jsx(Text, { dimColor: true, children: "nami is interactive \u2014 run it in a terminal, or use subcommands: nami apps, nami platforms --app \u2026, nami whoami." })] }));
+        app.unmount();
+        return 0;
+    }
+    let code = 0;
+    const app = render(_jsx(Shell, { ctx: ctx, appQuery: opts.app, platformQuery: opts.platform, onExit: (c) => { code = c; } }));
+    await app.waitUntilExit();
+    return code;
+}

package/dist/commands/whoami.js

@@ -0,0 +1,42 @@
+import { AuthError } from "../auth/errors.js";
+/** Show who is signed in. Never prints tokens. Returns the process exit code. */
+export async function whoami(opts, ctx) {
+    const stored = await ctx.store.load();
+    const viaToken = Boolean(ctx.env.NAMI_TOKEN);
+    if (!stored && !viaToken) {
+        ctx.err("Not signed in. Run `nami login` first.");
+        return 1;
+    }
+    let username = null;
+    try {
+        const res = await ctx.session.authorizedFetch("/private/account/");
+        if (res.ok) {
+            const data = (await res.json());
+            username = typeof data.username === "string" ? data.username : null;
+        }
+    }
+    catch (error) {
+        if (error instanceof AuthError && error.code === "session_expired") {
+            ctx.err(error.message);
+            return 1;
+        }
+        throw error;
+    }
+    const identity = {
+        host: ctx.host.name,
+        baseUrl: ctx.host.baseUrl,
+        orgId: stored?.orgId ?? null,
+        orgName: stored?.orgName ?? null,
+        username,
+        source: viaToken ? "NAMI_TOKEN" : "session",
+    };
+    if (opts.json) {
+        ctx.out(JSON.stringify(identity, null, 2));
+    }
+    else {
+        const who = identity.username ?? "an access token";
+        const org = identity.orgName ? ` · org ${identity.orgName}` : "";
+        ctx.out(`Signed in as ${who} on ${identity.host} (${identity.baseUrl})${org}${viaToken ? " · via NAMI_TOKEN" : ""}`);
+    }
+    return 0;
+}

package/dist/components/SelectList.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { palette } from "../theme.js";
+/**
+ * Keyboard list: ↑/↓ move (wrapping), Enter selects, typing filters,
+ * Backspace un-filters, Esc cancels. Pure: no data loading here.
+ */
+export function SelectList({ title, items, initialKey, onSelect, onCancel, emptyText = "Nothing to choose from.", footer }) {
+    const [filter, setFilter] = useState("");
+    const [cursor, setCursor] = useState(() => Math.max(0, items.findIndex((i) => i.key === initialKey)));
+    const visible = useMemo(() => {
+        const q = filter.trim().toLowerCase();
+        if (!q)
+            return items;
+        return items.filter((i) => `${i.label} ${i.hint ?? ""} ${i.badge ?? ""}`.toLowerCase().includes(q));
+    }, [items, filter]);
+    const index = visible.length === 0 ? 0 : Math.min(cursor, visible.length - 1);
+    useInput((input, key) => {
+        if (key.escape)
+            return onCancel?.();
+        if (key.return) {
+            const item = visible[index];
+            if (item)
+                onSelect(item.key);
+            return;
+        }
+        if (key.upArrow)
+            return setCursor(visible.length ? (index - 1 + visible.length) % visible.length : 0);
+        if (key.downArrow)
+            return setCursor(visible.length ? (index + 1) % visible.length : 0);
+        if (key.backspace || key.delete)
+            return setFilter((f) => f.slice(0, -1));
+        if (input && !key.ctrl && !key.meta) {
+            setFilter((f) => f + input);
+            setCursor(0);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: title }), filter && _jsxs(Text, { dimColor: true, children: ["  filter: ", filter, "  (", visible.length, " of ", items.length, ")"] })] }), visible.length === 0 ? (_jsx(Text, { dimColor: true, children: items.length === 0 ? emptyText : "No matches — Backspace to widen." })) : (visible.map((item, i) => (_jsxs(Box, { children: [_jsx(Text, { color: i === index ? palette.aqua : undefined, children: i === index ? "❯ " : "  " }), item.badge && _jsxs(Text, { color: palette.secondaryBlue, children: ["[", item.badge, "] "] }), _jsx(Text, { bold: i === index, children: item.label }), item.hint && _jsxs(Text, { dimColor: true, children: ["  ", item.hint] }), item.warn && _jsxs(Text, { color: palette.coral, children: ["  ", item.warn] })] }, item.key)))), _jsx(Text, { dimColor: true, children: footer ?? "↑/↓ move · Enter select · type to filter · Esc back" })] }));
+}

package/dist/components/Thinking.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text, useStdout } from "ink";
+import { Wave } from "./Wave.js";
+import { shouldAnimate } from "../utils/terminal.js";
+const elapsedSeconds = (start, now) => Math.max(0, Math.floor((now() - start) / 1000));
+/** Standard busy indicator: the tide, a label and elapsed seconds. */
+export function Thinking({ label, startedAt, now = Date.now, phase, width }) {
+    const { stdout } = useStdout();
+    const [start] = useState(() => startedAt ?? now());
+    const [elapsed, setElapsed] = useState(() => elapsedSeconds(start, now));
+    const live = phase === undefined && shouldAnimate(process.env, stdout);
+    useEffect(() => {
+        if (!live)
+            return;
+        const id = setInterval(() => setElapsed(elapsedSeconds(start, now)), 1000);
+        return () => clearInterval(id);
+    }, [live, now, start]);
+    return (_jsxs(Box, { children: [_jsx(Wave, { phase: phase, width: width }), _jsxs(Text, { children: [" ", label] }), _jsxs(Text, { dimColor: true, children: [" (", elapsed, "s)"] })] }));
+}

package/dist/components/Wave.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, useStdout } from "ink";
+import { MIN_WAVE_WIDTH, renderWaveFrame } from "./wave-frame.js";
+import { shouldAnimate, terminalColumns } from "../utils/terminal.js";
+const PHASE_STEP = (2 * Math.PI) / 24;
+/** The Nami tide. Animates only on an interactive TTY (see `shouldAnimate`). */
+export function Wave({ width = 12, phase, fps = 12, animate = true, wavelength = 8 }) {
+    const { stdout } = useStdout();
+    const [tick, setTick] = useState(0);
+    const [columns, setColumns] = useState(() => terminalColumns(stdout));
+    const controlled = phase !== undefined;
+    const live = !controlled && animate && shouldAnimate(process.env, stdout);
+    useEffect(() => {
+        if (!live)
+            return;
+        const id = setInterval(() => setTick((t) => t + 1), Math.max(16, Math.round(1000 / fps)));
+        return () => clearInterval(id);
+    }, [live, fps]);
+    useEffect(() => {
+        const onResize = () => setColumns(terminalColumns(stdout));
+        stdout.on("resize", onResize);
+        return () => {
+            stdout.off("resize", onResize);
+        };
+    }, [stdout]);
+    const effectiveWidth = Math.max(MIN_WAVE_WIDTH, Math.min(width, columns - 2));
+    const frame = renderWaveFrame(controlled ? phase : tick * PHASE_STEP, effectiveWidth, wavelength);
+    return (_jsx(Text, { children: frame.map((column, i) => (_jsx(Text, { color: column.color, children: column.glyph }, i))) }));
+}

package/dist/components/wave-frame.js

@@ -0,0 +1,21 @@
+import { WAVE_COLORS } from "../theme.js";
+export const WAVE_GLYPHS = "▁▂▃▄▅▆▇█";
+export const MIN_WAVE_WIDTH = 4;
+const GLYPHS = Array.from(WAVE_GLYPHS);
+const MAX_HEIGHT = GLYPHS.length - 1;
+/**
+ * One frame of the tide: a sine wave sampled per column, offset by `phase`
+ * (radians). Pure — components and tests share it, so animation is just
+ * "advance the phase".
+ */
+export function renderWaveFrame(phase, width, wavelength = 8) {
+    const columns = Math.max(MIN_WAVE_WIDTH, Math.floor(width));
+    const frame = [];
+    for (let i = 0; i < columns; i++) {
+        const level = (Math.sin((2 * Math.PI * i) / wavelength - phase) + 1) / 2;
+        const height = Math.round(level * MAX_HEIGHT);
+        const band = Math.min(WAVE_COLORS.length - 1, Math.floor(height / 2));
+        frame.push({ glyph: GLYPHS[height], color: WAVE_COLORS[band] });
+    }
+    return frame;
+}

package/dist/config/selection.js

@@ -0,0 +1,22 @@
+import { platformTypeLabel } from "../control-center/platforms.js";
+export const selectionFrom = (app, platform, device = null) => ({
+    appId: app.id,
+    appName: app.name,
+    appPlatformId: platform.id,
+    platformName: platform.name,
+    platformType: platform.type,
+    device,
+});
+/** Rebuild the picker objects from a stored selection (flags default to "fine" — verify decides). */
+export const appFrom = (s) => ({ id: s.appId, name: s.appName, archived: false, defaultLanguage: null, logo: null });
+export const platformFrom = (s) => ({
+    id: s.appPlatformId,
+    appId: s.appId,
+    name: s.platformName,
+    type: s.platformType,
+    typeLabel: platformTypeLabel(s.platformType),
+    sdkEnabled: true,
+    isConfigValid: true,
+    archived: false,
+    marketplaceAppId: null,
+});

package/dist/config/store.js

@@ -0,0 +1,132 @@
+import { mkdir, readFile, rename, rm, writeFile, chmod } from "node:fs/promises";
+import { join } from "node:path";
+export const CONFIG_SCHEMA_VERSION = 1;
+export const RECENT_MAX = 5;
+export const defaultConfig = () => ({
+    schemaVersion: CONFIG_SCHEMA_VERSION,
+    host: "production",
+    session: { orgId: null, orgName: null },
+    current: null,
+    recent: [],
+    sdkPlatform: null,
+    onboarding: { step: "welcome", completedAt: null },
+});
+const CREDENTIAL_KEY = /token|password|secret|passcode|totp/i;
+const JWT_LIKE = /^eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+/** `config.json` must never carry credentials, even by accident. */
+function assertNoCredentials(value, path = "config") {
+    if (typeof value === "string") {
+        if (JWT_LIKE.test(value))
+            throw new Error(`Refusing to write a credential-looking value at ${path} to config.json.`);
+        return;
+    }
+    if (Array.isArray(value))
+        return value.forEach((v, i) => assertNoCredentials(v, `${path}[${i}]`));
+    if (value && typeof value === "object") {
+        for (const [k, v] of Object.entries(value)) {
+            if (CREDENTIAL_KEY.test(k))
+                throw new Error(`Refusing to write credential key "${k}" at ${path} to config.json.`);
+            assertNoCredentials(v, `${path}.${k}`);
+        }
+    }
+}
+const recentKey = (s) => `${s.appPlatformId}::${s.device?.id ?? ""}`;
+/** Upgrade older shapes; unknown versions fall back to defaults (with a warning from load()). */
+export function migrate(raw) {
+    if (!raw || typeof raw !== "object")
+        return { config: defaultConfig(), warning: "config.json was not an object — starting fresh." };
+    const r = raw;
+    if (r.schemaVersion !== CONFIG_SCHEMA_VERSION) {
+        return { config: defaultConfig(), warning: `config.json has schemaVersion ${String(r.schemaVersion)} (this CLI writes ${CONFIG_SCHEMA_VERSION}) — starting fresh.` };
+    }
+    const d = defaultConfig();
+    return {
+        config: {
+            schemaVersion: CONFIG_SCHEMA_VERSION,
+            host: typeof r.host === "string" ? r.host : d.host,
+            session: { orgId: r.session?.orgId ?? null, orgName: r.session?.orgName ?? null },
+            current: r.current ?? null,
+            recent: Array.isArray(r.recent) ? r.recent.slice(0, RECENT_MAX) : [],
+            sdkPlatform: typeof r.sdkPlatform === "string" ? r.sdkPlatform : null,
+            onboarding: { step: r.onboarding?.step ?? d.onboarding.step, completedAt: r.onboarding?.completedAt ?? null },
+        },
+    };
+}
+/** `config.json` beside `tokens.json`: dir 0700, file 0600, atomic replace, never any secret. */
+export class ConfigStore {
+    dir;
+    /** Mutations are serialized so fire-and-forget callers never lose an update to a read-modify-write race. */
+    chain = Promise.resolve();
+    constructor(dir) {
+        this.dir = dir;
+    }
+    enqueue(work) {
+        const run = this.chain.then(work, work);
+        this.chain = run.catch(() => undefined);
+        return run;
+    }
+    /** Resolves once every queued mutation has finished (tests, shutdown). */
+    idle() {
+        return this.chain.then(() => undefined);
+    }
+    get path() {
+        return join(this.dir, "config.json");
+    }
+    async load() {
+        let text;
+        try {
+            text = await readFile(this.path, "utf8");
+        }
+        catch {
+            return { config: defaultConfig() };
+        }
+        try {
+            return migrate(JSON.parse(text));
+        }
+        catch {
+            return { config: defaultConfig(), warning: "config.json could not be parsed — starting fresh." };
+        }
+    }
+    async save(config) {
+        assertNoCredentials(config);
+        await mkdir(this.dir, { recursive: true, mode: 0o700 });
+        const tmp = `${this.path}.${process.pid}.tmp`;
+        await writeFile(tmp, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+        await chmod(tmp, 0o600);
+        await rename(tmp, this.path);
+    }
+    /** Record the active selection; keeps `recent` newest-first, de-duplicated by platform + device, capped. */
+    setCurrent(selection, extra = {}) {
+        return this.enqueue(async () => {
+            const { config } = await this.load();
+            const key = recentKey(selection);
+            const next = {
+                ...config,
+                host: extra.host ?? config.host,
+                session: extra.session ?? config.session,
+                current: selection,
+                recent: [selection, ...config.recent.filter((r) => recentKey(r) !== key)].slice(0, RECENT_MAX),
+            };
+            await this.save(next);
+            return next;
+        });
+    }
+    setOnboardingStep(step) {
+        return this.enqueue(async () => {
+            const { config } = await this.load();
+            if (config.onboarding.step === "done" && step !== "done")
+                return; // never regress a finished onboarding
+            await this.save({ ...config, onboarding: { step, completedAt: step === "done" ? config.onboarding.completedAt ?? new Date().toISOString() : config.onboarding.completedAt } });
+        });
+    }
+    markOnboardingDone() {
+        return this.enqueue(async () => {
+            const { config } = await this.load();
+            await this.save({ ...config, onboarding: { step: "done", completedAt: config.onboarding.completedAt ?? new Date().toISOString() } });
+        });
+    }
+    /** Forget the config (selection, recent, onboarding). Tokens are untouched. */
+    resetOnboarding() {
+        return this.enqueue(() => rm(this.path, { force: true }));
+    }
+}

package/dist/control-center/apps.js

@@ -0,0 +1,15 @@
+import { fetchAllPages } from "./pagination.js";
+export function mapApp(raw) {
+    const r = (raw ?? {});
+    return {
+        id: String(r.id),
+        name: typeof r.name === "string" ? r.name : "",
+        archived: r.archived === true,
+        defaultLanguage: typeof r.default_language === "string" ? r.default_language : null,
+        logo: typeof r.logo === "string" ? r.logo : null,
+    };
+}
+export async function listApps(session, opts = {}) {
+    const apps = await fetchAllPages(session, "/private/apps/", {}, mapApp);
+    return opts.includeArchived ? apps : apps.filter((a) => !a.archived);
+}

package/dist/control-center/errors.js

@@ -0,0 +1,10 @@
+export class ControlCenterError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = "ControlCenterError";
+    }
+}

package/dist/control-center/pagination.js

@@ -0,0 +1,29 @@
+import { ControlCenterError } from "./errors.js";
+/** DRF `StandardPagination` page size (omaha `PAGE_SIZE`). */
+export const PAGE_SIZE = 50;
+/**
+ * Fetch every page of a paginated private endpoint.
+ *
+ * Stop rule: a page with fewer than PAGE_SIZE results is the last one. The
+ * paginator returns 404 for any page past the end (never an empty `results`),
+ * so a 404 on page ≥ 2 right after a full page means "done", not "not found".
+ */
+export async function fetchAllPages(session, path, params, map) {
+    const out = [];
+    for (let page = 1;; page++) {
+        const query = new URLSearchParams({ ...params, page: String(page) }).toString();
+        const res = await session.authorizedFetch(`${path}?${query}`);
+        if (res.status === 404) {
+            if (page > 1)
+                return out;
+            throw new ControlCenterError("not_found", `${path} was not found on this host.`, 404);
+        }
+        if (!res.ok)
+            throw new ControlCenterError("http", `Request to ${path} failed (HTTP ${res.status}).`, res.status);
+        const body = (await res.json());
+        const results = Array.isArray(body.results) ? body.results : [];
+        out.push(...results.map(map));
+        if (results.length < PAGE_SIZE)
+            return out;
+    }
+}

package/dist/control-center/platforms.js

@@ -0,0 +1,28 @@
+import { fetchAllPages } from "./pagination.js";
+const PLATFORM_TYPE_LABELS = {
+    apple: "Apple",
+    google: "Google Play",
+    amazon_iap: "Amazon",
+    roku_pay: "Roku",
+    web: "Web",
+};
+export const platformTypeLabel = (type) => PLATFORM_TYPE_LABELS[type] ?? type;
+export function mapPlatform(raw) {
+    const r = (raw ?? {});
+    const type = typeof r.type === "string" ? r.type : "";
+    return {
+        id: String(r.id),
+        appId: typeof r.app === "string" ? r.app : null,
+        name: typeof r.name === "string" ? r.name : "",
+        type,
+        typeLabel: platformTypeLabel(type),
+        sdkEnabled: r.sdk_enabled === true,
+        isConfigValid: r.is_config_valid === true,
+        archived: r.archived === true,
+        marketplaceAppId: typeof r.marketplace_app_id === "string" ? r.marketplace_app_id : null,
+    };
+}
+export async function listPlatforms(session, appId, opts = {}) {
+    const platforms = await fetchAllPages(session, "/private/platforms/", { app_id: appId }, mapPlatform);
+    return opts.includeArchived ? platforms : platforms.filter((p) => !p.archived);
+}

package/dist/control-center/resolve.js

@@ -0,0 +1,35 @@
+export class ResolveError extends Error {
+    reason;
+    label;
+    query;
+    candidates;
+    constructor(reason, label, query, candidates) {
+        super(reason === "none"
+            ? `No ${label} matches "${query}".`
+            : `"${query}" matches more than one ${label}: ${candidates.join(", ")}. Use the id or a more specific name.`);
+        this.reason = reason;
+        this.label = label;
+        this.query = query;
+        this.candidates = candidates;
+        this.name = "ResolveError";
+    }
+}
+/** Exact id → exact name (case-insensitive) → unique case-insensitive substring. */
+export function resolve(items, query, label) {
+    const q = query.trim();
+    const byId = items.find((i) => i.id === q);
+    if (byId)
+        return byId;
+    const lower = q.toLowerCase();
+    const byName = items.filter((i) => i.name.toLowerCase() === lower);
+    if (byName.length === 1)
+        return byName[0];
+    const bySubstring = items.filter((i) => i.name.toLowerCase().includes(lower));
+    if (bySubstring.length === 1)
+        return bySubstring[0];
+    if (bySubstring.length === 0)
+        throw new ResolveError("none", label, q, []);
+    throw new ResolveError("ambiguous", label, q, bySubstring.map((i) => i.name));
+}
+export const findApp = (apps, query) => resolve(apps, query, "app");
+export const findPlatform = (platforms, query) => resolve(platforms, query, "platform");

package/dist/hosts.js

@@ -0,0 +1,13 @@
+/** Control Center API hosts (the same hosts nami-cli profiles point at). */
+export const CONTROL_CENTER_HOSTS = {
+    production: "https://app.namiml.com",
+    staging: "https://app-staging.namiml.com",
+};
+export function resolveHost(name) {
+    const key = (name ?? "production");
+    const baseUrl = CONTROL_CENTER_HOSTS[key];
+    if (!baseUrl) {
+        throw new Error(`Unknown host "${name}". Use one of: ${Object.keys(CONTROL_CENTER_HOSTS).join(", ")}.`);
+    }
+    return { name: key, baseUrl };
+}

package/dist/paths.js

@@ -0,0 +1,5 @@
+import envPaths from "env-paths";
+/** CLI config directory. `NAMI_CLI_HOME` overrides it (tests, CI, sandboxes). */
+export function configDir(env = process.env) {
+    return env.NAMI_CLI_HOME || envPaths("nami", { suffix: "" }).config;
+}

package/dist/program.js

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+import { NAMI_CLI_VERSION } from "./version.js";
+const HOST_FLAG = "--host <name>";
+const HOST_HELP = "Nami environment: production (default) or staging";
+export function createProgram(h, options = {}) {
+    const program = new Command();
+    // Root options (--host/--app/--platform for bare `nami`) must only apply BEFORE a
+    // subcommand name; otherwise commander files `nami platforms --app X` under the
+    // root and the subcommand's required --app comes up missing.
+    program.enablePositionalOptions();
+    if (options.testing) {
+        program.exitOverride().configureOutput({ writeOut: () => { }, writeErr: () => { } });
+    }
+    program
+        .name("nami")
+        .description("Nami SDK developer CLI — a terminal test app for your Nami integration.")
+        .version(NAMI_CLI_VERSION, "-v, --version")
+        .showHelpAfterError()
+        .option(HOST_FLAG, HOST_HELP)
+        .option("--app <id-or-name>", "skip the app picker")
+        .option("--platform <id-or-name>", "skip the platform picker")
+        .action(async (_opts, cmd) => {
+        const opts = cmd.optsWithGlobals();
+        process.exitCode = await h.shell(opts);
+    });
+    program
+        .command("login")
+        .description("Sign in to the Nami Control Center (email + password, then your authenticator code if enabled).")
+        .option(HOST_FLAG, HOST_HELP)
+        .option("--totp-code <code>", "one-time authenticator code (skips the prompt; never stored)")
+        .option("--org <id-or-name>", "organization to select without prompting")
+        .option("--print-token", "print the access token after sign-in, for use as NAMI_TOKEN in CI")
+        .action(async (_opts, cmd) => {
+        process.exitCode = await h.login(cmd.optsWithGlobals());
+    });
+    program
+        .command("logout")
+        .description("Forget the stored sign-in tokens on this machine.")
+        .option(HOST_FLAG, HOST_HELP)
+        .action(async (_opts, cmd) => {
+        process.exitCode = await h.logout(cmd.optsWithGlobals());
+    });
+    program
+        .command("whoami")
+        .description("Show the signed-in account and organization.")
+        .option(HOST_FLAG, HOST_HELP)
+        .option("--json", "machine-readable output (never includes tokens)")
+        .action(async (_opts, cmd) => {
+        process.exitCode = await h.whoami(cmd.optsWithGlobals());
+    });
+    program
+        .command("apps")
+        .description("List the apps in your organization.")
+        .option(HOST_FLAG, HOST_HELP)
+        .option("--all", "include archived apps")
+        .option("--json", "machine-readable output")
+        .action(async (_opts, cmd) => {
+        process.exitCode = await h.apps(cmd.optsWithGlobals());
+    });
+    program
+        .command("platforms")
+        .description("List an app's platforms. The id column is the App Platform ID the SDK uses.")
+        .requiredOption("--app <id-or-name>", "app id, exact name, or unique substring")
+        .option(HOST_FLAG, HOST_HELP)
+        .option("--all", "include archived platforms")
+        .option("--json", "machine-readable output")
+        .action(async (_opts, cmd) => {
+        process.exitCode = await h.platforms(cmd.optsWithGlobals());
+    });
+    program
+        .command("configure")
+        .description("Verify an App Platform ID and configure the SDK against it (headless).")
+        .requiredOption("--app-platform-id <uuid>", "the App Platform ID (nami platforms shows it)")
+        .option(HOST_FLAG, HOST_HELP)
+        .option("--json", "machine-readable result")
+        .action(async (_opts, cmd) => {
+        process.exitCode = await h.configure(cmd.optsWithGlobals());
+    });
+    program
+        .command("config")
+        .description("Show the persisted CLI state (host, org, current app/platform, recent, onboarding). Never contains secrets.")
+        .option(HOST_FLAG, HOST_HELP)
+        .option("--json", "print config.json verbatim")
+        .action(async (_opts, cmd) => {
+        process.exitCode = await h.config(cmd.optsWithGlobals());
+    });
+    program
+        .command("onboarding")
+        .description("Show the onboarding step, or start over with --reset (keeps your sign-in).")
+        .option(HOST_FLAG, HOST_HELP)
+        .option("--reset", "forget the current selection, recent list and onboarding progress")
+        .action(async (_opts, cmd) => {
+        process.exitCode = await h.onboarding(cmd.optsWithGlobals());
+    });
+    program
+        .command("demo")
+        .description("Show the placeholder screen with the tide animation.")
+        .action(() => h.demo());
+    return program;
+}