@namiml/cli 3.4.11-dev.202609221916

package/LICENSE

@@ -0,0 +1 @@
+© Nami ML Inc. Your use is subject to the terms at https://www.namiml.com/

package/README.md

@@ -0,0 +1,21 @@
+# Nami CLI
+
+`nami` is the terminal test app for your Nami integration: configure the SDK against your app, list and launch placements, see your pages and flows rendered in the terminal, inspect API traffic and customer attributes, and check your implementation against what a flow expects.
+
+```bash
+npx @namiml/cli            # run without installing
+npm install -g @namiml/cli # or install the `nami` command
+nami --version
+```
+
+Requires Node 20+. Single-file executables for macOS, Linux and Windows are attached to each [release](https://github.com/namiml/nami-cli/releases).
+
+`@namiml/cli` is versioned in lockstep with the Nami SDKs — `nami --version` tells you exactly which SDK release it is pinned to.
+
+## Status
+
+Early access. The current release is a scaffold; the test-app screens, onboarding and implementation checks are landing release by release. Each [GitHub release](https://github.com/namiml/nami-cli/releases) carries its notes.
+
+## License
+
+© Nami ML Inc. Your use is subject to the terms at <https://www.namiml.com/>.

package/dist/App.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text, useApp } from "ink";
+import { NAMI_SDK_VERSION } from "@namiml/sdk-core";
+import { NAMI_CLI_VERSION } from "./version.js";
+import { Thinking } from "./components/Thinking.js";
+import { palette } from "./theme.js";
+export function App({ demo = true, demoMs = 2200, phase }) {
+    const { exit } = useApp();
+    const [ready, setReady] = useState(false);
+    useEffect(() => {
+        if (!demo)
+            return;
+        const id = setTimeout(() => setReady(true), demoMs);
+        return () => clearTimeout(id);
+    }, [demo, demoMs]);
+    useEffect(() => {
+        if (demo && ready)
+            exit();
+    }, [demo, ready, exit]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Nami SDK CLI" }), _jsxs(Text, { children: ["@namiml/cli ", NAMI_CLI_VERSION] }), _jsxs(Text, { dimColor: true, children: ["pinned to @namiml/sdk-core ", NAMI_SDK_VERSION] }), _jsx(Text, { children: "Test app, onboarding and checks land in NAM-4482 sub-tickets." })] }), demo && !ready && _jsx(Thinking, { label: "Warming up the tide\u2026", phase: phase }), demo && ready && _jsx(Text, { color: palette.aqua, children: "Ready." })] }));
+}

package/dist/adapters/file-storage.adapter.js

@@ -0,0 +1,87 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const DEBOUNCE_MS = 50;
+/** Storage file for one App Platform ID. Throws on path-traversal attempts. */
+export function storagePathFor(appPlatformId, configDir) {
+    if (!/^[A-Za-z0-9-]+$/.test(appPlatformId))
+        throw new Error(`Refusing to build a storage path from "${appPlatformId}".`);
+    return join(configDir, "storage", `${appPlatformId}.json`);
+}
+/**
+ * Synchronous IStorageAdapter backed by one JSON file per App Platform ID, so
+ * each platform keeps its own device identity, profile and cache. Loads once,
+ * writes through with a short debounce, and flushes on process exit.
+ */
+export class FileStorageAdapter {
+    path;
+    data = new Map();
+    timer = null;
+    dirty = false;
+    onExit = () => this.flush();
+    constructor(path) {
+        this.path = path;
+        try {
+            if (existsSync(path)) {
+                const parsed = JSON.parse(readFileSync(path, "utf8"));
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    for (const [k, v] of Object.entries(parsed)) {
+                        if (typeof v === "string")
+                            this.data.set(k, v);
+                    }
+                }
+            }
+        }
+        catch {
+            // Corrupt file: start empty; the next write replaces it.
+        }
+        process.once("exit", this.onExit);
+    }
+    getItem(key) {
+        return this.data.get(key) ?? null;
+    }
+    setItem(key, value) {
+        this.data.set(key, value);
+        this.schedule();
+    }
+    removeItem(key) {
+        if (this.data.delete(key))
+            this.schedule();
+    }
+    clear() {
+        this.data.clear();
+        this.schedule();
+    }
+    getAllKeys() {
+        return [...this.data.keys()];
+    }
+    /** Write pending changes now (also called on process exit). */
+    flush() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (!this.dirty)
+            return;
+        this.dirty = false;
+        mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+        const tmp = `${this.path}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(Object.fromEntries(this.data), null, 2) + "\n", { mode: 0o600 });
+        chmodSync(tmp, 0o600);
+        renameSync(tmp, this.path);
+    }
+    /** Stop listening for exit (tests, or when swapping platforms). Flushes first. */
+    dispose() {
+        this.flush();
+        process.off("exit", this.onExit);
+    }
+    schedule() {
+        this.dirty = true;
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.flush();
+        }, DEBOUNCE_MS);
+        this.timer.unref?.();
+    }
+}

package/dist/adapters/index.js

@@ -0,0 +1,18 @@
+import { registerPlatformAdapters, registerPurchaseAdapter } from "@namiml/sdk-core";
+import { TerminalStorageAdapter } from "./terminal-storage.adapter.js";
+import { TerminalDeviceAdapter } from "./terminal-device.adapter.js";
+import { TerminalUIAdapter } from "./terminal-ui.adapter.js";
+import { TerminalPurchaseAdapter } from "./terminal-purchase.adapter.js";
+/** Register the terminal adapter set with @namiml/sdk-core. Call before Nami.configure(). */
+export function registerTerminalAdapters(options = {}) {
+    const adapters = {
+        storage: options.storage ?? new TerminalStorageAdapter(),
+        device: new TerminalDeviceAdapter(),
+        ui: new TerminalUIAdapter(),
+        purchase: new TerminalPurchaseAdapter(),
+    };
+    registerPlatformAdapters({ storage: adapters.storage, device: adapters.device, ui: adapters.ui });
+    registerPurchaseAdapter(adapters.purchase);
+    return adapters;
+}
+export { TerminalStorageAdapter, TerminalDeviceAdapter, TerminalUIAdapter, TerminalPurchaseAdapter };

package/dist/adapters/terminal-device.adapter.js

@@ -0,0 +1,39 @@
+import os from "node:os";
+import { randomUUID } from "node:crypto";
+import { NAMI_SDK_PACKAGE_VERSION } from "@namiml/sdk-core";
+const SDK_CLIENT = "cli";
+function terminalLanguage() {
+    const raw = process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || "en";
+    const tag = raw.split(".")[0].replace("_", "-");
+    return !tag || tag === "C" || tag === "POSIX" ? "en" : tag;
+}
+export class TerminalDeviceAdapter {
+    getDeviceData() {
+        return {
+            os_name: os.platform(),
+            os_version: os.release(),
+            browser_name: "",
+            browser_version: "",
+            sdk_client: SDK_CLIENT,
+            sdk_version: NAMI_SDK_PACKAGE_VERSION,
+            language: this.getLanguage(),
+            extended_platform: "node",
+            extended_platform_version: process.versions.node,
+        };
+    }
+    getDeviceFormFactor() {
+        return "desktop";
+    }
+    getDeviceScaleFactor() {
+        return 1;
+    }
+    generateUUID() {
+        return randomUUID();
+    }
+    getScreenInfo() {
+        return { width: process.stdout.columns ?? 80, height: process.stdout.rows ?? 24, scale: 1 };
+    }
+    getLanguage() {
+        return terminalLanguage();
+    }
+}

package/dist/adapters/terminal-purchase.adapter.js

@@ -0,0 +1,12 @@
+/** Simulated store: the CLI never talks to App Store / Play / Stripe. */
+export class TerminalPurchaseAdapter {
+    async getProducts(_skuIds) {
+        return [];
+    }
+    async purchase(skuId, _context) {
+        return { success: false, skuId, message: "Purchases are simulated in the Nami CLI" };
+    }
+    async restorePurchases() {
+        return [];
+    }
+}

package/dist/adapters/terminal-storage.adapter.js

@@ -0,0 +1,19 @@
+/** In-memory storage. File-backed persistence arrives with onboarding (NAM-4482). */
+export class TerminalStorageAdapter {
+    store = new Map();
+    getItem(key) {
+        return this.store.get(key) ?? null;
+    }
+    setItem(key, value) {
+        this.store.set(key, value);
+    }
+    removeItem(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+    getAllKeys() {
+        return [...this.store.keys()];
+    }
+}

package/dist/adapters/terminal-ui.adapter.js

@@ -0,0 +1,23 @@
+/**
+ * Listener-style UI adapter (same shape as Expo's). Core calls createPaywall();
+ * the future composite renderer subscribes via onPaywallRequested().
+ */
+export class TerminalUIAdapter {
+    paywallListener = null;
+    onPaywallRequested(listener) {
+        this.paywallListener = listener;
+        return () => {
+            this.paywallListener = null;
+        };
+    }
+    createPaywall(type, value, context) {
+        const request = { type, value, context };
+        this.paywallListener?.(request);
+        return request;
+    }
+    reRenderPaywall() { }
+    flowNavigateToScreen(_paywall, _options) { }
+    onReset() {
+        this.paywallListener = null;
+    }
+}

package/dist/auth/control-center.js

@@ -0,0 +1,130 @@
+import { NAMI_CLI_VERSION } from "../version.js";
+import { AuthError } from "./errors.js";
+const LOGIN = "/private/account/login/";
+const CONFIRM_MFA = "/private/account/login/confirm_mfa/";
+const TOKEN_REFRESH = "/private/account/token/refresh/";
+const ACCOUNT = "/private/account/";
+/**
+ * Omaha's two-step login (password → optional TOTP) and org-scoped token
+ * refresh, as consumed by nami-platform's `nami-cli`. Credentials are used for
+ * exactly one request and never retained or logged.
+ */
+export class ControlCenterAuth {
+    baseUrl;
+    fetchImpl;
+    userAgent;
+    constructor(baseUrl, fetchImpl = globalThis.fetch, userAgent = `@namiml/cli/${NAMI_CLI_VERSION}`) {
+        this.baseUrl = baseUrl;
+        this.fetchImpl = fetchImpl;
+        this.userAgent = userAgent;
+    }
+    async login(username, password) {
+        const res = await this.request("POST", LOGIN, { username, password });
+        if (res.status === 429)
+            throw throttled(res.status);
+        if (res.status === 400 || res.status === 401 || res.status === 403) {
+            throw new AuthError("invalid_credentials", "Email or password is incorrect.", res.status);
+        }
+        if (!res.ok)
+            throw httpError("Sign-in", res.status);
+        const data = (await res.json());
+        if (typeof data.pre_auth_token === "string") {
+            return {
+                kind: "mfa_required",
+                preAuthToken: data.pre_auth_token,
+                authenticators: Array.isArray(data.authenticators) ? data.authenticators : [],
+            };
+        }
+        return signedIn(data);
+    }
+    async confirmMfa(preAuthToken, code, type = "totp") {
+        const res = await this.request("POST", CONFIRM_MFA, { code, type }, { authorization: `Bearer ${preAuthToken}` });
+        if (res.status === 429)
+            throw throttled(res.status);
+        if (res.status === 400 || res.status === 401 || res.status === 403) {
+            throw new AuthError("mfa_invalid", "That code was not accepted. Check your authenticator app and try again.", res.status);
+        }
+        if (!res.ok)
+            throw httpError("Two-factor confirmation", res.status);
+        return signedIn((await res.json()));
+    }
+    /** Exchange the refresh token for an access token scoped to `orgId` (201). */
+    async selectOrg(refreshToken, orgId) {
+        const res = await this.request("POST", TOKEN_REFRESH, { refresh_token: refreshToken, selected_org: orgId });
+        if (res.status === 429)
+            throw throttled(res.status);
+        if (res.status === 401 || res.status === 403) {
+            const detail = await detailOf(res);
+            if (/org/i.test(detail)) {
+                throw new AuthError("org_forbidden", "Your account does not have access to that organization.", res.status);
+            }
+            throw new AuthError("session_expired", "Your session has expired. Run `nami login` again.", res.status);
+        }
+        if (!res.ok)
+            throw httpError("Token refresh", res.status);
+        const data = (await res.json());
+        if (typeof data.access_token !== "string")
+            throw httpError("Token refresh", res.status);
+        return data.access_token;
+    }
+    async fetchAccount(accessToken) {
+        const res = await this.request("GET", ACCOUNT, undefined, { authorization: `Bearer ${accessToken}` });
+        if (res.status === 401 || res.status === 403) {
+            throw new AuthError("session_expired", "Your session has expired. Run `nami login` again.", res.status);
+        }
+        if (!res.ok)
+            throw httpError("Account lookup", res.status);
+        return toProfile((await res.json()));
+    }
+    async request(method, path, body, headers = {}) {
+        try {
+            return await this.fetchImpl(this.baseUrl + path, {
+                method,
+                headers: {
+                    accept: "application/json",
+                    "user-agent": this.userAgent,
+                    ...(body ? { "content-type": "application/json" } : {}),
+                    ...headers,
+                },
+                body: body ? JSON.stringify(body) : undefined,
+            });
+        }
+        catch {
+            throw new AuthError("network", `Could not reach ${this.baseUrl}. Check your connection and the host.`);
+        }
+    }
+}
+function signedIn(data) {
+    if (typeof data.access_token !== "string" || typeof data.refresh_token !== "string") {
+        throw new AuthError("http", "Sign-in response did not include tokens.");
+    }
+    return {
+        kind: "signed_in",
+        tokens: { accessToken: data.access_token, refreshToken: data.refresh_token },
+        profile: toProfile(data.profile ?? {}),
+    };
+}
+function toProfile(profile) {
+    const orgs = Array.isArray(profile.orgs)
+        ? profile.orgs.map((o) => ({ id: String(o.id), name: String(o.name) }))
+        : [];
+    const details = profile.default_org_member_details;
+    const defaultOrg = details?.org;
+    return {
+        id: typeof profile.id === "string" ? profile.id : undefined,
+        username: typeof profile.username === "string" ? profile.username : undefined,
+        orgs,
+        defaultOrgId: typeof defaultOrg?.id === "string" ? defaultOrg.id : null,
+    };
+}
+async function detailOf(res) {
+    try {
+        const data = (await res.json());
+        return typeof data.detail === "string" ? data.detail : "";
+    }
+    catch {
+        return "";
+    }
+}
+const throttled = (status) => new AuthError("throttled", "Too many sign-in attempts. Wait a minute and try again.", status);
+const httpError = (what, status) => new AuthError("http", `${what} failed (HTTP ${status}).`, status);

package/dist/auth/errors.js

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

package/dist/auth/redact.js

@@ -0,0 +1,11 @@
+/** Mask credentials in headers before they are rendered anywhere (logs, traffic tab). */
+export function redactAuthorization(headers) {
+    const out = { ...headers };
+    for (const key of Object.keys(out)) {
+        if (key.toLowerCase() === "authorization") {
+            const scheme = out[key].split(" ")[0];
+            out[key] = `${scheme} ***`;
+        }
+    }
+    return out;
+}

package/dist/auth/session.js

@@ -0,0 +1,56 @@
+import { AuthError } from "./errors.js";
+const NOT_SIGNED_IN = "Not signed in. Run `nami login` first.";
+const EXPIRED = "Your session has expired. Run `nami login` again.";
+/**
+ * Authenticated access to the Control Center API. Uses `NAMI_TOKEN` when set
+ * (headless / CI — never persisted), otherwise the stored session, refreshing
+ * the org-scoped access token once on 401.
+ */
+export class AuthSession {
+    store;
+    auth;
+    baseUrl;
+    fetchImpl;
+    env;
+    constructor(store, auth, 
+    /** Control Center base URL; paths passed to authorizedFetch are resolved against it. */
+    baseUrl, fetchImpl = globalThis.fetch, env = process.env) {
+        this.store = store;
+        this.auth = auth;
+        this.baseUrl = baseUrl;
+        this.fetchImpl = fetchImpl;
+        this.env = env;
+    }
+    current() {
+        return this.store.load();
+    }
+    /** `pathOrUrl` may be an absolute URL or a `/private/...` path. */
+    async authorizedFetch(pathOrUrl, init = {}) {
+        const url = pathOrUrl.startsWith("/") ? this.baseUrl.replace(/\/$/, "") + pathOrUrl : pathOrUrl;
+        const envToken = this.env.NAMI_TOKEN;
+        if (envToken)
+            return this.withBearer(url, init, envToken);
+        const session = await this.store.load();
+        if (!session)
+            throw new AuthError("session_expired", NOT_SIGNED_IN);
+        const first = await this.withBearer(url, init, session.accessToken);
+        if (first.status !== 401)
+            return first;
+        let fresh;
+        try {
+            fresh = await this.auth.selectOrg(session.refreshToken, session.orgId);
+        }
+        catch {
+            throw new AuthError("session_expired", EXPIRED, 401);
+        }
+        await this.store.save({ ...session, accessToken: fresh, savedAt: new Date().toISOString() });
+        const retry = await this.withBearer(url, init, fresh);
+        if (retry.status === 401)
+            throw new AuthError("session_expired", EXPIRED, 401);
+        return retry;
+    }
+    withBearer(url, init, token) {
+        const headers = { accept: "application/json", ...init.headers, authorization: `Bearer ${token}` };
+        return this.fetchImpl(url, { ...init, headers });
+    }
+}

package/dist/auth/token-store.js

@@ -0,0 +1,36 @@
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const isStoredSession = (value) => typeof value === "object" &&
+    value !== null &&
+    typeof value.accessToken === "string" &&
+    typeof value.refreshToken === "string" &&
+    typeof value.baseUrl === "string";
+/** `tokens.json` under the config dir: directory 0700, file 0600, atomic replace. */
+export class FileTokenStore {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    get path() {
+        return join(this.dir, "tokens.json");
+    }
+    async load() {
+        try {
+            const parsed = JSON.parse(await readFile(this.path, "utf8"));
+            return isStoredSession(parsed) ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async save(session) {
+        await mkdir(this.dir, { recursive: true, mode: 0o700 });
+        const tmp = `${this.path}.${process.pid}.tmp`;
+        await writeFile(tmp, JSON.stringify(session, null, 2) + "\n", { mode: 0o600 });
+        await chmod(tmp, 0o600);
+        await rename(tmp, this.path);
+    }
+    async clear() {
+        await rm(this.path, { force: true });
+    }
+}

package/dist/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "./App.js";
+import { createProgram } from "./program.js";
+import { buildContext } from "./commands/context.js";
+import { login } from "./commands/login.js";
+import { logout } from "./commands/logout.js";
+import { whoami } from "./commands/whoami.js";
+import { apps } from "./commands/apps.js";
+import { platforms } from "./commands/platforms.js";
+import { shell } from "./commands/shell.js";
+import { configure } from "./commands/configure.js";
+import { config } from "./commands/config.js";
+import { onboarding } from "./commands/onboarding.js";
+const program = createProgram({
+    shell: async (opts) => shell(opts, await buildContext(opts.host)),
+    demo: () => { render(_jsx(App, {})); },
+    login: async (opts) => login(opts, await buildContext(opts.host)),
+    logout: async (opts) => logout(await buildContext(opts.host)),
+    whoami: async (opts) => whoami(opts, await buildContext(opts.host)),
+    apps: async (opts) => apps(opts, await buildContext(opts.host)),
+    platforms: async (opts) => platforms(opts, await buildContext(opts.host)),
+    configure: async (opts) => configure(opts, await buildContext(opts.host)),
+    config: async (opts) => config(opts, await buildContext(opts.host)),
+    onboarding: async (opts) => onboarding(opts, await buildContext(opts.host)),
+});
+await program.parseAsync(process.argv);

package/dist/commands/apps.js

@@ -0,0 +1,26 @@
+import { AuthError } from "../auth/errors.js";
+import { listApps } from "../control-center/apps.js";
+import { renderTable } from "./list-output.js";
+/** `nami apps` — list the signed-in org's apps. Returns the exit code. */
+export async function apps(opts, ctx) {
+    try {
+        const items = await listApps(ctx.session, { includeArchived: Boolean(opts.all) });
+        if (opts.json) {
+            ctx.out(JSON.stringify(items, null, 2));
+        }
+        else if (items.length === 0) {
+            ctx.out(`No apps found on ${ctx.host.name}. Create one in the Control Center (${ctx.host.baseUrl}).`);
+        }
+        else {
+            ctx.out(renderTable(items, ["id", "name", "defaultLanguage", "archived"]));
+        }
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof AuthError) {
+            ctx.err(error.message);
+            return 1;
+        }
+        throw error;
+    }
+}

package/dist/commands/config.js

@@ -0,0 +1,20 @@
+const sel = (s) => `${s.appName} · ${s.platformName} (${s.platformType})${s.device ? ` · ${s.device.displayName}` : ""}  ${s.appPlatformId}`;
+/** `nami config` — show the persisted, secret-free state. Returns the exit code. */
+export async function config(opts, ctx) {
+    const { config, warning } = await ctx.config.load();
+    if (warning)
+        ctx.err(warning);
+    if (opts.json) {
+        ctx.out(JSON.stringify(config, null, 2));
+        return 0;
+    }
+    ctx.out(`Config:     ${ctx.config.path}`);
+    ctx.out(`Host:       ${config.host}`);
+    ctx.out(`Org:        ${config.session.orgName ?? "—"}${config.session.orgId ? ` (${config.session.orgId})` : ""}`);
+    ctx.out(`Current:    ${config.current ? sel(config.current) : "— (run nami to pick an app and platform)"}`);
+    ctx.out(`Recent:     ${config.recent.length === 0 ? "—" : ""}`);
+    for (const r of config.recent)
+        ctx.out(`            ${sel(r)}`);
+    ctx.out(`Onboarding: ${config.onboarding.step}${config.onboarding.completedAt ? ` (completed ${config.onboarding.completedAt})` : ""}`);
+    return 0;
+}

package/dist/commands/configure.js

@@ -0,0 +1,29 @@
+import { configureSdk } from "../sdk/configure.js";
+import { SDK_DISABLED_MESSAGE, VerifyError, verifyAppPlatform } from "../sdk/verify.js";
+/** `nami configure --app-platform-id <uuid>` — headless verify + configure. Returns the exit code. */
+export async function configure(opts, ctx, deps = {}) {
+    const verify = deps.verify ?? verifyAppPlatform;
+    const run = deps.configure ?? configureSdk;
+    let result;
+    try {
+        const verified = await verify(ctx.host.baseUrl, opts.appPlatformId, deps.fetch ?? globalThis.fetch);
+        if (verified.kind === "sdk_disabled")
+            ctx.err(SDK_DISABLED_MESSAGE);
+        result = await run({ host: ctx.host, appPlatformId: opts.appPlatformId }, { ...deps, verified });
+    }
+    catch (error) {
+        if (error instanceof VerifyError) {
+            ctx.err(error.message);
+            return error.code === "invalid_id" ? 2 : 1;
+        }
+        throw error;
+    }
+    if (opts.json) {
+        ctx.out(JSON.stringify(result, null, 2));
+    }
+    else {
+        ctx.out(`Configured ${result.appPlatformId} on ${result.host}: ${result.configureState}${result.sdkEnabled ? "" : " (SDK disabled)"}`);
+        ctx.out(`placements ${result.counts.placements} · products ${result.counts.products} · paywalls ${result.counts.paywalls}${result.deviceId ? ` · device ${result.deviceId}` : ""}`);
+    }
+    return result.sdkInitialized ? 0 : 1;
+}

package/dist/commands/context.js

@@ -0,0 +1,26 @@
+import { ControlCenterAuth } from "../auth/control-center.js";
+import { AuthSession } from "../auth/session.js";
+import { FileTokenStore } from "../auth/token-store.js";
+import { resolveHost } from "../hosts.js";
+import { configDir } from "../paths.js";
+import { ConfigStore } from "../config/store.js";
+export async function buildContext(hostFlag, env = process.env) {
+    const dir = configDir(env);
+    const store = new FileTokenStore(dir);
+    const config = new ConfigStore(dir);
+    const stored = await store.load();
+    // Without an explicit --host, follow the stored session, then the persisted config.
+    const host = resolveHost(hostFlag ?? stored?.host ?? (await config.load()).config.host);
+    const auth = new ControlCenterAuth(host.baseUrl);
+    return {
+        host,
+        store,
+        config,
+        auth,
+        session: new AuthSession(store, auth, host.baseUrl, globalThis.fetch, env),
+        env,
+        out: (line) => process.stdout.write(line + "\n"),
+        err: (line) => process.stderr.write(line + "\n"),
+        isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    };
+}

package/dist/commands/list-output.js

@@ -0,0 +1,9 @@
+/** Fixed-width text table for list commands. Values are stringified; columns sized to content. */
+export function renderTable(rows, columns) {
+    if (rows.length === 0)
+        return "";
+    const cells = rows.map((r) => columns.map((c) => String(r[c] ?? "")));
+    const widths = columns.map((c, i) => Math.max(c.length, ...cells.map((row) => row[i].length)));
+    const line = (vals) => vals.map((v, i) => v.padEnd(widths[i])).join("  ").trimEnd();
+    return [line(columns), line(widths.map((w) => "-".repeat(w))), ...cells.map(line)].join("\n");
+}