@elizaos/app-core 2.0.0-alpha.73 → 2.0.0-alpha.75

package/components/inventory/useInventoryData.js

@@ -0,0 +1,332 @@
+/**
+ * Custom hook: derives token rows, sorted rows, NFT items,
+ * chain errors, and chain-specific computed values from app state.
+ *
+ * Chain-aware: uses the chainConfig registry so that filtering,
+ * fallback rows, and derived values work for any supported chain.
+ */
+import { useMemo } from "react";
+import { CHAIN_CONFIGS, PRIMARY_CHAIN_KEYS, resolveChainKey, } from "../chainConfig";
+import { isBscChainName, toNormalizedAddress, } from "./constants";
+/** Returns true if a chain name matches the given focus key using chainConfig. */
+function matchesChainFocus(chainName, focus) {
+    if (focus === "all")
+        return true;
+    const resolved = resolveChainKey(chainName);
+    return resolved === focus;
+}
+function hasContractAddress(row) {
+    return typeof row.contractAddress === "string";
+}
+function hasVisibleBalance(row) {
+    return Boolean(row.isTracked || row.balanceRaw > 0 || row.valueUsd > 0);
+}
+export function useInventoryData({ walletBalances, walletAddresses, walletConfig, walletNfts, inventorySort, inventoryChainFocus, trackedBscTokens, trackedTokens, }) {
+    const chainFocus = inventoryChainFocus ?? "all";
+    const knownEvmAddr = walletAddresses?.evmAddress ?? walletConfig?.evmAddress;
+    const knownSolAddr = walletAddresses?.solanaAddress ?? walletConfig?.solanaAddress;
+    // ── Legacy BSC aliases ─────────────────────────────────────────────
+    const primaryChain = useMemo(() => {
+        if (!walletBalances?.evm?.chains)
+            return null;
+        return (walletBalances.evm.chains.find((c) => isBscChainName(c.chain)) ?? null);
+    }, [walletBalances]);
+    const primaryNativeBalanceNum = useMemo(() => {
+        if (!primaryChain)
+            return 0;
+        return Number.parseFloat(primaryChain.nativeBalance) || 0;
+    }, [primaryChain]);
+    // ── Flatten token rows ────────────────────────────────────────────
+    const tokenRows = useMemo(() => {
+        const rows = [];
+        if (walletBalances?.evm) {
+            const seenChainKeys = new Set();
+            for (const chain of walletBalances.evm.chains) {
+                const chainKey = resolveChainKey(chain.chain);
+                if (chainKey)
+                    seenChainKeys.add(chainKey);
+                // Filter by chain focus when not "all"
+                if (chainFocus !== "all" && !matchesChainFocus(chain.chain, chainFocus))
+                    continue;
+                rows.push({
+                    chain: chain.chain,
+                    symbol: chain.nativeSymbol,
+                    name: `${chain.chain} native`,
+                    contractAddress: null,
+                    logoUrl: null,
+                    balance: chain.nativeBalance,
+                    valueUsd: Number.parseFloat(chain.nativeValueUsd) || 0,
+                    balanceRaw: Number.parseFloat(chain.nativeBalance) || 0,
+                    isNative: true,
+                });
+                if (chain.error)
+                    continue;
+                for (const tk of chain.tokens) {
+                    rows.push({
+                        chain: chain.chain,
+                        symbol: tk.symbol,
+                        name: tk.name,
+                        contractAddress: tk.contractAddress ?? null,
+                        logoUrl: tk.logoUrl ?? null,
+                        balance: tk.balance,
+                        valueUsd: Number.parseFloat(tk.valueUsd) || 0,
+                        balanceRaw: Number.parseFloat(tk.balance) || 0,
+                        isNative: false,
+                        isTracked: false,
+                    });
+                }
+            }
+            // Insert fallback rows for primary chains not seen in API data
+            if (knownEvmAddr) {
+                for (const key of PRIMARY_CHAIN_KEYS) {
+                    if (key === "solana")
+                        continue; // handled below
+                    if (seenChainKeys.has(key))
+                        continue;
+                    if (chainFocus !== "all" && chainFocus !== key)
+                        continue;
+                    const cfg = CHAIN_CONFIGS[key];
+                    rows.unshift({
+                        chain: cfg.name,
+                        symbol: cfg.nativeSymbol,
+                        name: `${cfg.name} native`,
+                        contractAddress: null,
+                        logoUrl: null,
+                        balance: "0",
+                        valueUsd: 0,
+                        balanceRaw: 0,
+                        isNative: true,
+                    });
+                }
+            }
+        }
+        else if (knownEvmAddr) {
+            // No EVM data at all — still expose the supported EVM chains.
+            for (const key of PRIMARY_CHAIN_KEYS) {
+                if (key === "solana")
+                    continue;
+                if (chainFocus !== "all" && chainFocus !== key)
+                    continue;
+                const cfg = CHAIN_CONFIGS[key];
+                rows.push({
+                    chain: cfg.name,
+                    symbol: cfg.nativeSymbol,
+                    name: `${cfg.name} native`,
+                    contractAddress: null,
+                    logoUrl: null,
+                    balance: "0",
+                    valueUsd: 0,
+                    balanceRaw: 0,
+                    isNative: true,
+                });
+            }
+        }
+        // Solana tokens
+        if ((chainFocus === "all" || chainFocus === "solana") &&
+            walletBalances?.solana) {
+            rows.push({
+                chain: "Solana",
+                symbol: "SOL",
+                name: "Solana native",
+                contractAddress: null,
+                logoUrl: null,
+                balance: walletBalances.solana.solBalance,
+                valueUsd: Number.parseFloat(walletBalances.solana.solValueUsd) || 0,
+                balanceRaw: Number.parseFloat(walletBalances.solana.solBalance) || 0,
+                isNative: true,
+            });
+            for (const tk of walletBalances.solana.tokens) {
+                rows.push({
+                    chain: "Solana",
+                    symbol: tk.symbol,
+                    name: tk.name,
+                    contractAddress: tk.mint ?? null,
+                    logoUrl: tk.logoUrl ?? null,
+                    balance: tk.balance,
+                    valueUsd: Number.parseFloat(tk.valueUsd) || 0,
+                    balanceRaw: Number.parseFloat(tk.balance) || 0,
+                    isNative: false,
+                });
+            }
+        }
+        if ((chainFocus === "all" || chainFocus === "solana") &&
+            knownSolAddr &&
+            !walletBalances?.solana) {
+            rows.push({
+                chain: "Solana",
+                symbol: "SOL",
+                name: "Solana native",
+                contractAddress: null,
+                logoUrl: null,
+                balance: "0",
+                valueUsd: 0,
+                balanceRaw: 0,
+                isNative: true,
+            });
+        }
+        // Add tracked tokens not already in the list
+        if (chainFocus === "bsc" || chainFocus === "all") {
+            const knownBscContracts = new Set(rows
+                .filter((row) => isBscChainName(row.chain) && hasContractAddress(row))
+                .map((row) => toNormalizedAddress(row.contractAddress)));
+            for (const tracked of trackedBscTokens) {
+                const normalized = toNormalizedAddress(tracked.contractAddress);
+                if (knownBscContracts.has(normalized))
+                    continue;
+                rows.push({
+                    chain: "BSC",
+                    symbol: tracked.symbol,
+                    name: tracked.name,
+                    contractAddress: tracked.contractAddress,
+                    logoUrl: tracked.logoUrl ?? null,
+                    balance: "0",
+                    valueUsd: 0,
+                    balanceRaw: 0,
+                    isNative: false,
+                    isTracked: true,
+                });
+            }
+            for (const tracked of trackedTokens) {
+                const exists = rows.some((r) => r.contractAddress?.toLowerCase() === tracked.address.toLowerCase());
+                if (!exists) {
+                    rows.push({
+                        chain: "BSC",
+                        symbol: `TKN-${tracked.address.slice(2, 6)}`,
+                        name: tracked.symbol || `Token ${tracked.address.slice(0, 10)}...`,
+                        contractAddress: tracked.address,
+                        logoUrl: null,
+                        balance: "0",
+                        valueUsd: 0,
+                        balanceRaw: 0,
+                        isNative: false,
+                        isTracked: true,
+                    });
+                }
+            }
+        }
+        return rows.filter(hasVisibleBalance);
+    }, [
+        walletBalances,
+        trackedBscTokens,
+        chainFocus,
+        trackedTokens,
+        knownEvmAddr,
+        knownSolAddr,
+    ]);
+    // ── Sort ──────────────────────────────────────────────────────────
+    const sortedRows = useMemo(() => {
+        const sorted = [...tokenRows];
+        if (inventorySort === "value") {
+            sorted.sort((a, b) => b.valueUsd - a.valueUsd || b.balanceRaw - a.balanceRaw);
+        }
+        else if (inventorySort === "chain") {
+            sorted.sort((a, b) => a.chain.localeCompare(b.chain) || a.symbol.localeCompare(b.symbol));
+        }
+        else if (inventorySort === "symbol") {
+            sorted.sort((a, b) => a.symbol.localeCompare(b.symbol) || a.chain.localeCompare(b.chain));
+        }
+        return sorted;
+    }, [tokenRows, inventorySort]);
+    // ── Chain errors ──────────────────────────────────────────────────
+    const chainErrors = useMemo(() => (walletBalances?.evm?.chains ?? []).filter((c) => c.error), [walletBalances]);
+    const bscHasError = useMemo(() => chainErrors.some((c) => isBscChainName(c.chain)), [chainErrors]);
+    const focusChainHasError = useMemo(() => {
+        if (chainFocus === "all")
+            return chainErrors.length > 0;
+        return chainErrors.some((c) => matchesChainFocus(c.chain, chainFocus));
+    }, [chainErrors, chainFocus]);
+    // ── Flatten NFTs ──────────────────────────────────────────────────
+    const allNfts = useMemo(() => {
+        if (!walletNfts)
+            return [];
+        const items = [];
+        for (const chainData of walletNfts.evm) {
+            for (const nft of chainData.nfts) {
+                items.push({
+                    chain: chainData.chain,
+                    name: nft.name,
+                    imageUrl: nft.imageUrl,
+                    collectionName: nft.collectionName || nft.tokenType,
+                });
+            }
+        }
+        if (walletNfts.solana) {
+            for (const nft of walletNfts.solana.nfts) {
+                items.push({
+                    chain: "Solana",
+                    name: nft.name,
+                    imageUrl: nft.imageUrl,
+                    collectionName: nft.collectionName,
+                });
+            }
+        }
+        return items;
+    }, [walletNfts]);
+    // ── Derived values ────────────────────────────────────────────────
+    const focusedChain = useMemo(() => {
+        if (chainFocus === "all")
+            return null;
+        if (chainFocus === "solana") {
+            return {
+                name: CHAIN_CONFIGS.solana.name,
+                nativeSymbol: CHAIN_CONFIGS.solana.nativeSymbol,
+                nativeBalance: walletBalances?.solana?.solBalance ?? (knownSolAddr ? "0" : null),
+                error: null,
+            };
+        }
+        const chainConfig = CHAIN_CONFIGS[chainFocus];
+        const evmChain = walletBalances?.evm?.chains.find((chain) => matchesChainFocus(chain.chain, chainFocus)) ?? null;
+        if (!chainConfig && !evmChain)
+            return null;
+        return {
+            name: evmChain?.chain ?? chainConfig?.name ?? chainFocus,
+            nativeSymbol: evmChain?.nativeSymbol ?? chainConfig?.nativeSymbol ?? null,
+            nativeBalance: evmChain?.nativeBalance ?? (knownEvmAddr ? "0" : null),
+            error: evmChain?.error ?? null,
+        };
+    }, [chainFocus, knownEvmAddr, knownSolAddr, walletBalances]);
+    const primaryChainError = primaryChain?.error ??
+        chainErrors.find((chain) => isBscChainName(chain.chain))?.error ??
+        null;
+    const primaryNativeBalance = primaryChain?.nativeBalance ?? null;
+    const focusedRows = useMemo(() => {
+        if (chainFocus === "all")
+            return sortedRows;
+        return sortedRows.filter((row) => matchesChainFocus(row.chain, chainFocus));
+    }, [sortedRows, chainFocus]);
+    const bscRows = sortedRows.filter((row) => isBscChainName(row.chain));
+    const visibleRows = chainFocus === "all" ? sortedRows : focusedRows;
+    const totalUsd = useMemo(() => (chainFocus === "all" ? tokenRows : focusedRows).reduce((sum, r) => sum + r.valueUsd, 0), [tokenRows, focusedRows, chainFocus]);
+    const visibleChainErrors = useMemo(() => {
+        if (chainFocus === "all")
+            return chainErrors;
+        return chainErrors.filter((chain) => matchesChainFocus(chain.chain, chainFocus));
+    }, [chainErrors, chainFocus]);
+    return {
+        chainFocus,
+        tokenRows,
+        sortedRows,
+        chainErrors,
+        bscHasError,
+        focusChainHasError,
+        allNfts,
+        // Backwards-compat aliases
+        bscChain: primaryChain,
+        primaryChain,
+        bnbBalance: primaryNativeBalanceNum,
+        primaryNativeBalanceNum,
+        bscRows,
+        focusedRows,
+        visibleRows,
+        totalUsd,
+        visibleChainErrors,
+        focusedChainName: focusedChain?.name ?? null,
+        focusedChainError: focusedChain?.error ?? null,
+        focusedNativeBalance: focusedChain?.nativeBalance ?? null,
+        focusedNativeSymbol: focusedChain?.nativeSymbol ?? null,
+        bscChainError: primaryChainError,
+        primaryChainError,
+        bscNativeBalance: primaryNativeBalance,
+        primaryNativeBalance,
+    };
+}

package/components/knowledge-upload-image.d.ts

@@ -0,0 +1,27 @@
+export type KnowledgeImageUploadFile = File & {
+    webkitRelativePath?: string;
+};
+export type KnowledgeImageCompressionPlatform = {
+    isAvailable: () => boolean;
+    loadImageSource: (file: File) => Promise<{
+        source: CanvasImageSource;
+        width: number;
+        height: number;
+    }>;
+    renderBlob: (input: {
+        source: CanvasImageSource;
+        width: number;
+        height: number;
+        outputType: string;
+        quality: number;
+    }) => Promise<Blob>;
+};
+export declare const MAX_KNOWLEDGE_IMAGE_PROCESSING_BYTES: number;
+export declare function isKnowledgeImageFile(file: Pick<File, "name" | "type">): boolean;
+export declare function maybeCompressKnowledgeUploadImage(file: KnowledgeImageUploadFile, platform?: KnowledgeImageCompressionPlatform): Promise<{
+    file: KnowledgeImageUploadFile;
+    optimized: boolean;
+    originalSize: number;
+    optimizedSize: number;
+}>;
+//# sourceMappingURL=knowledge-upload-image.d.ts.map

package/components/knowledge-upload-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-upload-image.d.ts","sourceRoot":"","sources":["../../src/components/knowledge-upload-image.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,wBAAwB,GAAG,IAAI,GAAG;IAC5C,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC;QACvC,MAAM,EAAE,iBAAiB,CAAC;QAC1B,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;IACH,UAAU,EAAE,CAAC,KAAK,EAAE;QAClB,MAAM,EAAE,iBAAiB,CAAC;QAC1B,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;KACjB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,oCAAoC,QAAgB,CAAC;AAwGlE,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,GAChC,OAAO,CAIT;AAED,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,wBAAwB,EAC9B,QAAQ,GAAE,iCAAgE,GACzE,OAAO,CAAC;IACT,IAAI,EAAE,wBAAwB,CAAC;IAC/B,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC,CA0ED"}

package/components/knowledge-upload-image.js

@@ -0,0 +1,146 @@
+export const MAX_KNOWLEDGE_IMAGE_PROCESSING_BYTES = 5 * 1_048_576;
+const TARGET_KNOWLEDGE_IMAGE_BYTES = Math.floor(MAX_KNOWLEDGE_IMAGE_PROCESSING_BYTES * 0.9);
+const IMAGE_OUTPUT_TYPE = "image/jpeg";
+const IMAGE_MAX_DIMENSION = 2560;
+const IMAGE_MIN_DIMENSION = 320;
+const IMAGE_SCALE_STEP = 0.82;
+const IMAGE_QUALITY_STEPS = [0.92, 0.84, 0.76, 0.68, 0.6, 0.52, 0.44];
+const IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".webp", ".gif"];
+function browserCompressionPlatform() {
+    return {
+        isAvailable: () => typeof document !== "undefined" &&
+            typeof URL !== "undefined" &&
+            typeof URL.createObjectURL === "function" &&
+            typeof Image !== "undefined",
+        loadImageSource: async (file) => {
+            const objectUrl = URL.createObjectURL(file);
+            try {
+                const image = await new Promise((resolve, reject) => {
+                    const nextImage = new Image();
+                    nextImage.onload = () => resolve(nextImage);
+                    nextImage.onerror = () => reject(new Error(`Failed to load image "${file.name}"`));
+                    nextImage.src = objectUrl;
+                });
+                return {
+                    source: image,
+                    width: image.naturalWidth || image.width,
+                    height: image.naturalHeight || image.height,
+                };
+            }
+            finally {
+                URL.revokeObjectURL(objectUrl);
+            }
+        },
+        renderBlob: async ({ source, width, height, outputType, quality }) => {
+            const canvas = document.createElement("canvas");
+            canvas.width = width;
+            canvas.height = height;
+            const context = canvas.getContext("2d");
+            if (!context)
+                throw new Error("Canvas 2D context is unavailable");
+            if (outputType === IMAGE_OUTPUT_TYPE) {
+                context.fillStyle = "#ffffff";
+                context.fillRect(0, 0, width, height);
+            }
+            context.drawImage(source, 0, 0, width, height);
+            return await new Promise((resolve, reject) => {
+                canvas.toBlob((blob) => {
+                    if (!blob) {
+                        reject(new Error("Failed to encode optimized image"));
+                        return;
+                    }
+                    resolve(blob);
+                }, outputType, quality);
+            });
+        },
+    };
+}
+function clampDimensions(width, height, maxDimension) {
+    const largestEdge = Math.max(width, height);
+    if (largestEdge <= maxDimension) {
+        return { width, height };
+    }
+    const scale = maxDimension / largestEdge;
+    return {
+        width: Math.max(1, Math.round(width * scale)),
+        height: Math.max(1, Math.round(height * scale)),
+    };
+}
+function cloneUploadFile(file, blob) {
+    const cloned = new File([blob], file.name, {
+        type: blob.type || file.type,
+        lastModified: file.lastModified,
+    });
+    if (typeof file.webkitRelativePath === "string") {
+        Object.defineProperty(cloned, "webkitRelativePath", {
+            value: file.webkitRelativePath,
+            configurable: true,
+        });
+    }
+    return cloned;
+}
+export function isKnowledgeImageFile(file) {
+    if (file.type.startsWith("image/"))
+        return true;
+    const lowerName = file.name.toLowerCase();
+    return IMAGE_EXTENSIONS.some((extension) => lowerName.endsWith(extension));
+}
+export async function maybeCompressKnowledgeUploadImage(file, platform = browserCompressionPlatform()) {
+    if (!isKnowledgeImageFile(file) ||
+        file.size <= MAX_KNOWLEDGE_IMAGE_PROCESSING_BYTES ||
+        !platform.isAvailable()) {
+        return {
+            file,
+            optimized: false,
+            originalSize: file.size,
+            optimizedSize: file.size,
+        };
+    }
+    const image = await platform.loadImageSource(file);
+    let { width, height } = clampDimensions(image.width, image.height, IMAGE_MAX_DIMENSION);
+    let bestBlob = null;
+    while (true) {
+        for (const quality of IMAGE_QUALITY_STEPS) {
+            const blob = await platform.renderBlob({
+                source: image.source,
+                width,
+                height,
+                outputType: IMAGE_OUTPUT_TYPE,
+                quality,
+            });
+            if (!bestBlob || blob.size < bestBlob.size) {
+                bestBlob = blob;
+            }
+            if (blob.size <= TARGET_KNOWLEDGE_IMAGE_BYTES) {
+                return {
+                    file: cloneUploadFile(file, blob),
+                    optimized: true,
+                    originalSize: file.size,
+                    optimizedSize: blob.size,
+                };
+            }
+        }
+        const largestEdge = Math.max(width, height);
+        if (largestEdge <= IMAGE_MIN_DIMENSION)
+            break;
+        const nextScale = Math.max(IMAGE_MIN_DIMENSION / largestEdge, IMAGE_SCALE_STEP);
+        if (nextScale >= 1)
+            break;
+        width = Math.max(1, Math.round(width * nextScale));
+        height = Math.max(1, Math.round(height * nextScale));
+    }
+    if (bestBlob && bestBlob.size < file.size) {
+        return {
+            file: cloneUploadFile(file, bestBlob),
+            optimized: true,
+            originalSize: file.size,
+            optimizedSize: bestBlob.size,
+        };
+    }
+    return {
+        file,
+        optimized: false,
+        originalSize: file.size,
+        optimizedSize: file.size,
+    };
+}

package/components/labels.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared label helpers used across app forms and config surfaces.
+ */
+export declare const ENV_KEY_ACRONYMS: Set<string>;
+export declare function autoLabel(key: string, pluginId: string): string;
+//# sourceMappingURL=labels.d.ts.map

package/components/labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/components/labels.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAiBvC,CAAC;AAEH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAsB/D"}

package/components/labels.js

@@ -0,0 +1,40 @@
+/**
+ * Shared label helpers used across app forms and config surfaces.
+ */
+export const ENV_KEY_ACRONYMS = new Set([
+    "API",
+    "URL",
+    "ID",
+    "SSH",
+    "SSL",
+    "HTTP",
+    "HTTPS",
+    "RPC",
+    "NFT",
+    "EVM",
+    "TLS",
+    "DNS",
+    "IP",
+    "JWT",
+    "SDK",
+    "LLM",
+]);
+export function autoLabel(key, pluginId) {
+    const prefixes = [
+        `${pluginId.toUpperCase().replace(/-/g, "_")}_`,
+        `${pluginId.toUpperCase().replace(/-/g, "")}_`,
+    ];
+    let remainder = key;
+    for (const prefix of prefixes) {
+        if (key.startsWith(prefix) && key.length > prefix.length) {
+            remainder = key.slice(prefix.length);
+            break;
+        }
+    }
+    return remainder
+        .split("_")
+        .map((word) => ENV_KEY_ACRONYMS.has(word)
+        ? word
+        : `${word[0]}${word.slice(1).toLowerCase()}`)
+        .join(" ");
+}

package/components/onboarding/ActivateStep.d.ts

@@ -0,0 +1,2 @@
+export declare function ActivateStep(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ActivateStep.d.ts.map

package/components/onboarding/ActivateStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivateStep.d.ts","sourceRoot":"","sources":["../../../src/components/onboarding/ActivateStep.tsx"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,4CA8B3B"}

package/components/onboarding/ActivateStep.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useApp } from "@elizaos/app-core/state";
+import { useBranding } from "../../config/branding";
+export function ActivateStep() {
+    const branding = useBranding();
+    const { onboardingName, handleOnboardingNext, t } = useApp();
+    return (_jsxs(_Fragment, { children: [_jsx("div", { className: "onboarding-section-title", children: t("onboarding.readyTitle") }), _jsx("div", { className: "onboarding-divider", children: _jsx("div", { className: "onboarding-divider-diamond" }) }), _jsx("div", { className: "onboarding-question", children: t("onboarding.companionReady", {
+                    name: onboardingName || branding.appName,
+                }) }), _jsx("p", { className: "onboarding-desc", children: t("onboarding.allConfigured") }), _jsxs("div", { className: "onboarding-panel-footer", children: [_jsx("span", {}), _jsx("button", { className: "onboarding-confirm-btn", onClick: () => handleOnboardingNext(), type: "button", children: t("onboarding.enter") })] })] }));
+}

package/components/onboarding/ConnectionStep.d.ts

@@ -0,0 +1,2 @@
+export declare function ConnectionStep(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ConnectionStep.d.ts.map

package/components/onboarding/ConnectionStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionStep.d.ts","sourceRoot":"","sources":["../../../src/components/onboarding/ConnectionStep.tsx"],"names":[],"mappings":"AAqBA,wBAAgB,cAAc,4CA4/C7B"}