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

package/platform/desktop-permissions-client.js

@@ -0,0 +1,246 @@
+import { invokeDesktopBridgeRequest } from "../bridge/electrobun-rpc.js";
+const PATCH_STATE = Symbol.for("elizaos.desktopPermissionsPatch");
+const RUNTIME_PERMISSION_IDS = ["website-blocking"];
+const RENDERER_PERMISSION_IDS = [
+    "camera",
+    "microphone",
+    "location",
+    "notifications",
+];
+function isRuntimePermissionId(id) {
+    return RUNTIME_PERMISSION_IDS.includes(id);
+}
+function isRendererPermissionId(id) {
+    return RENDERER_PERMISSION_IDS.includes(id);
+}
+function currentRendererPlatform() {
+    if (typeof navigator !== "undefined") {
+        const platform = navigator.platform.toLowerCase();
+        if (platform.includes("mac"))
+            return "darwin";
+        if (platform.includes("win"))
+            return "win32";
+    }
+    return "linux";
+}
+function buildRendererPermissionState(id, status, lastRequested) {
+    return {
+        id,
+        status,
+        lastChecked: Date.now(),
+        ...(lastRequested ? { lastRequested } : {}),
+        canRequest: status === "not-determined",
+        platform: currentRendererPlatform(),
+    };
+}
+function mapRendererPermissionState(state) {
+    if (state === "granted" || state === "denied")
+        return state;
+    if (state === "prompt" || state === "default")
+        return "not-determined";
+    return null;
+}
+async function queryRendererPermission(id) {
+    if (!isRendererPermissionId(id) || typeof navigator === "undefined") {
+        return null;
+    }
+    if (id === "notifications" && typeof Notification !== "undefined") {
+        const status = mapRendererPermissionState(Notification.permission);
+        return status ? buildRendererPermissionState(id, status) : null;
+    }
+    if (!navigator.permissions?.query) {
+        return null;
+    }
+    const name = id === "location" ? "geolocation" : id;
+    try {
+        const result = await navigator.permissions.query({
+            name: name,
+        });
+        const status = mapRendererPermissionState(result.state);
+        return status ? buildRendererPermissionState(id, status) : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function requestRendererPermission(id) {
+    if (!isRendererPermissionId(id) || typeof navigator === "undefined") {
+        return null;
+    }
+    const lastRequested = Date.now();
+    if (id === "camera" || id === "microphone") {
+        try {
+            const stream = await navigator.mediaDevices?.getUserMedia?.({
+                video: id === "camera",
+                audio: id === "microphone",
+            });
+            for (const track of stream?.getTracks?.() ?? []) {
+                track.stop();
+            }
+        }
+        catch {
+            // The follow-up query reports denied when the browser has a recorded denial.
+        }
+        const checked = await queryRendererPermission(id);
+        return checked ? { ...checked, lastRequested } : null;
+    }
+    if (id === "location" && navigator.geolocation) {
+        const requestedStatus = await new Promise((resolve) => {
+            navigator.geolocation.getCurrentPosition(() => resolve("granted"), (err) => resolve(err.code === err.PERMISSION_DENIED ? "denied" : null), { maximumAge: 0, timeout: 10_000 });
+        });
+        const checked = await queryRendererPermission(id);
+        if (checked)
+            return { ...checked, lastRequested };
+        return requestedStatus
+            ? buildRendererPermissionState(id, requestedStatus, lastRequested)
+            : null;
+    }
+    if (id === "notifications" && typeof Notification !== "undefined") {
+        const status = mapRendererPermissionState(await Notification.requestPermission());
+        return status
+            ? buildRendererPermissionState(id, status, lastRequested)
+            : null;
+    }
+    return queryRendererPermission(id);
+}
+async function reconcileRendererPermissions(permissions) {
+    let changed = false;
+    const nextPermissions = { ...permissions };
+    await Promise.all(RENDERER_PERMISSION_IDS.map(async (id) => {
+        const state = await queryRendererPermission(id);
+        if (!state)
+            return;
+        const current = nextPermissions[id];
+        if (current?.status === state.status &&
+            current?.canRequest === state.canRequest) {
+            return;
+        }
+        nextPermissions[id] = { ...current, ...state };
+        changed = true;
+    }));
+    return changed ? nextPermissions : permissions;
+}
+async function mergeRuntimePermissions(permissions, getPermission) {
+    const nextPermissions = { ...permissions };
+    await Promise.all(RUNTIME_PERMISSION_IDS.map(async (id) => {
+        try {
+            nextPermissions[id] = await getPermission(id);
+        }
+        catch {
+            // Leave the bridged snapshot untouched when the runtime-side permission
+            // route is temporarily unavailable.
+        }
+    }));
+    return nextPermissions;
+}
+export function installDesktopPermissionsClientPatch(client) {
+    const patchableClient = client;
+    const existingPatch = patchableClient[PATCH_STATE];
+    if (existingPatch) {
+        return () => { };
+    }
+    const originalGetPermissions = client.getPermissions.bind(client);
+    const originalGetPermission = client.getPermission.bind(client);
+    const originalRequestPermission = client.requestPermission.bind(client);
+    const originalOpenPermissionSettings = client.openPermissionSettings.bind(client);
+    const originalRefreshPermissions = client.refreshPermissions.bind(client);
+    const originalSetShellEnabled = client.setShellEnabled.bind(client);
+    const originalIsShellEnabled = client.isShellEnabled.bind(client);
+    patchableClient[PATCH_STATE] = {
+        getPermissions: client.getPermissions,
+        getPermission: client.getPermission,
+        requestPermission: client.requestPermission,
+        openPermissionSettings: client.openPermissionSettings,
+        refreshPermissions: client.refreshPermissions,
+        setShellEnabled: client.setShellEnabled,
+        isShellEnabled: client.isShellEnabled,
+    };
+    client.getPermissions = async () => {
+        const bridged = await invokeDesktopBridgeRequest({
+            rpcMethod: "permissionsGetAll",
+            ipcChannel: "permissions:getAll",
+        });
+        if (bridged === null) {
+            return originalGetPermissions();
+        }
+        return reconcileRendererPermissions(await mergeRuntimePermissions(bridged, originalGetPermission));
+    };
+    client.getPermission = async (id) => {
+        if (isRuntimePermissionId(id)) {
+            return originalGetPermission(id);
+        }
+        const bridged = await invokeDesktopBridgeRequest({
+            rpcMethod: "permissionsCheck",
+            ipcChannel: "permissions:check",
+            params: { id },
+        });
+        const rendererState = await queryRendererPermission(id);
+        return rendererState ?? bridged ?? originalGetPermission(id);
+    };
+    client.requestPermission = async (id) => {
+        if (isRuntimePermissionId(id)) {
+            return originalRequestPermission(id);
+        }
+        const bridged = await invokeDesktopBridgeRequest({
+            rpcMethod: "permissionsRequest",
+            ipcChannel: "permissions:request",
+            params: { id },
+        });
+        const rendererState = await requestRendererPermission(id);
+        return rendererState ?? bridged ?? originalRequestPermission(id);
+    };
+    client.openPermissionSettings = async (id) => {
+        if (isRuntimePermissionId(id)) {
+            return originalOpenPermissionSettings(id);
+        }
+        const bridged = await invokeDesktopBridgeRequest({
+            rpcMethod: "permissionsOpenSettings",
+            ipcChannel: "permissions:openSettings",
+            params: { id },
+        });
+        if (bridged !== null) {
+            return;
+        }
+        return originalOpenPermissionSettings(id);
+    };
+    client.refreshPermissions = async () => {
+        const bridged = await invokeDesktopBridgeRequest({
+            rpcMethod: "permissionsGetAll",
+            ipcChannel: "permissions:getAll",
+            params: { forceRefresh: true },
+        });
+        if (bridged === null) {
+            return originalRefreshPermissions();
+        }
+        return reconcileRendererPermissions(await mergeRuntimePermissions(bridged, originalGetPermission));
+    };
+    client.setShellEnabled = async (enabled) => {
+        const bridged = await invokeDesktopBridgeRequest({
+            rpcMethod: "permissionsSetShellEnabled",
+            ipcChannel: "permissions:setShellEnabled",
+            params: { enabled },
+        });
+        return bridged ?? originalSetShellEnabled(enabled);
+    };
+    client.isShellEnabled = async () => {
+        const bridged = await invokeDesktopBridgeRequest({
+            rpcMethod: "permissionsIsShellEnabled",
+            ipcChannel: "permissions:isShellEnabled",
+        });
+        return bridged ?? originalIsShellEnabled();
+    };
+    return () => {
+        const patchState = patchableClient[PATCH_STATE];
+        if (!patchState) {
+            return;
+        }
+        client.getPermissions = patchState.getPermissions;
+        client.getPermission = patchState.getPermission;
+        client.requestPermission = patchState.requestPermission;
+        client.openPermissionSettings = patchState.openPermissionSettings;
+        client.refreshPermissions = patchState.refreshPermissions;
+        client.setShellEnabled = patchState.setShellEnabled;
+        client.isShellEnabled = patchState.isShellEnabled;
+        delete patchableClient[PATCH_STATE];
+    };
+}

package/platform/empty-node-module.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Empty stub for Node built-in subpaths that don't exist in browser polyfills.
+ * Server-only code imports these but they're never executed in the browser.
+ *
+ * Each named export is a no-op so esbuild's dep scanner doesn't choke.
+ */
+export declare const isArrayBuffer: () => boolean;
+export declare const isTypedArray: () => boolean;
+export declare const pipeline: () => void;
+export declare const finished: () => void;
+export declare const ReadableStream: {
+    new (underlyingSource: UnderlyingByteSource, strategy?: {
+        highWaterMark?: number;
+    }): ReadableStream<Uint8Array<ArrayBuffer>>;
+    new <R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+    new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+    prototype: ReadableStream;
+} | {
+    new (): {};
+};
+export declare const WritableStream: {
+    new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
+    prototype: WritableStream;
+} | {
+    new (): {};
+};
+export declare const TransformStream: {
+    new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
+    prototype: TransformStream;
+} | {
+    new (): {};
+};
+export declare const createIntegrationTelemetrySpan: () => {
+    success: () => void;
+    failure: () => void;
+};
+export declare const hasAdminAccess: () => Promise<boolean>;
+export declare const hasOwnerAccess: () => Promise<boolean>;
+export declare const hasPrivateAccess: () => Promise<boolean>;
+export declare const extractActionParamsViaLlm: () => Promise<{}>;
+export declare const DEFAULT_MAX_BODY_BYTES = 1048576;
+export declare const readRequestBody: () => Promise<null>;
+export declare const readRequestBodyBuffer: () => Promise<null>;
+export declare const loadElizaConfig: () => {
+    agents: {};
+    meta: {};
+    ui: {};
+};
+export declare class TelegramClient {
+}
+export declare const Api: {};
+export declare class StringSession {
+    value: string;
+    constructor(value?: string);
+}
+declare const _default: {};
+export default _default;
+//# sourceMappingURL=empty-node-module.d.ts.map

package/platform/empty-node-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-node-module.d.ts","sourceRoot":"","sources":["../../../../../src/platform/empty-node-module.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,eAAO,MAAM,aAAa,eAAc,CAAC;AACzC,eAAO,MAAM,YAAY,eAAc,CAAC;AAGxC,eAAO,MAAM,QAAQ,YAAW,CAAC;AACjC,eAAO,MAAM,QAAQ,YAAW,CAAC;AAGjC,eAAO,MAAM,cAAc;;qBAgCqn0+C,CAAC;;;;;;;CA/Bvk0+C,CAAC;AAC3E,eAAO,MAAM,cAAc;;;;;CAC+C,CAAC;AAC3E,eAAO,MAAM,eAAe;;;;;CAC+C,CAAC;AAG5E,eAAO,MAAM,8BAA8B;;;CAGzC,CAAC;AACH,eAAO,MAAM,cAAc,wBAAoB,CAAC;AAChD,eAAO,MAAM,cAAc,wBAAoB,CAAC;AAChD,eAAO,MAAM,gBAAgB,wBAAoB,CAAC;AAClD,eAAO,MAAM,yBAAyB,mBAAmB,CAAC;AAC1D,eAAO,MAAM,sBAAsB,UAAY,CAAC;AAChD,eAAO,MAAM,eAAe,qBAAmB,CAAC;AAChD,eAAO,MAAM,qBAAqB,qBAAmB,CAAC;AACtD,eAAO,MAAM,eAAe;;;;CAI1B,CAAC;AAEH,qBAAa,cAAc;CAAG;AAC9B,eAAO,MAAM,GAAG,IAAK,CAAC;AACtB,qBAAa,aAAa;IACL,KAAK;gBAAL,KAAK,SAAK;CAC9B;;AAED,wBAAkB"}

package/platform/empty-node-module.js

@@ -0,0 +1,46 @@
+/**
+ * Empty stub for Node built-in subpaths that don't exist in browser polyfills.
+ * Server-only code imports these but they're never executed in the browser.
+ *
+ * Each named export is a no-op so esbuild's dep scanner doesn't choke.
+ */
+// util/types
+export const isArrayBuffer = () => false;
+export const isTypedArray = () => false;
+// stream/promises
+export const pipeline = () => { };
+export const finished = () => { };
+// stream/web — re-export the global Web Streams if available
+export const ReadableStream = typeof globalThis !== "undefined" ? globalThis.ReadableStream : class {
+};
+export const WritableStream = typeof globalThis !== "undefined" ? globalThis.WritableStream : class {
+};
+export const TransformStream = typeof globalThis !== "undefined" ? globalThis.TransformStream : class {
+};
+// @elizaos/agent browser fallback
+export const createIntegrationTelemetrySpan = () => ({
+    success: () => { },
+    failure: () => { },
+});
+export const hasAdminAccess = async () => false;
+export const hasOwnerAccess = async () => false;
+export const hasPrivateAccess = async () => false;
+export const extractActionParamsViaLlm = async () => ({});
+export const DEFAULT_MAX_BODY_BYTES = 1_048_576;
+export const readRequestBody = async () => null;
+export const readRequestBodyBuffer = async () => null;
+export const loadElizaConfig = () => ({
+    agents: {},
+    meta: {},
+    ui: {},
+});
+export class TelegramClient {
+}
+export const Api = {};
+export class StringSession {
+    value;
+    constructor(value = "") {
+        this.value = value;
+    }
+}
+export default {};

package/platform/index.d.ts

@@ -0,0 +1,12 @@
+/** Platform utilities — platform initialization helpers. */
+export type * from "./types";
+export { applyLaunchConnection, applyLaunchConnectionFromUrl, } from "./browser-launch";
+export * from "./cloud-preference-patch";
+export * from "./desktop-permissions-client";
+export { type DeepLinkHandlers, dispatchShareTarget, handleDeepLink, injectPopoutApiBase, isAndroid, isDesktopPlatform, isElizaOS, isIOS, isNative, isPopoutWindow, isWebPlatform, platform, type ShareTargetFile, type ShareTargetPayload, setupPlatformStyles, } from "./init";
+export * from "./android-runtime";
+export * from "./ios-runtime";
+export * from "./onboarding-reset";
+export type { CloudPreferenceClientLike, OnboardingClientLike, PermissionsClientLike, } from "./types";
+export * from "./window-shell";
+//# sourceMappingURL=index.d.ts.map

package/platform/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/platform/index.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAE5D,mBAAmB,SAAS,CAAC;AAW7B,OAAO,EACL,qBAAqB,EACrB,4BAA4B,GAC7B,MAAM,kBAAkB,CAAC;AAC1B,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,OAAO,EACL,KAAK,gBAAgB,EACrB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,KAAK,EACL,QAAQ,EACR,cAAc,EACd,aAAa,EACb,QAAQ,EACR,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,mBAAmB,GACpB,MAAM,QAAQ,CAAC;AAChB,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,YAAY,EACV,yBAAyB,EACzB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,SAAS,CAAC;AACjB,cAAc,gBAAgB,CAAC"}

package/platform/index.js

@@ -0,0 +1,16 @@
+/** Platform utilities — platform initialization helpers. */
+// Onboarding no longer requests system permissions up front. Permissions
+// are requested just-in-time when a feature actually needs them (via the
+// permissions registry / chat surface). The legacy
+// `REQUIRED_ONBOARDING_PERMISSION_IDS` and `hasRequiredOnboardingPermissions`
+// helpers were removed when the latent first-run permission walkthrough
+// was deleted from `PermissionsSection.tsx`.
+// ── Platform init ───────────────────────────────────────────────────────
+export { applyLaunchConnection, applyLaunchConnectionFromUrl, } from "./browser-launch.js";
+export * from "./cloud-preference-patch.js";
+export * from "./desktop-permissions-client.js";
+export { dispatchShareTarget, handleDeepLink, injectPopoutApiBase, isAndroid, isDesktopPlatform, isElizaOS, isIOS, isNative, isPopoutWindow, isWebPlatform, platform, setupPlatformStyles, } from "./init.js";
+export * from "./android-runtime.js";
+export * from "./ios-runtime.js";
+export * from "./onboarding-reset.js";
+export * from "./window-shell.js";

package/platform/init.d.ts

@@ -0,0 +1,73 @@
+/** Platform detection and initialization utilities. */
+export declare const platform: string;
+export declare const isNative: boolean;
+export declare const isIOS: boolean;
+export declare const isAndroid: boolean;
+export declare function isDesktopPlatform(): boolean;
+/**
+ * Pure UA inspector. Exported only so tests can pin the regex contract
+ * without having to mock the platform module.
+ *
+ * Returns `true` only when `ua` contains a `ElizaOS/<tag>` token at a
+ * word boundary. Substrings like `ElizaOSlike/...` or `NotElizaOS...`
+ * must not match — the regex requires the slash to follow `ElizaOS`
+ * directly.
+ */
+export declare function userAgentHasElizaOSMarker(ua: string): boolean;
+/**
+ * True when the APK is running on the AOSP ElizaOS variant (the system
+ * app on a Eliza-branded device), as opposed to the same APK installed
+ * on a stock Android phone from Play Store.
+ *
+ * Detection: `MainActivity.applyElizaOSUserAgentSuffix` appends
+ * `ElizaOS/<tag>` to the WebView user-agent when `ro.elizaos.product`
+ * is set by the AOSP product makefile (vendor/eliza/eliza_common.mk).
+ * Stock Android leaves the user-agent untouched.
+ *
+ * Used by `RuntimeGate` and the Android boot pre-seed to decide whether
+ * the "Choose your setup" picker is bypassed (ElizaOS — the device IS
+ * the agent) or rendered (vanilla APK — the user picks Cloud / Remote /
+ * Local).
+ */
+export declare function isElizaOS(): boolean;
+/** True when the runtime can spin up a local agent — desktop or dev server. */
+export declare function canRunLocal(): boolean;
+/**
+ * True when the platform might host a local agent that the UI can reach over
+ * the app. Used to decide whether the RuntimeGate's "Local Agent" tile
+ * should run a liveness probe before being shown. Desktop and dev mode
+ * always qualify; Android qualifies because `ElizaAgentService` starts the
+ * bundled agent on `127.0.0.1:31337`; iOS qualifies because app-core handles
+ * the same route shape through an in-process ITTP transport.
+ */
+export declare function canHostLocalAgent(): boolean;
+export declare function isWebPlatform(): boolean;
+export interface ShareTargetFile {
+    name: string;
+    path?: string;
+}
+export interface ShareTargetPayload {
+    source?: string;
+    title?: string;
+    text?: string;
+    url?: string;
+    files?: ShareTargetFile[];
+}
+declare global {
+    interface Window {
+        __ELIZAOS_SHARE_QUEUE__?: ShareTargetPayload[];
+    }
+}
+export declare function dispatchShareTarget(payload: ShareTargetPayload, dispatchEvent: (name: string, detail: unknown) => void, eventName: string): void;
+export interface DeepLinkHandlers {
+    onChat?: () => void;
+    onSettings?: () => void;
+    onConnect?: (gatewayUrl: string) => void;
+    onShare?: (payload: ShareTargetPayload) => void;
+    onUnknown?: (path: string) => void;
+}
+export declare function handleDeepLink(url: string, protocol: string, handlers: DeepLinkHandlers): void;
+export declare function setupPlatformStyles(): void;
+export declare function isPopoutWindow(): boolean;
+export declare function injectPopoutApiBase(): void;
+//# sourceMappingURL=init.d.ts.map

package/platform/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../src/platform/init.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAsBvD,eAAO,MAAM,QAAQ,QAEA,CAAC;AACtB,eAAO,MAAM,QAAQ,SAAoB,CAAC;AAC1C,eAAO,MAAM,KAAK,SAAqB,CAAC;AACxC,eAAO,MAAM,SAAS,SAAyB,CAAC;AAEhD,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAInC;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAID,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,uBAAuB,CAAC,EAAE,kBAAkB,EAAE,CAAC;KAChD;CACF;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,kBAAkB,EAC3B,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,EACtD,SAAS,EAAE,MAAM,GAChB,IAAI,CAMN;AAID,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,SAAS,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAChD,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,gBAAgB,GACzB,IAAI,CAsEN;AAID,wBAAgB,mBAAmB,IAAI,IAAI,CAqB1C;AAID,wBAAgB,cAAc,IAAI,OAAO,CAMxC;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAuC1C"}

package/platform/init.js

@@ -0,0 +1,204 @@
+/** Platform detection and initialization utilities. */
+import { Capacitor } from "@capacitor/core";
+import { isElectrobunRuntime } from "../bridge/index.js";
+import { getBootConfig, setBootConfig } from "../config/boot-config.js";
+// ── Platform detection ──────────────────────────────────────────────
+function detectPlatform() {
+    try {
+        return {
+            platform: Capacitor.getPlatform(),
+            isNative: Capacitor.isNativePlatform(),
+        };
+    }
+    catch {
+        /* fallback */
+    }
+    return { platform: "web", isNative: false };
+}
+const detected = detectPlatform();
+export const platform = isElectrobunRuntime()
+    ? "electrobun"
+    : detected.platform;
+export const isNative = detected.isNative;
+export const isIOS = platform === "ios";
+export const isAndroid = platform === "android";
+export function isDesktopPlatform() {
+    return platform === "electrobun";
+}
+/**
+ * Pure UA inspector. Exported only so tests can pin the regex contract
+ * without having to mock the platform module.
+ *
+ * Returns `true` only when `ua` contains a `ElizaOS/<tag>` token at a
+ * word boundary. Substrings like `ElizaOSlike/...` or `NotElizaOS...`
+ * must not match — the regex requires the slash to follow `ElizaOS`
+ * directly.
+ */
+export function userAgentHasElizaOSMarker(ua) {
+    return /\bElizaOS\//.test(ua);
+}
+/**
+ * True when the APK is running on the AOSP ElizaOS variant (the system
+ * app on a Eliza-branded device), as opposed to the same APK installed
+ * on a stock Android phone from Play Store.
+ *
+ * Detection: `MainActivity.applyElizaOSUserAgentSuffix` appends
+ * `ElizaOS/<tag>` to the WebView user-agent when `ro.elizaos.product`
+ * is set by the AOSP product makefile (vendor/eliza/eliza_common.mk).
+ * Stock Android leaves the user-agent untouched.
+ *
+ * Used by `RuntimeGate` and the Android boot pre-seed to decide whether
+ * the "Choose your setup" picker is bypassed (ElizaOS — the device IS
+ * the agent) or rendered (vanilla APK — the user picks Cloud / Remote /
+ * Local).
+ */
+export function isElizaOS() {
+    if (!isAndroid)
+        return false;
+    if (typeof navigator === "undefined")
+        return false;
+    return userAgentHasElizaOSMarker(navigator.userAgent ?? "");
+}
+/** True when the runtime can spin up a local agent — desktop or dev server. */
+export function canRunLocal() {
+    return isDesktopPlatform() || Boolean(import.meta.env.DEV);
+}
+/**
+ * True when the platform might host a local agent that the UI can reach over
+ * the app. Used to decide whether the RuntimeGate's "Local Agent" tile
+ * should run a liveness probe before being shown. Desktop and dev mode
+ * always qualify; Android qualifies because `ElizaAgentService` starts the
+ * bundled agent on `127.0.0.1:31337`; iOS qualifies because app-core handles
+ * the same route shape through an in-process ITTP transport.
+ */
+export function canHostLocalAgent() {
+    return canRunLocal() || isAndroid || isIOS;
+}
+export function isWebPlatform() {
+    return detected.platform === "web" && !isElectrobunRuntime();
+}
+export function dispatchShareTarget(payload, dispatchEvent, eventName) {
+    if (!window.__ELIZAOS_SHARE_QUEUE__) {
+        window.__ELIZAOS_SHARE_QUEUE__ = [];
+    }
+    window.__ELIZAOS_SHARE_QUEUE__.push(payload);
+    dispatchEvent(eventName, payload);
+}
+export function handleDeepLink(url, protocol, handlers) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return;
+    }
+    if (parsed.protocol !== `${protocol}:`)
+        return;
+    const path = (parsed.pathname || parsed.host || "").replace(/^\/+/, "");
+    switch (path) {
+        case "chat":
+            handlers.onChat?.();
+            break;
+        case "settings":
+            handlers.onSettings?.();
+            break;
+        case "connect": {
+            const gatewayUrl = parsed.searchParams.get("url");
+            if (gatewayUrl) {
+                try {
+                    const validatedUrl = new URL(gatewayUrl);
+                    if (validatedUrl.protocol !== "https:" &&
+                        validatedUrl.protocol !== "http:") {
+                        console.error(`[${protocol}] Invalid gateway URL protocol:`, validatedUrl.protocol);
+                        break;
+                    }
+                    handlers.onConnect?.(validatedUrl.href);
+                }
+                catch {
+                    console.error(`[${protocol}] Invalid gateway URL format`);
+                }
+            }
+            break;
+        }
+        case "share": {
+            const title = parsed.searchParams.get("title")?.trim() || undefined;
+            const text = parsed.searchParams.get("text")?.trim() || undefined;
+            const sharedUrl = parsed.searchParams.get("url")?.trim() || undefined;
+            const files = parsed.searchParams
+                .getAll("file")
+                .map((filePath) => filePath.trim())
+                .filter((filePath) => filePath.length > 0)
+                .map((filePath) => {
+                const slash = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+                const name = slash >= 0 ? filePath.slice(slash + 1) : filePath;
+                return { name, path: filePath };
+            });
+            handlers.onShare?.({
+                source: "deep-link",
+                title,
+                text,
+                url: sharedUrl,
+                files,
+            });
+            break;
+        }
+        default:
+            handlers.onUnknown?.(path);
+    }
+}
+// ── Platform CSS setup ──────────────────────────────────────────────
+export function setupPlatformStyles() {
+    const root = document.documentElement;
+    document.body.classList.add(`platform-${platform}`);
+    if (isNative) {
+        document.body.classList.add("native");
+    }
+    root.style.setProperty("--safe-area-top", "env(safe-area-inset-top, 0px)");
+    root.style.setProperty("--safe-area-bottom", "env(safe-area-inset-bottom, 0px)");
+    root.style.setProperty("--safe-area-left", "env(safe-area-inset-left, 0px)");
+    root.style.setProperty("--safe-area-right", "env(safe-area-inset-right, 0px)");
+    root.style.setProperty("--keyboard-height", "0px");
+}
+// ── Popout helpers ──────────────────────────────────────────────────
+export function isPopoutWindow() {
+    if (typeof window === "undefined")
+        return false;
+    const params = new URLSearchParams(window.location.search || window.location.hash.split("?")[1] || "");
+    return params.has("popout");
+}
+export function injectPopoutApiBase() {
+    const params = new URLSearchParams(window.location.search || window.location.hash.split("?")[1] || "");
+    const apiBase = params.get("apiBase");
+    if (apiBase) {
+        try {
+            const parsed = new URL(apiBase);
+            const host = parsed.hostname;
+            const allowPrivateHttp = /^10\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host) ||
+                /^192\.168\.\d{1,3}\.\d{1,3}$/.test(host) ||
+                /^172\.(1[6-9]|2\d|3[0-1])\.\d{1,3}\.\d{1,3}$/.test(host) ||
+                /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.\d{1,3}\.\d{1,3}$/.test(host) ||
+                host.endsWith(".local") ||
+                host.endsWith(".internal") ||
+                host.endsWith(".ts.net");
+            if (host === "localhost" ||
+                host === "127.0.0.1" ||
+                host === "::1" ||
+                host === window.location.hostname ||
+                parsed.protocol === "https:" ||
+                (parsed.protocol === "http:" && allowPrivateHttp)) {
+                setBootConfig({ ...getBootConfig(), apiBase });
+            }
+            else {
+                console.warn("[app-core] Rejected non-local apiBase:", host);
+            }
+        }
+        catch {
+            if (apiBase.startsWith("/") && !apiBase.startsWith("//")) {
+                setBootConfig({ ...getBootConfig(), apiBase });
+            }
+            else {
+                console.warn("[app-core] Rejected invalid relative apiBase:", apiBase);
+            }
+        }
+    }
+}