@elizaos/app-core 2.0.0-alpha.52 → 2.0.0-alpha.53

package/src/onboarding-config.test.ts

@@ -1,104 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  buildOnboardingConnectionConfig,
-  isElizaCloudConnectionReady,
-} from "./onboarding-config";
-
-describe("buildOnboardingConnectionConfig", () => {
-  it("builds a cloud-managed connection when Eliza Cloud is selected", () => {
-    expect(
-      buildOnboardingConnectionConfig({
-        onboardingRunMode: "cloud",
-        onboardingCloudProvider: "elizacloud",
-        onboardingProvider: "",
-        onboardingApiKey: "ck-test",
-        onboardingPrimaryModel: "",
-        onboardingOpenRouterModel: "",
-        onboardingRemoteConnected: false,
-        onboardingRemoteApiBase: "",
-        onboardingRemoteToken: "",
-        onboardingSmallModel: "openai/gpt-5-mini",
-        onboardingLargeModel: "anthropic/claude-sonnet-4.5",
-      }),
-    ).toEqual({
-      kind: "cloud-managed",
-      cloudProvider: "elizacloud",
-      apiKey: "ck-test",
-      smallModel: "openai/gpt-5-mini",
-      largeModel: "anthropic/claude-sonnet-4.5",
-    });
-  });
-
-  it("builds a local provider connection and carries the openrouter model override", () => {
-    expect(
-      buildOnboardingConnectionConfig({
-        onboardingRunMode: "local",
-        onboardingCloudProvider: "",
-        onboardingProvider: "openrouter",
-        onboardingApiKey: "sk-or-test",
-        onboardingPrimaryModel: "",
-        onboardingOpenRouterModel: "openai/gpt-5-mini",
-        onboardingRemoteConnected: false,
-        onboardingRemoteApiBase: "",
-        onboardingRemoteToken: "",
-        onboardingSmallModel: "",
-        onboardingLargeModel: "",
-      }),
-    ).toEqual({
-      kind: "local-provider",
-      provider: "openrouter",
-      apiKey: "sk-or-test",
-      primaryModel: "openai/gpt-5-mini",
-    });
-  });
-
-  it("builds a remote-provider connection when a remote backend is selected", () => {
-    expect(
-      buildOnboardingConnectionConfig({
-        onboardingRunMode: "cloud",
-        onboardingCloudProvider: "remote",
-        onboardingProvider: "anthropic-subscription",
-        onboardingApiKey: "sk-ant-oat01-test",
-        onboardingPrimaryModel: "",
-        onboardingOpenRouterModel: "",
-        onboardingRemoteConnected: true,
-        onboardingRemoteApiBase: "https://example.com/api",
-        onboardingRemoteToken: "remote-key",
-        onboardingSmallModel: "",
-        onboardingLargeModel: "",
-      }),
-    ).toEqual({
-      kind: "remote-provider",
-      remoteApiBase: "https://example.com/api",
-      remoteAccessToken: "remote-key",
-      provider: "anthropic-subscription",
-      apiKey: "sk-ant-oat01-test",
-      primaryModel: undefined,
-    });
-  });
-});
-
-describe("isElizaCloudConnectionReady", () => {
-  it("treats an existing Eliza Cloud login as ready", () => {
-    expect(
-      isElizaCloudConnectionReady({
-        connection: null,
-        elizaCloudConnected: true,
-      }),
-    ).toBe(true);
-  });
-
-  it("treats a cloud-managed API key connection as ready", () => {
-    expect(
-      isElizaCloudConnectionReady({
-        connection: {
-          kind: "cloud-managed",
-          cloudProvider: "elizacloud",
-          apiKey: "ck-ready",
-        },
-        elizaCloudConnected: false,
-      }),
-    ).toBe(true);
-  });
-});

package/src/onboarding-config.ts

@@ -1,114 +0,0 @@
-import {
-  isCloudManagedConnection,
-  normalizeOnboardingProviderId,
-  type OnboardingConnection,
-  type OnboardingLocalProviderId,
-} from "@elizaos/autonomous/contracts/onboarding";
-
-export interface BuildOnboardingConnectionArgs {
-  onboardingRunMode: "local" | "cloud" | "";
-  onboardingCloudProvider: string;
-  onboardingProvider: string;
-  onboardingApiKey: string;
-  onboardingPrimaryModel: string;
-  onboardingOpenRouterModel: string;
-  onboardingRemoteConnected: boolean;
-  onboardingRemoteApiBase: string;
-  onboardingRemoteToken: string;
-  onboardingSmallModel: string;
-  onboardingLargeModel: string;
-}
-
-function trimToUndefined(value: string): string | undefined {
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function resolveLocalProviderId(
-  provider: string,
-): OnboardingLocalProviderId | null {
-  const normalized = normalizeOnboardingProviderId(provider);
-  return normalized && normalized !== "elizacloud" ? normalized : null;
-}
-
-export function resolveOnboardingPrimaryModel(args: {
-  providerId: string;
-  onboardingPrimaryModel: string;
-  onboardingOpenRouterModel: string;
-}): string | undefined {
-  if (args.providerId === "openrouter") {
-    return trimToUndefined(args.onboardingOpenRouterModel);
-  }
-  return trimToUndefined(args.onboardingPrimaryModel);
-}
-
-export function buildOnboardingConnectionConfig(
-  args: BuildOnboardingConnectionArgs,
-): OnboardingConnection | null {
-  if (
-    args.onboardingRunMode === "cloud" &&
-    args.onboardingCloudProvider === "elizacloud" &&
-    !args.onboardingRemoteConnected
-  ) {
-    return {
-      kind: "cloud-managed",
-      cloudProvider: "elizacloud",
-      apiKey: trimToUndefined(args.onboardingApiKey),
-      smallModel: trimToUndefined(args.onboardingSmallModel),
-      largeModel: trimToUndefined(args.onboardingLargeModel),
-    };
-  }
-
-  const providerId = resolveLocalProviderId(args.onboardingProvider);
-  if (!providerId) {
-    if (args.onboardingCloudProvider === "remote") {
-      return {
-        kind: "remote-provider",
-        remoteApiBase: args.onboardingRemoteApiBase.trim(),
-        remoteAccessToken: trimToUndefined(args.onboardingRemoteToken),
-      };
-    }
-    return null;
-  }
-
-  const primaryModel = resolveOnboardingPrimaryModel({
-    providerId,
-    onboardingPrimaryModel: args.onboardingPrimaryModel,
-    onboardingOpenRouterModel: args.onboardingOpenRouterModel,
-  });
-
-  if (
-    args.onboardingRunMode === "cloud" &&
-    args.onboardingCloudProvider === "remote"
-  ) {
-    return {
-      kind: "remote-provider",
-      remoteApiBase: args.onboardingRemoteApiBase.trim(),
-      remoteAccessToken: trimToUndefined(args.onboardingRemoteToken),
-      provider: providerId,
-      apiKey: trimToUndefined(args.onboardingApiKey),
-      primaryModel,
-    };
-  }
-
-  return {
-    kind: "local-provider",
-    provider: providerId,
-    apiKey: trimToUndefined(args.onboardingApiKey),
-    primaryModel,
-  };
-}
-
-export function isElizaCloudConnectionReady(args: {
-  connection: OnboardingConnection | null | undefined;
-  elizaCloudConnected: boolean;
-}): boolean {
-  if (args.elizaCloudConnected) {
-    return true;
-  }
-  return Boolean(
-    isCloudManagedConnection(args.connection) &&
-      args.connection.cloudProvider === "elizacloud" &&
-      args.connection.apiKey?.trim(),
-  );
-}

package/src/platform/browser-launch.test.ts

@@ -1,94 +0,0 @@
-// @vitest-environment jsdom
-
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const { fetchMock, mockClient } = vi.hoisted(() => ({
-  fetchMock: vi.fn(),
-  mockClient: {
-    setBaseUrl: vi.fn(),
-    setToken: vi.fn(),
-  },
-}));
-
-vi.mock("../api", () => ({
-  client: mockClient,
-}));
-
-import { applyLaunchConnectionFromUrl } from "./browser-launch";
-
-function setUrl(path: string): void {
-  window.history.replaceState({}, "", path);
-}
-
-describe("applyLaunchConnectionFromUrl", () => {
-  beforeEach(() => {
-    fetchMock.mockReset();
-    mockClient.setBaseUrl.mockReset();
-    mockClient.setToken.mockReset();
-    sessionStorage.clear();
-    vi.stubGlobal("fetch", fetchMock);
-    setUrl("/");
-  });
-
-  it("exchanges a managed cloud launch session and strips launch params", async () => {
-    fetchMock.mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          success: true,
-          data: {
-            connection: {
-              apiBase: "https://agent-123.containers.elizacloud.ai",
-              token: "managed-backend-token",
-            },
-          },
-        }),
-        {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        },
-      ),
-    );
-
-    setUrl(
-      "/?cloudLaunchSession=session-123&cloudLaunchBase=https%3A%2F%2Felizacloud.ai",
-    );
-
-    await expect(applyLaunchConnectionFromUrl()).resolves.toBe(true);
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      "https://elizacloud.ai/api/v1/milady/launch-sessions/session-123",
-      expect.objectContaining({
-        method: "GET",
-        redirect: "manual",
-      }),
-    );
-    expect(mockClient.setBaseUrl).toHaveBeenCalledWith(
-      "https://agent-123.containers.elizacloud.ai",
-    );
-    expect(mockClient.setToken).toHaveBeenCalledWith("managed-backend-token");
-    expect(window.location.search).toBe("");
-  });
-
-  it("falls back to direct launch params and strips them after applying", async () => {
-    setUrl(
-      "/?apiBase=https%3A%2F%2Fagent-456.containers.elizacloud.ai&token=backend-token",
-    );
-
-    await expect(applyLaunchConnectionFromUrl()).resolves.toBe(true);
-
-    expect(fetchMock).not.toHaveBeenCalled();
-    expect(mockClient.setBaseUrl).toHaveBeenCalledWith(
-      "https://agent-456.containers.elizacloud.ai",
-    );
-    expect(mockClient.setToken).toHaveBeenCalledWith("backend-token");
-    expect(window.location.search).toBe("");
-  });
-
-  it("returns false when no launch params are present", async () => {
-    await expect(applyLaunchConnectionFromUrl()).resolves.toBe(false);
-
-    expect(fetchMock).not.toHaveBeenCalled();
-    expect(mockClient.setBaseUrl).not.toHaveBeenCalled();
-    expect(mockClient.setToken).not.toHaveBeenCalled();
-  });
-});

package/src/platform/browser-launch.ts

@@ -1,149 +0,0 @@
-import { client } from "../api";
-
-function getSearchParams(): URLSearchParams {
-  if (typeof window === "undefined") {
-    return new URLSearchParams();
-  }
-
-  return new URLSearchParams(
-    window.location.search || window.location.hash.split("?")[1] || "",
-  );
-}
-
-function isAllowedHttpHost(host: string): boolean {
-  return (
-    /^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") ||
-    host === "localhost" ||
-    host === "127.0.0.1" ||
-    host === "::1"
-  );
-}
-
-function normalizeLaunchApiBase(apiBase: string): string {
-  const trimmed = apiBase.trim();
-  if (!trimmed) {
-    throw new Error("Missing launch API base");
-  }
-
-  try {
-    const parsed = new URL(trimmed);
-    if (
-      parsed.protocol === "https:" ||
-      (parsed.protocol === "http:" && isAllowedHttpHost(parsed.hostname))
-    ) {
-      return parsed.toString().replace(/\/+$/, "");
-    }
-    throw new Error(`Rejected launch apiBase protocol: ${parsed.protocol}`);
-  } catch {
-    if (trimmed.startsWith("/") && !trimmed.startsWith("//")) {
-      return trimmed.replace(/\/+$/, "") || "/";
-    }
-    throw new Error("Rejected invalid launch apiBase");
-  }
-}
-
-function normalizeLaunchBaseUrl(baseUrl: string): string {
-  const parsed = new URL(baseUrl);
-  if (parsed.protocol !== "https:" && !isAllowedHttpHost(parsed.hostname)) {
-    throw new Error("Rejected invalid cloud launch base");
-  }
-  parsed.pathname = "";
-  parsed.search = "";
-  parsed.hash = "";
-  return parsed.toString().replace(/\/+$/, "");
-}
-
-function stripLaunchParams(): void {
-  if (typeof window === "undefined") return;
-  const url = new URL(window.location.href);
-  for (const key of [
-    "apiBase",
-    "token",
-    "cloudLaunchSession",
-    "cloudLaunchBase",
-  ]) {
-    url.searchParams.delete(key);
-  }
-  window.history.replaceState({}, "", url.toString());
-}
-
-async function exchangeCloudLaunchSession(
-  cloudBaseUrl: string,
-  sessionId: string,
-): Promise<{ apiBase: string; token: string }> {
-  const response = await fetch(
-    `${cloudBaseUrl}/api/v1/milady/launch-sessions/${encodeURIComponent(sessionId)}`,
-    {
-      method: "GET",
-      headers: { Accept: "application/json" },
-      redirect: "manual",
-    },
-  );
-
-  if (!response.ok) {
-    const payload = (await response.json().catch(() => ({}))) as {
-      error?: string;
-    };
-    throw new Error(
-      payload.error ||
-        `Launch session exchange failed (HTTP ${response.status})`,
-    );
-  }
-
-  const payload = (await response.json()) as {
-    success?: boolean;
-    data?: {
-      connection?: { apiBase?: string; token?: string };
-    };
-    error?: string;
-  };
-
-  if (!payload.success || !payload.data?.connection?.apiBase) {
-    throw new Error(payload.error || "Launch session payload is invalid");
-  }
-
-  const token = payload.data.connection.token?.trim();
-  if (!token) {
-    throw new Error("Launch session did not include an access token");
-  }
-
-  return {
-    apiBase: normalizeLaunchApiBase(payload.data.connection.apiBase),
-    token,
-  };
-}
-
-export async function applyLaunchConnectionFromUrl(): Promise<boolean> {
-  if (typeof window === "undefined") return false;
-
-  const params = getSearchParams();
-  const launchSession = params.get("cloudLaunchSession")?.trim();
-  const launchBase = params.get("cloudLaunchBase")?.trim();
-
-  if (launchSession && launchBase) {
-    const connection = await exchangeCloudLaunchSession(
-      normalizeLaunchBaseUrl(launchBase),
-      launchSession,
-    );
-    client.setBaseUrl(connection.apiBase);
-    client.setToken(connection.token);
-    stripLaunchParams();
-    return true;
-  }
-
-  const apiBase = params.get("apiBase")?.trim();
-  if (!apiBase) {
-    return false;
-  }
-
-  client.setBaseUrl(normalizeLaunchApiBase(apiBase));
-  client.setToken(params.get("token")?.trim() || null);
-  stripLaunchParams();
-  return true;
-}

package/src/platform/index.ts

@@ -1,58 +0,0 @@
-/**
- * Platform utilities — onboarding permissions and platform initialization helpers.
- *
- * Migrated from apps/app/src/onboarding-permissions.ts and main.tsx.
- */
-
-import type {
-  AllPermissionsState,
-  PermissionStatus,
-  SystemPermissionId,
-} from "../api/client";
-
-// ── Onboarding permissions ──────────────────────────────────────────────
-
-export const REQUIRED_ONBOARDING_PERMISSION_IDS: ReadonlyArray<SystemPermissionId> =
-  ["accessibility", "screen-recording", "microphone"];
-
-export function isOnboardingPermissionGranted(
-  status: PermissionStatus | undefined,
-): boolean {
-  return status === "granted" || status === "not-applicable";
-}
-
-export function getMissingOnboardingPermissions(
-  permissions: AllPermissionsState | null | undefined,
-): SystemPermissionId[] {
-  if (!permissions) return [...REQUIRED_ONBOARDING_PERMISSION_IDS];
-  return REQUIRED_ONBOARDING_PERMISSION_IDS.filter((id) => {
-    return !isOnboardingPermissionGranted(permissions[id]?.status);
-  });
-}
-
-export function hasRequiredOnboardingPermissions(
-  permissions: AllPermissionsState | null | undefined,
-): boolean {
-  return getMissingOnboardingPermissions(permissions).length === 0;
-}
-
-// ── Platform init ───────────────────────────────────────────────────────
-
-export { applyLaunchConnectionFromUrl } from "./browser-launch";
-export {
-  type DeepLinkHandlers,
-  dispatchShareTarget,
-  handleDeepLink,
-  injectPopoutApiBase,
-  isAndroid,
-  isElectronPlatform,
-  isIOS,
-  isNative,
-  isPopoutWindow,
-  isWebPlatform,
-  platform,
-  type ShareTargetFile,
-  type ShareTargetPayload,
-  setupPlatformStyles,
-} from "./init";
-export * from "./lifo";