@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.2

package/navigation/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Navigation — tabs + onboarding.
+ */
+import type { LucideIcon } from "lucide-react";
+/** Apps are enabled by default; opt-out via VITE_ENABLE_APPS=false. */
+export declare const APPS_ENABLED: boolean;
+/** Stream routes stay addressable; the nav hides the tab unless streaming is enabled. */
+export declare const STREAM_ENABLED = true;
+/** Companion tab — enabled by default; opt-out via VITE_ENABLE_COMPANION_MODE=false. */
+export declare const COMPANION_ENABLED: boolean;
+/** Built-in tab identifiers. */
+export type BuiltinTab = "chat" | "phone" | "messages" | "contacts" | "lifeops" | "tasks" | "automations" | "browser" | "companion" | "stream" | "apps" | "character" | "character-select" | "inventory" | "documents" | "connectors" | "triggers" | "plugins" | "skills" | "advanced" | "fine-tuning" | "trajectories" | "relationships" | "memories" | "rolodex" | "voice" | "runtime" | "database" | "desktop" | "settings" | "logs";
+/**
+ * Tab identifier — includes all built-in tabs plus arbitrary strings
+ * for dynamic plugin-provided nav-page widgets.
+ */
+export type Tab = BuiltinTab | (string & {});
+export declare const APPS_TOOL_TABS: readonly ["lifeops", "plugins", "skills", "fine-tuning", "trajectories", "relationships", "memories", "runtime", "database", "logs", "advanced"];
+export declare function isAppsToolTab(tab: Tab): boolean;
+export interface TabGroup {
+    label: string;
+    tabs: Tab[];
+    icon: LucideIcon;
+    description?: string;
+}
+export interface AndroidPhoneSurfaceDetection {
+    platform?: string;
+    isNative?: boolean;
+    search?: string;
+    hash?: string;
+}
+export declare function isAndroidPhoneSurfaceEnabled(detection?: AndroidPhoneSurfaceDetection): boolean;
+interface WindowNavigationLocation {
+    protocol: string;
+    search: string;
+    hash: string;
+    pathname: string;
+}
+export declare function isAppWindowRoute(location?: Pick<WindowNavigationLocation, "search"> | undefined): boolean;
+export declare function shouldUseHashNavigation(location?: Pick<WindowNavigationLocation, "protocol" | "search"> | undefined): boolean;
+export declare function getWindowNavigationPath(location?: WindowNavigationLocation | undefined): string;
+export declare const ALL_TAB_GROUPS: TabGroup[];
+/** A plugin-provided nav-page widget that should appear in the navigation. */
+export interface DynamicNavTab {
+    /** Tab ID — used as the route path segment. */
+    tabId: string;
+    /** Human-readable label for the nav button. */
+    label: string;
+    /** Which existing TabGroup to join, or a new group label to create. */
+    navGroup?: string;
+    /** Icon for new groups (lucide component). Falls back to Gamepad2. */
+    icon?: LucideIcon;
+    /** Description for new groups. */
+    description?: string;
+}
+/** Compute visible tab groups. Pass feature flags explicitly for React reactivity. */
+export declare function getTabGroups(streamEnabled?: boolean, walletEnabled?: boolean, browserEnabled?: boolean, dynamicTabs?: DynamicNavTab[], phoneSurfaceEnabled?: boolean, automationsEnabled?: boolean): TabGroup[];
+export declare function pathForTab(tab: Tab, basePath?: string): string;
+export declare function canonicalPathForPath(_pathname: string, _basePath?: string): string | null;
+export declare function isRouteRootPath(pathname: string, basePath?: string): boolean;
+export declare function resolveInitialTabForPath(pathname: string, fallbackTab: Tab, basePath?: string): Tab;
+export declare function tabFromPath(pathname: string, basePath?: string): Tab | null;
+/**
+ * Extract an app slug from a `/apps/<slug>` path.
+ * Returns `null` when the path doesn't contain a slug segment.
+ */
+export declare function getAppSlugFromPath(pathname: string, basePath?: string): string | null;
+export declare function titleForTab(tab: Tab): string;
+export { getMainTabApp, MAIN_TAB_FALLBACK, type MainTabApp, resolveDefaultLandingTab, } from "./main-tab";
+//# sourceMappingURL=index.d.ts.map

package/navigation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/navigation/index.ts"],"names":[],"mappings":"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"}

package/navigation/index.js

@@ -0,0 +1,409 @@
+/**
+ * Navigation — tabs + onboarding.
+ */
+/// <reference types="vite/client" />
+import { Capacitor } from "@capacitor/core";
+import { Clock3, Gamepad2, MessageSquare, Monitor, Phone, Radio, Settings, UserRound, Wallet, } from "lucide-react";
+import { resolveDefaultLandingTab } from "./main-tab.js";
+/** Apps are enabled by default; opt-out via VITE_ENABLE_APPS=false. */
+export const APPS_ENABLED = String(import.meta.env.VITE_ENABLE_APPS ?? "true").toLowerCase() !== "false";
+/** Stream routes stay addressable; the nav hides the tab unless streaming is enabled. */
+export const STREAM_ENABLED = true;
+/** Companion tab — enabled by default; opt-out via VITE_ENABLE_COMPANION_MODE=false. */
+export const COMPANION_ENABLED = String(import.meta.env.VITE_ENABLE_COMPANION_MODE ?? "true").toLowerCase() !==
+    "false";
+export const APPS_TOOL_TABS = [
+    "lifeops",
+    "plugins",
+    "skills",
+    "fine-tuning",
+    "trajectories",
+    "relationships",
+    "memories",
+    "runtime",
+    "database",
+    "logs",
+    // Legacy hidden alias for old /advanced routes.
+    "advanced",
+];
+const APPS_TOOL_TAB_SET = new Set(APPS_TOOL_TABS);
+export function isAppsToolTab(tab) {
+    return APPS_TOOL_TAB_SET.has(tab);
+}
+function hasAndroidTestFlag(search, hash) {
+    const searchParams = new URLSearchParams(search);
+    if (searchParams.get("android") === "true")
+        return true;
+    const hashQuery = hash.includes("?") ? hash.slice(hash.indexOf("?")) : "";
+    if (!hashQuery)
+        return false;
+    return new URLSearchParams(hashQuery).get("android") === "true";
+}
+export function isAndroidPhoneSurfaceEnabled(detection = {}) {
+    const search = detection.search ??
+        (typeof window === "undefined" ? "" : window.location.search);
+    const hash = detection.hash ??
+        (typeof window === "undefined" ? "" : window.location.hash);
+    if (hasAndroidTestFlag(search, hash))
+        return true;
+    const platform = detection.platform ?? Capacitor.getPlatform();
+    const isNative = detection.isNative ?? Capacitor.isNativePlatform();
+    return isNative && platform === "android";
+}
+function getWindowNavigationLocation() {
+    return typeof window === "undefined" ? undefined : window.location;
+}
+export function isAppWindowRoute(location = getWindowNavigationLocation()) {
+    if (!location)
+        return false;
+    try {
+        return new URLSearchParams(location.search).get("appWindow") === "1";
+    }
+    catch {
+        return false;
+    }
+}
+export function shouldUseHashNavigation(location = getWindowNavigationLocation()) {
+    if (!location)
+        return false;
+    return location.protocol === "file:" || isAppWindowRoute(location);
+}
+export function getWindowNavigationPath(location = getWindowNavigationLocation()) {
+    if (!location)
+        return "/";
+    return shouldUseHashNavigation(location)
+        ? location.hash.replace(/^#/, "") || "/"
+        : location.pathname;
+}
+export const ALL_TAB_GROUPS = [
+    {
+        label: "Chat",
+        tabs: ["chat", "connectors"],
+        icon: MessageSquare,
+        description: "Conversations with your agent, inbound messages from every connector, and connector management",
+    },
+    {
+        label: "Phone",
+        tabs: ["phone", "messages", "contacts"],
+        icon: Phone,
+        description: "ElizaOS dialer, SMS, and contact book",
+    },
+    {
+        label: "Apps",
+        tabs: ["apps", ...APPS_TOOL_TABS],
+        icon: Gamepad2,
+        description: "Games, LifeOps, integrations, and app tools",
+    },
+    {
+        label: "Character",
+        tabs: ["character", "character-select", "documents"],
+        icon: UserRound,
+        description: "Avatar identity, style, examples, and knowledge",
+    },
+    {
+        label: "Wallet",
+        tabs: ["inventory"],
+        icon: Wallet,
+        description: "Crypto wallets and token balances",
+    },
+    {
+        label: "Browser",
+        tabs: ["browser"],
+        icon: Monitor,
+        description: "Agent-controlled browser workspace",
+    },
+    {
+        label: "Stream",
+        tabs: ["stream"],
+        icon: Radio,
+        description: "Live streaming controls",
+    },
+    {
+        label: "Automations",
+        tabs: ["automations", "triggers", "tasks"],
+        icon: Clock3,
+        description: "Tasks, scheduled tasks, and recurring workflows",
+    },
+    {
+        label: "Settings",
+        tabs: ["settings"],
+        icon: Settings,
+        description: "Configuration and preferences",
+    },
+];
+/** Compute visible tab groups. Pass feature flags explicitly for React reactivity. */
+export function getTabGroups(streamEnabled = STREAM_ENABLED, walletEnabled = true, browserEnabled = true, dynamicTabs, phoneSurfaceEnabled = isAndroidPhoneSurfaceEnabled(), automationsEnabled = true) {
+    const groups = ALL_TAB_GROUPS.filter((g) => (APPS_ENABLED || g.label !== "Apps") &&
+        (phoneSurfaceEnabled || g.label !== "Phone") &&
+        (streamEnabled || g.label !== "Stream") &&
+        (walletEnabled || g.label !== "Wallet") &&
+        (browserEnabled || g.label !== "Browser") &&
+        (automationsEnabled || g.label !== "Automations"));
+    // Merge dynamic plugin-provided nav-page tabs into groups.
+    if (dynamicTabs?.length) {
+        for (const dt of dynamicTabs) {
+            const targetGroup = dt.navGroup
+                ? groups.find((g) => g.label === dt.navGroup)
+                : null;
+            if (targetGroup) {
+                if (!targetGroup.tabs.includes(dt.tabId)) {
+                    targetGroup.tabs.push(dt.tabId);
+                }
+            }
+            else {
+                // Create a new group for this tab.
+                groups.push({
+                    label: dt.label,
+                    tabs: [dt.tabId],
+                    icon: dt.icon ?? Gamepad2,
+                    description: dt.description,
+                });
+            }
+        }
+    }
+    return groups;
+}
+const TAB_PATHS = {
+    chat: "/chat",
+    phone: "/phone",
+    messages: "/messages",
+    contacts: "/contacts",
+    lifeops: "/apps/lifeops",
+    tasks: "/apps/tasks",
+    browser: "/browser",
+    companion: "/companion",
+    stream: "/stream",
+    apps: "/apps",
+    character: "/character",
+    "character-select": "/character/select",
+    automations: "/automations",
+    triggers: "/automations",
+    inventory: "/wallet",
+    documents: "/character/documents",
+    connectors: "/connectors",
+    plugins: "/apps/plugins",
+    skills: "/apps/skills",
+    advanced: "/apps/fine-tuning",
+    "fine-tuning": "/apps/fine-tuning",
+    trajectories: "/apps/trajectories",
+    relationships: "/apps/relationships",
+    memories: "/apps/memories",
+    rolodex: "/rolodex",
+    voice: "/settings/voice",
+    runtime: "/apps/runtime",
+    database: "/apps/database",
+    desktop: "/desktop",
+    settings: "/settings",
+    logs: "/apps/logs",
+};
+const PATH_TO_TAB = new Map(Object.entries(TAB_PATHS).map(([tab, p]) => [p, tab]));
+function normalizePathForLookup(pathname, basePath = "") {
+    const base = normalizeBasePath(basePath);
+    let p = pathname || "/";
+    const queryIndex = p.indexOf("?");
+    if (queryIndex >= 0)
+        p = p.slice(0, queryIndex);
+    const hashIndex = p.indexOf("#");
+    if (hashIndex >= 0)
+        p = p.slice(0, hashIndex);
+    if (base) {
+        if (p === base)
+            p = "/";
+        else if (p.startsWith(`${base}/`))
+            p = p.slice(base.length);
+    }
+    let normalized = normalizePath(p).toLowerCase();
+    if (normalized.endsWith("/index.html"))
+        normalized = "/";
+    return normalized;
+}
+export function pathForTab(tab, basePath = "") {
+    const base = normalizeBasePath(basePath);
+    const p = TAB_PATHS[tab] ?? `/${tab}`;
+    return base ? `${base}${p}` : p;
+}
+export function canonicalPathForPath(_pathname, _basePath = "") {
+    return null;
+}
+export function isRouteRootPath(pathname, basePath = "") {
+    return normalizePathForLookup(pathname, basePath) === "/";
+}
+export function resolveInitialTabForPath(pathname, fallbackTab, basePath = "") {
+    if (isRouteRootPath(pathname, basePath)) {
+        return fallbackTab;
+    }
+    return tabFromPath(pathname, basePath) ?? fallbackTab;
+}
+/** Known apps-tool sub-paths under /apps/ (not actual app slugs). */
+const APPS_SUB_TABS = {
+    lifeops: "lifeops",
+    tasks: "automations",
+    plugins: "plugins",
+    skills: "skills",
+    "fine-tuning": "fine-tuning",
+    trajectories: "trajectories",
+    relationships: "relationships",
+    memories: "memories",
+    runtime: "runtime",
+    database: "database",
+    logs: "logs",
+    // Internal-tool window targets that hit non-`/apps/` shell tabs. The window
+    // path is `/apps/<slug>` so the route stays consistent with other internal
+    // tools, but the renderer mounts the tab the original `targetTab` pointed
+    // at (e.g. wallet for steward, chat for elizamaker).
+    inventory: "inventory",
+    elizamaker: "chat",
+    // Note: "companion" is intentionally NOT here — /apps/companion is an app slug
+    // that AppsView auto-launches as an overlay, not a tool tab.
+};
+export function tabFromPath(pathname, basePath = "") {
+    const normalized = normalizePathForLookup(pathname, basePath);
+    // The root path "/" lands on the discovered main-tab app. Reads the
+    // cached apps catalog synchronously and falls back to the legacy
+    // chat tab when no app declares elizaos.app.mainTab=true.
+    if (normalized === "/")
+        return resolveDefaultLandingTab();
+    if (normalized === "/node-catalog" ||
+        normalized === "/automations/node-catalog") {
+        return "automations";
+    }
+    // Companion disabled unless explicitly feature-flagged
+    if (!COMPANION_ENABLED &&
+        (normalized === "/companion" ||
+            normalized === "/apps/companion" ||
+            normalized === "/character-select" ||
+            normalized === "/character/select")) {
+        return "chat";
+    }
+    // Apps disabled in production builds — redirect to chat
+    if (!APPS_ENABLED &&
+        (normalized === "/apps" ||
+            normalized.startsWith("/apps/") ||
+            normalized === "/game")) {
+        return "chat";
+    }
+    // /apps/<sub> — known tool tabs resolve to their tab; everything else is an app slug
+    if (normalized.startsWith("/apps/")) {
+        const sub = normalized.slice("/apps/".length);
+        return APPS_SUB_TABS[sub] ?? "apps";
+    }
+    // /character/<sub> — resolve nested character paths
+    if (normalized.startsWith("/character/")) {
+        const sub = normalized.slice("/character/".length);
+        if (sub === "documents")
+            return "documents";
+        if (sub === "select")
+            return "character-select";
+        return "character";
+    }
+    // /settings/<sub> — resolve nested settings paths
+    if (normalized.startsWith("/settings/")) {
+        const sub = normalized.slice("/settings/".length);
+        if (sub === "connectors")
+            return "connectors";
+        if (sub === "voice")
+            return "settings";
+        return "settings";
+    }
+    // Check current paths first, then legacy redirects
+    return PATH_TO_TAB.get(normalized) ?? null;
+}
+function normalizeBasePath(basePath) {
+    if (!basePath)
+        return "";
+    let base = basePath.trim();
+    if (!base.startsWith("/"))
+        base = `/${base}`;
+    if (base === "/")
+        return "";
+    if (base.endsWith("/"))
+        base = base.slice(0, -1);
+    return base;
+}
+function normalizePath(p) {
+    if (!p)
+        return "/";
+    let normalized = p.trim();
+    if (!normalized.startsWith("/"))
+        normalized = `/${normalized}`;
+    if (normalized.length > 1 && normalized.endsWith("/"))
+        normalized = normalized.slice(0, -1);
+    return normalized;
+}
+/**
+ * Extract an app slug from a `/apps/<slug>` path.
+ * Returns `null` when the path doesn't contain a slug segment.
+ */
+export function getAppSlugFromPath(pathname, basePath = "") {
+    const normalized = normalizePathForLookup(pathname, basePath);
+    if (!normalized.startsWith("/apps/"))
+        return null;
+    const slug = normalized.slice("/apps/".length);
+    return slug || null;
+}
+export function titleForTab(tab) {
+    switch (tab) {
+        case "chat":
+            return "Chat";
+        case "phone":
+            return "Phone";
+        case "messages":
+            return "Messages";
+        case "contacts":
+            return "Contacts";
+        case "lifeops":
+            return "LifeOps";
+        case "browser":
+            return "Browser";
+        case "companion":
+            return "Companion";
+        case "apps":
+            return "Apps";
+        case "character":
+            return "Character";
+        case "character-select":
+            return "Character Select";
+        case "automations":
+            return "Automations";
+        case "triggers":
+            return "Automations";
+        case "inventory":
+            return "Wallet";
+        case "documents":
+            return "Knowledge";
+        case "connectors":
+            return "Connectors";
+        case "plugins":
+            return "Plugins";
+        case "skills":
+            return "Skills";
+        case "advanced":
+            return "Fine-Tuning";
+        case "fine-tuning":
+            return "Fine-Tuning";
+        case "trajectories":
+            return "Trajectories";
+        case "relationships":
+            return "Relationships";
+        case "memories":
+            return "Memories";
+        case "rolodex":
+            return "Rolodex";
+        case "voice":
+            return "Voice";
+        case "runtime":
+            return "Runtime";
+        case "database":
+            return "Databases";
+        case "settings":
+            return "Settings";
+        case "logs":
+            return "Logs";
+        case "stream":
+            return "Stream";
+        default:
+            // Dynamic plugin tabs — capitalize the tab ID as a fallback title.
+            return tab.charAt(0).toUpperCase() + tab.slice(1).replace(/-/g, " ");
+    }
+}
+export { getMainTabApp, MAIN_TAB_FALLBACK, resolveDefaultLandingTab, } from "./main-tab.js";

package/navigation/main-tab.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Main-tab discovery.
+ *
+ * Apps declare themselves as the shell's default landing tab by setting
+ * `package.json#elizaos.app.mainTab` to `true`. At boot, the shell scans
+ * the loaded apps catalog and picks the unique declarer; if none claim
+ * the seam, the shell falls back to a built-in placeholder. Multiple
+ * declarers are resolved deterministically by alphabetic package name
+ * with a warning, so a misconfigured second app never crashes the shell.
+ *
+ * Phase 1 of the agent + app-core extraction.
+ */
+import type { RegistryAppInfo } from "@elizaos/shared";
+/** Result of main-tab discovery. */
+export interface MainTabApp {
+    /** The shell tab id — derived from the app's route slug. */
+    tabId: string;
+    /** The app's npm package name. */
+    appName: string;
+}
+/**
+ * Fallback tab when no installed app declares `elizaos.app.mainTab=true`.
+ *
+ * Phase 1 of the extraction: while chat is still hardcoded into App.tsx
+ * (`case "chat": return <ChatView />`) the fallback stays "chat" so the
+ * shell renders identically to before for users with no main-tab app.
+ * Phase 5 drops the chat case once `app-chat` claims the seam, at which
+ * point this fallback becomes the HomePlaceholderView surface ("home").
+ */
+export declare const MAIN_TAB_FALLBACK: "chat";
+/**
+ * Discover which app should render as the shell's main tab.
+ *
+ * Returns `null` when no installed app claims the seam — callers should
+ * fall back to a built-in placeholder.
+ *
+ * If multiple apps declare `mainTab: true`, returns the first one ordered
+ * alphabetically by package name and emits a warning. Crashing the shell
+ * because of a metadata collision would make the system unusable, so we
+ * pick deterministically and let the user resolve it via Settings later.
+ */
+export declare function getMainTabApp(apps: RegistryAppInfo[]): MainTabApp | null;
+/**
+ * Resolve the shell's default landing tab.
+ *
+ * Reads the cached apps catalog (`readAppsCache()`) synchronously and
+ * runs `getMainTabApp()` against it. Used at boot before the apps API
+ * call has resolved, so the shell can pick a landing tab without
+ * waiting on the network. Falls back to `MAIN_TAB_FALLBACK` ("chat")
+ * when:
+ *   - the cache is empty (first run), or
+ *   - no app declares `mainTab: true`.
+ *
+ * Optional `apps` argument lets callers supply an already-loaded
+ * catalog (post-hydrate) without going through the cache.
+ */
+export declare function resolveDefaultLandingTab(apps?: RegistryAppInfo[]): string;
+//# sourceMappingURL=main-tab.d.ts.map

package/navigation/main-tab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-tab.d.ts","sourceRoot":"","sources":["../../../../../src/navigation/main-tab.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAIvD,oCAAoC;AACpC,MAAM,WAAW,UAAU;IACzB,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,EAAG,MAAe,CAAC;AAOjD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,UAAU,GAAG,IAAI,CAoBxE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,MAAM,CAIzE"}

package/navigation/main-tab.js

@@ -0,0 +1,76 @@
+/**
+ * Main-tab discovery.
+ *
+ * Apps declare themselves as the shell's default landing tab by setting
+ * `package.json#elizaos.app.mainTab` to `true`. At boot, the shell scans
+ * the loaded apps catalog and picks the unique declarer; if none claim
+ * the seam, the shell falls back to a built-in placeholder. Multiple
+ * declarers are resolved deterministically by alphabetic package name
+ * with a warning, so a misconfigured second app never crashes the shell.
+ *
+ * Phase 1 of the agent + app-core extraction.
+ */
+import { packageNameToAppRouteSlug } from "@elizaos/shared";
+import { readAppsCache } from "../components/apps/apps-cache.js";
+/**
+ * Fallback tab when no installed app declares `elizaos.app.mainTab=true`.
+ *
+ * Phase 1 of the extraction: while chat is still hardcoded into App.tsx
+ * (`case "chat": return <ChatView />`) the fallback stays "chat" so the
+ * shell renders identically to before for users with no main-tab app.
+ * Phase 5 drops the chat case once `app-chat` claims the seam, at which
+ * point this fallback becomes the HomePlaceholderView surface ("home").
+ */
+export const MAIN_TAB_FALLBACK = "chat";
+/** Read the `mainTab` flag, ignoring non-boolean values defensively. */
+function declaresMainTab(app) {
+    return app.mainTab === true;
+}
+/**
+ * Discover which app should render as the shell's main tab.
+ *
+ * Returns `null` when no installed app claims the seam — callers should
+ * fall back to a built-in placeholder.
+ *
+ * If multiple apps declare `mainTab: true`, returns the first one ordered
+ * alphabetically by package name and emits a warning. Crashing the shell
+ * because of a metadata collision would make the system unusable, so we
+ * pick deterministically and let the user resolve it via Settings later.
+ */
+export function getMainTabApp(apps) {
+    const declarers = apps.filter(declaresMainTab);
+    if (declarers.length === 0)
+        return null;
+    declarers.sort((a, b) => a.name.localeCompare(b.name));
+    if (declarers.length > 1) {
+        const names = declarers.map((a) => a.name).join(", ");
+        console.warn(`[main-tab] multiple apps declare elizaos.app.mainTab=true (${names}); ` +
+            `falling back to "${declarers[0].name}". ` +
+            `Set mainTab on exactly one installed app.`);
+    }
+    const winner = declarers[0];
+    const tabId = packageNameToAppRouteSlug(winner.name);
+    if (!tabId)
+        return null;
+    return { tabId, appName: winner.name };
+}
+/**
+ * Resolve the shell's default landing tab.
+ *
+ * Reads the cached apps catalog (`readAppsCache()`) synchronously and
+ * runs `getMainTabApp()` against it. Used at boot before the apps API
+ * call has resolved, so the shell can pick a landing tab without
+ * waiting on the network. Falls back to `MAIN_TAB_FALLBACK` ("chat")
+ * when:
+ *   - the cache is empty (first run), or
+ *   - no app declares `mainTab: true`.
+ *
+ * Optional `apps` argument lets callers supply an already-loaded
+ * catalog (post-hydrate) without going through the cache.
+ */
+export function resolveDefaultLandingTab(apps) {
+    const catalog = apps ?? readAppsCache();
+    if (!catalog)
+        return MAIN_TAB_FALLBACK;
+    return getMainTabApp(catalog)?.tabId ?? MAIN_TAB_FALLBACK;
+}

package/onboarding/auto-download-recommended.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Auto-download a recommended local model when the user picks Local mode.
+ *
+ * Background-only — never blocks the UI. The user lands in chat immediately
+ * via `RuntimeGate.finishAsLocal()`; this helper polls the local agent's
+ * `/api/health` until the runtime is up, then enqueues a download for a
+ * model that fits the device's hardware bucket. The user can interact with
+ * the chat (with the composer-locked / "set up provider" placeholder) while
+ * the download runs; once complete, the local-inference panel and the
+ * provider selector see the new model.
+ *
+ * Idempotency: a `localStorage` marker stops us from re-enqueuing on every
+ * boot. The marker is set after a successful enqueue OR after we determine
+ * the user already has at least one `eliza-download` model installed; the
+ * Local Inference panel is the source of truth from then on.
+ *
+ * Failure modes:
+ *   - agent never comes up within the deadline → silent no-op, no marker.
+ *     A future boot can retry.
+ *   - hub fetch fails → silent no-op, no marker. Same retry semantics.
+ *   - download POST fails → silent no-op, no marker.
+ *
+ * The user request was specifically: "we want to start downloading the
+ * recommended models immediately when they start a local agent, but we
+ * dont want to keep them in loading screen". This file is the kickoff;
+ * the loading screen is bypassed by `finishAsLocal()` already running
+ * `completeOnboarding()` before this helper is invoked.
+ */
+export declare function autoDownloadRecommendedLocalModelInBackground(apiBase: string): Promise<void>;
+//# sourceMappingURL=auto-download-recommended.d.ts.map

package/onboarding/auto-download-recommended.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-download-recommended.d.ts","sourceRoot":"","sources":["../../../../../src/onboarding/auto-download-recommended.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAyDH,wBAAsB,6CAA6C,CACjE,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAkCf"}