@namiml/cli 3.4.11-dev.202609222238 → 3.4.11-dev.202609230009

package/dist/cli.js

@@ -11,6 +11,7 @@ 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 { use } from "./commands/use.js";
 import { config } from "./commands/config.js";
 import { onboarding } from "./commands/onboarding.js";
 import { devices } from "./commands/devices.js";
@@ -23,6 +24,7 @@ const program = createProgram({
     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)),
+    use: async (opts) => use(opts, await buildContext(opts.host)),
     config: async (opts) => config(opts, await buildContext(opts.host)),
     onboarding: async (opts) => onboarding(opts, await buildContext(opts.host)),
     devices: async (opts) => devices(opts, await buildContext(opts.host)),

package/dist/commands/use.js

@@ -0,0 +1,131 @@
+import { AuthError } from "../auth/errors.js";
+import { listApps } from "../control-center/apps.js";
+import { listPlatforms } from "../control-center/platforms.js";
+import { findAppPlatformById, pastedStandIn } from "../control-center/lookup.js";
+import { findApp, findPlatform, resolve, ResolveError } from "../control-center/resolve.js";
+import { appFrom, platformFrom, selectionFrom } from "../config/selection.js";
+import { resolveDevice, toSelection } from "../devices/presets.js";
+import { verifyAppPlatform, VerifyError } from "../sdk/verify.js";
+const NOT_SIGNED_IN = "Not signed in. Run `nami login` first.";
+const NO_FLAGS = "nami use needs one of --org, --app, --platform, --app-platform-id or --device. Run nami for the interactive picker.";
+const NO_CURRENT_APP = "No app selected yet. Pass --app too, or run nami once.";
+const summary = (s) => {
+    const device = s.device ? ` · ${s.device.displayName}` : "";
+    return `Now using ${s.appName} · ${s.platformName} (${s.platformType})${device}`;
+};
+/** `nami use` — record and validate a selection (org, app, platform, app-platform-id or device). Never runs the SDK. */
+export async function use(opts, ctx, deps = {}) {
+    const verify = deps.verify ?? verifyAppPlatform;
+    const doListApps = deps.listApps ?? listApps;
+    const doListPlatforms = deps.listPlatforms ?? listPlatforms;
+    if (!opts.org && !opts.app && !opts.platform && !opts.appPlatformId && !opts.device) {
+        ctx.err(NO_FLAGS);
+        return 2;
+    }
+    try {
+        if (opts.org) {
+            const stored = await ctx.store.load();
+            if (!stored) {
+                ctx.err(NOT_SIGNED_IN);
+                return 1;
+            }
+            const profile = await ctx.auth.fetchAccount(stored.accessToken);
+            const org = resolve(profile.orgs, opts.org, "organization");
+            const accessToken = await ctx.auth.selectOrg(stored.refreshToken, org.id);
+            const next = { ...stored, accessToken, orgId: org.id, orgName: org.name, savedAt: new Date().toISOString() };
+            await ctx.store.save(next);
+            await ctx.config.setSession({ orgId: org.id, orgName: org.name });
+            // Apps are org-scoped: a bare --org switch invalidates whatever app/platform was current.
+            if (!opts.app && !opts.appPlatformId)
+                await ctx.config.clearCurrent();
+            if (!opts.app && !opts.platform && !opts.appPlatformId && !opts.device) {
+                if (opts.json) {
+                    const { config } = await ctx.config.load();
+                    ctx.out(JSON.stringify(config.current, null, 2));
+                }
+                else {
+                    ctx.out(`Now using organization ${org.name}.`);
+                }
+                return 0;
+            }
+        }
+        let app;
+        let platform;
+        if (opts.appPlatformId) {
+            await verify(ctx.host.baseUrl, opts.appPlatformId, deps.fetch ?? globalThis.fetch);
+            // The id is verified on a public endpoint; naming it needs a session, so a
+            // failed lookup degrades to the stand-ins instead of refusing the switch.
+            const named = (await findAppPlatformById(ctx.session, opts.appPlatformId, { listApps: doListApps, listPlatforms: doListPlatforms })) ?? pastedStandIn(opts.appPlatformId);
+            app = named.app;
+            platform = named.platform;
+        }
+        else if (opts.app) {
+            app = findApp(await doListApps(ctx.session), opts.app);
+            const platforms = await doListPlatforms(ctx.session, app.id);
+            if (opts.platform) {
+                platform = findPlatform(platforms, opts.platform);
+            }
+            else if (platforms.length === 1) {
+                platform = platforms[0];
+            }
+            else {
+                ctx.err(`"${app.name}" has more than one platform: ${platforms.map((p) => p.name).join(", ")}. Pass --platform too.`);
+                return 2;
+            }
+        }
+        else if (opts.platform) {
+            const { config } = await ctx.config.load();
+            if (!config.current) {
+                ctx.err(NO_CURRENT_APP);
+                return 2;
+            }
+            app = appFrom(config.current);
+            const platforms = await doListPlatforms(ctx.session, app.id);
+            platform = findPlatform(platforms, opts.platform);
+        }
+        else if (opts.device) {
+            // --device with no app/platform/app-platform-id targets the current selection.
+            const { config } = await ctx.config.load();
+            if (!config.current) {
+                ctx.err(NO_CURRENT_APP);
+                return 2;
+            }
+            app = appFrom(config.current);
+            platform = platformFrom(config.current);
+        }
+        if (!app || !platform) {
+            ctx.err(NO_FLAGS);
+            return 2;
+        }
+        let device = null;
+        if (opts.device) {
+            const resolved = resolveDevice(platform.type, opts.device);
+            device = toSelection(resolved);
+        }
+        const selection = selectionFrom(app, platform, device);
+        const next = await ctx.config.setCurrent(selection, { host: ctx.host.name });
+        if (opts.json) {
+            ctx.out(JSON.stringify(next.current, null, 2));
+        }
+        else {
+            ctx.out(summary(selection));
+            ctx.out(`App Platform ID ${selection.appPlatformId} · ${ctx.host.name}`);
+        }
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof ResolveError) {
+            ctx.err(error.message);
+            return 2;
+        }
+        if (error instanceof VerifyError) {
+            ctx.err(error.message);
+            return error.code === "invalid_id" ? 2 : 1;
+        }
+        if (error instanceof AuthError) {
+            ctx.err(error.message);
+            return 1;
+        }
+        throw error;
+    }
+}

package/dist/config/store.js

@@ -30,7 +30,8 @@ function assertNoCredentials(value, path = "config") {
         }
     }
 }
-const recentKey = (s) => `${s.appPlatformId}::${s.device?.id ?? ""}`;
+/** Identity of a selection in `recent`: the platform plus the device it was used on. */
+export 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")
@@ -111,6 +112,24 @@ export class ConfigStore {
             return next;
         });
     }
+    /** Forget the active selection (e.g. after switching org); `recent` is untouched. */
+    clearCurrent() {
+        return this.enqueue(async () => {
+            const { config } = await this.load();
+            const next = { ...config, current: null };
+            await this.save(next);
+            return next;
+        });
+    }
+    /** Replace the session block (org context) only. */
+    setSession(session) {
+        return this.enqueue(async () => {
+            const { config } = await this.load();
+            const next = { ...config, session };
+            await this.save(next);
+            return next;
+        });
+    }
     setOnboardingStep(step) {
         return this.enqueue(async () => {
             const { config } = await this.load();

package/dist/control-center/lookup.js

@@ -0,0 +1,42 @@
+import { listApps } from "./apps.js";
+import { listPlatforms, platformTypeLabel } from "./platforms.js";
+/**
+ * Find the app and platform behind an App Platform ID.
+ *
+ * There is no "platform by id" endpoint in this client, so this walks the apps
+ * the session can see. Naming is a convenience on top of the public verify
+ * call: any failure (signed out, another org's id, an unreachable list) returns
+ * null so the caller can fall back to `pastedStandIn` rather than refuse a valid id.
+ */
+export async function findAppPlatformById(session, appPlatformId, deps = {}) {
+    const apps = deps.listApps ?? listApps;
+    const platforms = deps.listPlatforms ?? listPlatforms;
+    try {
+        for (const app of await apps(session)) {
+            const platform = (await platforms(session, app.id)).find((p) => p.id === appPlatformId);
+            if (platform)
+                return { app, platform };
+        }
+    }
+    catch {
+        // Naming is optional; the id itself was already verified.
+    }
+    return null;
+}
+/** What an unnamed App Platform ID looks like until the device step narrows it down. */
+export function pastedStandIn(appPlatformId) {
+    return {
+        app: { id: appPlatformId, name: "Pasted ID", archived: false, defaultLanguage: null, logo: null },
+        platform: {
+            id: appPlatformId,
+            appId: null,
+            name: "App Platform",
+            type: "web",
+            typeLabel: platformTypeLabel("web"),
+            sdkEnabled: true,
+            isConfigValid: true,
+            archived: false,
+            marketplaceAppId: null,
+        },
+    };
+}

package/dist/program.js

@@ -79,6 +79,19 @@ export function createProgram(h, options = {}) {
         .action(async (_opts, cmd) => {
         process.exitCode = await h.configure(cmd.optsWithGlobals());
     });
+    program
+        .command("use")
+        .description("Switch the current organization, app, app platform or device (headless).")
+        .option("--org <id-or-name>", "switch organization (re-scopes the access token; clears the current selection)")
+        .option("--app <id-or-name>", "app id, exact name, or unique substring")
+        .option("--platform <id-or-name>", "platform id, exact name, or unique substring")
+        .option("--app-platform-id <uuid>", "select by App Platform ID directly")
+        .option("--device <id-or-name>", "target device preset, previewer id or name")
+        .option(HOST_FLAG, HOST_HELP)
+        .option("--json", "machine-readable result")
+        .action(async (_opts, cmd) => {
+        process.exitCode = await h.use(cmd.optsWithGlobals());
+    });
     program
         .command("devices")
         .description("List the target device presets and the full previewer device list for a platform type.")

package/dist/screens/PickOrg.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { SelectList } from "../components/SelectList.js";
+export function PickOrg({ orgs, currentOrgId, onSelect, onCancel }) {
+    if (orgs.length === 0) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { bold: true, children: "Your account does not belong to any organization yet." }) }));
+    }
+    return (_jsx(SelectList, { title: "Choose an organization", items: orgs.map((o) => ({ key: o.id, label: o.name })), initialKey: currentOrgId ?? undefined, onSelect: (key) => { const org = orgs.find((o) => o.id === key); if (org)
+            onSelect(org); }, onCancel: onCancel }));
+}

package/dist/screens/Shell.js

@@ -5,6 +5,8 @@ import { LoginFlow } from "./LoginFlow.js";
 import { PickApp } from "./PickApp.js";
 import { PickPlatform } from "./PickPlatform.js";
 import { PickDevice } from "./PickDevice.js";
+import { PickOrg } from "./PickOrg.js";
+import { SwitchScreen } from "./SwitchScreen.js";
 import { SuccessScreen } from "./SuccessScreen.js";
 import { deviceById, presetsFor, resolveDevice, toSelection } from "../devices/presets.js";
 import { SelectionHeader } from "./SelectionHeader.js";
@@ -14,12 +16,17 @@ import { AuthError } from "../auth/errors.js";
 import { listApps } from "../control-center/apps.js";
 import { listPlatforms } from "../control-center/platforms.js";
 import { findApp, findPlatform, ResolveError } from "../control-center/resolve.js";
+import { findAppPlatformById, pastedStandIn } from "../control-center/lookup.js";
 import { ConfigureScreen } from "./ConfigureScreen.js";
 import { appFrom, platformFrom, selectionFrom } from "../config/selection.js";
+import { verifyAppPlatform as verifyAppPlatformFn, VerifyError } from "../sdk/verify.js";
+import TextInput from "ink-text-input";
 /**
- * Bare `nami`: sign in if needed → pick app → pick platform → home.
- * Selection is in-memory for now (persistence: NAM-4501; configure: NAM-4500;
- * full Switch with Recent/org switching: NAM-4503).
+ * Bare `nami`: sign in if needed → pick app → platform → device → home.
+ * `s` opens the Switch hub, which reaches every axis `nami use` can switch
+ * headlessly: a recent selection, app, platform, device, organization, or a
+ * pasted App Platform ID. Every path funnels back through `configure`, so the
+ * SDK is re-configured in place and each platform keeps its own storage file.
  */
 export function Shell({ ctx, appQuery, platformQuery, deviceQuery, onExit, exitWhenDone = true, phase, verify, configure }) {
     const { exit } = useApp();
@@ -28,6 +35,7 @@ export function Shell({ ctx, appQuery, platformQuery, deviceQuery, onExit, exitW
     const [orgId, setOrgId] = useState(null);
     const step = (name) => void ctx.config.setOnboardingStep(name).catch(() => { });
     const [queries, setQueries] = useState({ app: appQuery, platform: platformQuery, device: deviceQuery });
+    const [pasted, setPasted] = useState("");
     const finish = (code) => {
         onExit?.(code);
         if (exitWhenDone)
@@ -62,6 +70,85 @@ export function Shell({ ctx, appQuery, platformQuery, deviceQuery, onExit, exitW
         }
         setState({ kind: "pick-device", app, platform, current });
     };
+    /** Open the Switch hub over the current home state; recent/current come from config.json. */
+    const openSwitch = async (home) => {
+        const { config } = await ctx.config.load();
+        setState({ kind: "switch", home, recent: config.recent, current: config.current });
+    };
+    /** A recent entry is a selection we already know — rebuild it and reconfigure, no network call. */
+    const useRecent = (home, selection) => {
+        const sameDevice = (selection.device?.id ?? null) === (home.device?.id ?? null);
+        if (selection.appPlatformId === home.platform.id && sameDevice)
+            return setState(home);
+        const device = selection.device ? deviceById(selection.device.id) ?? null : null;
+        step("configure");
+        setState({ kind: "configure", app: appFrom(selection), platform: platformFrom(selection), device });
+    };
+    const openOrgs = async (home) => {
+        setState({ kind: "busy", label: "Loading your organizations…" });
+        try {
+            const stored = await ctx.store.load();
+            if (!stored)
+                return setState({ kind: "signin" });
+            const profile = await ctx.auth.fetchAccount(stored.accessToken);
+            setState({ kind: "pick-org", home, orgs: profile.orgs });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    };
+    /** Re-scope the token to another org. No re-login; the old selection no longer applies. */
+    const switchOrg = async (org) => {
+        setState({ kind: "busy", label: `Switching to ${org.name}…` });
+        try {
+            const stored = await ctx.store.load();
+            if (!stored)
+                return setState({ kind: "signin" });
+            const accessToken = await ctx.auth.selectOrg(stored.refreshToken, org.id);
+            await ctx.store.save({ ...stored, accessToken, orgId: org.id, orgName: org.name, savedAt: new Date().toISOString() });
+            setOrgName(org.name);
+            setOrgId(org.id);
+            await ctx.config.clearCurrent().catch(() => { });
+            await loadApps();
+        }
+        catch (error) {
+            handleError(error);
+        }
+    };
+    /**
+     * A pasted App Platform ID: verify it on the public config endpoint, then find
+     * its name by scanning the apps this account can see. An id from another org
+     * still works — it just shows as a pasted id until the device step.
+     */
+    const usePastedId = async (home, raw) => {
+        const id = raw.trim();
+        if (!id)
+            return;
+        setState({ kind: "busy", label: "Checking that ID…" });
+        try {
+            await (verify ?? verifyAppPlatformFn)(ctx.host.baseUrl, id);
+        }
+        catch (error) {
+            if (error instanceof VerifyError)
+                return setState({ kind: "paste-id", home, notice: error.message });
+            return handleError(error);
+        }
+        const named = (await findAppPlatformById(ctx.session, id)) ?? pastedStandIn(id);
+        chooseDevice(named.app, named.platform);
+    };
+    const onSwitchChoice = (home, action) => {
+        if (action.kind === "recent")
+            return useRecent(home, action.selection);
+        if (action.kind === "app")
+            return void loadApps(home.app);
+        if (action.kind === "platform")
+            return void loadPlatforms(home.app, home.platform);
+        if (action.kind === "device")
+            return setState({ kind: "pick-device", app: home.app, platform: home.platform, current: home.device ?? undefined });
+        if (action.kind === "org")
+            return void openOrgs(home);
+        setState({ kind: "paste-id", home });
+    };
     const loadApps = async (current) => {
         setState({ kind: "busy", label: "Loading your apps…" });
         try {
@@ -121,13 +208,21 @@ export function Shell({ ctx, appQuery, platformQuery, deviceQuery, onExit, exitW
         if (state.kind === "fatal")
             finish(state.code);
     }, [state.kind]);
+    useInput((_input, key) => {
+        if (state.kind !== "paste-id")
+            return;
+        if (key.escape) {
+            setPasted("");
+            setState(state.home);
+        }
+    }, { isActive: state.kind === "paste-id" });
     useInput((input, key) => {
         if (state.kind !== "home")
             return;
         if (input === "q" || key.escape)
             return finish(0);
         if (input === "s")
-            return void loadApps(state.app);
+            return void openSwitch(state);
         if (input === "p")
             return void loadPlatforms(state.app, state.platform);
         if (input === "d" && presetsFor(state.platform.type).length > 1)
@@ -135,12 +230,15 @@ export function Shell({ ctx, appQuery, platformQuery, deviceQuery, onExit, exitW
         if (input === "l")
             return setState({ ...state, launchHint: true });
     }, { isActive: state.kind === "home" });
-    const header = (_jsx(SelectionHeader, { orgName: orgName, appName: "app" in state ? state.app.name : undefined, platformName: "platform" in state ? state.platform.name : undefined, platformType: "platform" in state ? state.platform.typeLabel : undefined, deviceName: "device" in state ? state.device?.displayName : undefined, host: ctx.host.name }));
+    // The hub and its sub-screens keep the home state they came from, so the header
+    // keeps showing what is loaded while you choose what to switch to.
+    const shown = "home" in state ? state.home : "app" in state ? state : {};
+    const header = (_jsx(SelectionHeader, { orgName: orgName, appName: shown.app?.name, platformName: shown.platform?.name, platformType: shown.platform?.typeLabel, deviceName: shown.device?.displayName, host: ctx.host.name }));
     return (_jsxs(Box, { flexDirection: "column", children: [header, _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [state.kind === "boot" && _jsx(Thinking, { label: "Starting\u2026", phase: phase }), state.kind === "signin" && (_jsxs(Box, { flexDirection: "column", children: [state.notice && _jsx(Text, { color: palette.aqua, children: state.notice }), _jsx(LoginFlow, { auth: ctx.auth, store: ctx.store, host: ctx.host, exitWhenDone: false, phase: phase, onDone: (session) => { setOrgName(session.orgName); setOrgId(session.orgId); void loadApps(); }, onFail: (e) => fatal(e.message) })] })), state.kind === "busy" && _jsx(Thinking, { label: state.label, phase: phase }), state.kind === "pick-app" && (_jsx(PickApp, { apps: state.apps, orgName: orgName, baseUrl: ctx.host.baseUrl, currentAppId: state.current?.id, onSelect: (app) => void loadPlatforms(app), onCancel: () => finish(0) })), state.kind === "pick-platform" && (_jsx(PickPlatform, { appName: state.app.name, platforms: state.platforms, currentPlatformId: state.current?.id, onSelect: (platform) => chooseDevice(state.app, platform), onCancel: () => void loadApps(state.app) })), state.kind === "pick-device" && (_jsx(PickDevice, { platformType: state.platform.type, platformName: state.platform.name, currentDeviceId: state.current?.id, onSelect: (device) => { step("configure"); setState({ kind: "configure", app: state.app, platform: state.platform, device }); }, onCancel: () => void loadPlatforms(state.app, state.platform) })), state.kind === "configure" && (_jsx(ConfigureScreen, { host: ctx.host, appPlatformId: state.platform.id, device: state.device ? { platformType: state.platform.type, id: state.device.id } : undefined, phase: phase, verify: verify, configure: configure, onDone: (result) => {
                             void ctx.config
                                 .setCurrent(selectionFrom(state.app, state.platform, state.device ? toSelection(state.device) : null), { host: ctx.host.name, session: { orgId, orgName } })
                                 .then(() => ctx.config.markOnboardingDone())
                                 .catch(() => { });
                             setState({ kind: "home", app: state.app, platform: state.platform, device: state.device, result });
-                        }, onBack: () => chooseDevice(state.app, state.platform, state.device ?? undefined) })), state.kind === "home" && (_jsx(SuccessScreen, { app: state.app, platform: state.platform, device: state.device, result: state.result, host: ctx.host, canSwitchDevice: presetsFor(state.platform.type).length > 1, launchHint: state.launchHint })), state.kind === "fatal" && _jsx(Text, { color: palette.coral, children: state.message })] })] }));
+                        }, onBack: () => chooseDevice(state.app, state.platform, state.device ?? undefined) })), state.kind === "home" && (_jsx(SuccessScreen, { app: state.app, platform: state.platform, device: state.device, result: state.result, host: ctx.host, canSwitchDevice: presetsFor(state.platform.type).length > 1, launchHint: state.launchHint })), state.kind === "switch" && (_jsx(SwitchScreen, { recent: state.recent, current: state.current, orgName: orgName, canSwitchDevice: presetsFor(state.home.platform.type).length > 1, canSwitchOrg: true, onChoose: (action) => onSwitchChoice(state.home, action), onCancel: () => setState(state.home) })), state.kind === "pick-org" && (_jsx(PickOrg, { orgs: state.orgs, currentOrgId: orgId, onSelect: (org) => void switchOrg(org), onCancel: () => setState(state.home) })), state.kind === "paste-id" && (_jsxs(Box, { flexDirection: "column", children: [state.notice && _jsx(Text, { color: palette.coral, children: state.notice }), _jsxs(Box, { children: [_jsx(Text, { children: "App Platform ID: " }), _jsx(TextInput, { value: pasted, onChange: setPasted, onSubmit: (v) => { setPasted(""); void usePastedId(state.home, v); } })] }), _jsx(Text, { dimColor: true, children: "nami platforms --app <app> lists them. Esc to go back." })] })), state.kind === "fatal" && _jsx(Text, { color: palette.coral, children: state.message })] })] }));
 }

package/dist/screens/SwitchScreen.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { SelectList } from "../components/SelectList.js";
+import { recentKey as selectionKey } from "../config/store.js";
+/** `recent:` + `ConfigStore`'s own de-dup key, so the two can never drift apart. */
+const recentKey = (s) => `recent:${selectionKey(s)}`;
+const isCurrent = (s, current) => current !== null && s.appPlatformId === current.appPlatformId && (s.device?.id ?? null) === (current.device?.id ?? null);
+export function switchItems({ recent, current, canSwitchDevice, canSwitchOrg, }) {
+    const recentItems = recent.map((s) => {
+        const hintParts = [s.device?.displayName, isCurrent(s, current) ? "current" : undefined].filter((v) => Boolean(v));
+        return {
+            key: recentKey(s),
+            label: `${s.appName} · ${s.platformName}`,
+            badge: s.platformType,
+            hint: hintParts.length > 0 ? hintParts.join(" · ") : undefined,
+        };
+    });
+    const actionItems = [
+        { key: "action:app", label: "Switch app" },
+        { key: "action:platform", label: "Switch platform" },
+        ...(canSwitchDevice ? [{ key: "action:device", label: "Change device" }] : []),
+        ...(canSwitchOrg ? [{ key: "action:org", label: "Change organization" }] : []),
+        { key: "action:paste", label: "Paste an App Platform ID" },
+    ];
+    return [...recentItems, ...actionItems];
+}
+/** The Switch hub: recent selections plus app/platform/device/org/paste actions. Pure — never fetches. */
+export function SwitchScreen({ recent, current, orgName, canSwitchDevice, canSwitchOrg, onChoose, onCancel }) {
+    const items = switchItems({ recent, current, canSwitchDevice, canSwitchOrg });
+    const handleSelect = (key) => {
+        if (key === "action:app")
+            return onChoose({ kind: "app" });
+        if (key === "action:platform")
+            return onChoose({ kind: "platform" });
+        if (key === "action:device")
+            return onChoose({ kind: "device" });
+        if (key === "action:org")
+            return onChoose({ kind: "org" });
+        if (key === "action:paste")
+            return onChoose({ kind: "paste" });
+        const selection = recent.find((s) => recentKey(s) === key);
+        if (selection)
+            onChoose({ kind: "recent", selection });
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [orgName && _jsx(Text, { dimColor: true, children: orgName }), _jsx(SelectList, { title: "Switch", items: items, initialKey: "action:app", onSelect: handleSelect, onCancel: onCancel, footer: "Esc to go back" })] }));
+}

package/dist/version.js

@@ -1,2 +1,2 @@
 /** CLI package version. Stamped by scripts/version.sh from the repo VERSION file — do not hand-edit. */
-export const NAMI_CLI_VERSION = "3.4.11-dev.202609222238";
+export const NAMI_CLI_VERSION = "3.4.11-dev.202609230009";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@namiml/cli",
-  "version": "3.4.11-dev.202609222238",
+  "version": "3.4.11-dev.202609230009",
   "description": "Nami SDK developer CLI — terminal test app, implementation and flow checks",
   "keywords": [
     "nami",
@@ -35,7 +35,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@namiml/sdk-core": "3.4.11-dev.202609222238",
+    "@namiml/sdk-core": "3.4.11-dev.202609230009",
     "commander": "^15",
     "env-paths": "^4",
     "ink": "^6.0.0",