@elizaos/plugin-elizacloud 2.0.0-alpha.8 → 2.0.11-beta.7

package/src/routes/cloud-status-routes-autonomous.ts

@@ -0,0 +1,238 @@
+import {
+  isCloudInferenceSelectedInConfig,
+  isElizaCloudServiceSelectedInConfig,
+  migrateLegacyRuntimeConfig,
+} from "@elizaos/core";
+import type {
+  AgentRuntime,
+  RouteHelpers,
+  RouteRequestMeta,
+  Service,
+} from "@elizaos/core";
+import { resolveCloudApiBaseUrl as resolveCanonicalCloudApiBaseUrl } from "../cloud/base-url.js";
+import { resolveCloudApiKey } from "../cloud/cloud-api-key.js";
+import { validateCloudBaseUrl } from "../cloud/validate-url.js";
+
+const DEFAULT_CLOUD_API_BASE_URL = "https://www.elizacloud.ai/api/v1";
+const CLOUD_BILLING_URL =
+  "https://www.elizacloud.ai/dashboard/settings?tab=billing";
+
+interface CloudAuthIdentityService {
+  isAuthenticated: () => boolean;
+  getUserId?: () => string | undefined;
+  getOrganizationId?: () => string | undefined;
+}
+
+interface CloudAuthCreditsService {
+  isAuthenticated: () => boolean;
+  getClient: () => { get: <T>(path: string) => Promise<T> };
+}
+
+export interface CloudConfigLike {
+  cloud?: {
+    enabled?: boolean;
+    apiKey?: string;
+    baseUrl?: string;
+  };
+}
+
+export interface CloudStatusRouteContext
+  extends RouteRequestMeta,
+    Pick<RouteHelpers, "json"> {
+  config: CloudConfigLike;
+  runtime: AgentRuntime | null;
+}
+
+function resolveCloudApiBaseUrl(rawBaseUrl?: string): string {
+  return resolveCanonicalCloudApiBaseUrl(
+    rawBaseUrl ?? DEFAULT_CLOUD_API_BASE_URL,
+  );
+}
+
+/**
+ * Coerce an Eliza Cloud `balance` field into a number. The cloud API
+ * returns `balance` as `string | number` — string when upstream is using
+ * fixed-precision decimals, number when arithmetic'd. Treat both as the
+ * same dollar amount.
+ */
+function coerceCloudBalance(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    const parsed = Number.parseFloat(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+async function fetchCloudCreditsByApiKey(
+  baseUrl: string,
+  apiKey: string,
+): Promise<number | null> {
+  const response = await fetch(`${baseUrl}/credits/balance`, {
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    redirect: "manual",
+    signal: AbortSignal.timeout(10_000),
+  });
+
+  if (response.status >= 300 && response.status < 400) {
+    throw new Error(
+      "Cloud credits request was redirected; redirects are not allowed",
+    );
+  }
+
+  const creditResponse = (await response.json().catch(() => ({}))) as Record<
+    string,
+    unknown
+  >;
+
+  if (!response.ok) {
+    const message =
+      typeof creditResponse.error === "string" && creditResponse.error.trim()
+        ? creditResponse.error
+        : `HTTP ${response.status}`;
+    throw new Error(message);
+  }
+
+  const balance =
+    coerceCloudBalance(creditResponse.balance) ??
+    coerceCloudBalance(
+      (creditResponse.data as Record<string, unknown> | undefined)?.balance,
+    );
+  return balance;
+}
+
+export async function handleCloudStatusRoutes(
+  ctx: CloudStatusRouteContext,
+): Promise<boolean> {
+  const { res, method, pathname, config, runtime, json } = ctx;
+
+  if (method === "GET" && pathname === "/api/cloud/status") {
+    migrateLegacyRuntimeConfig(config as Record<string, unknown>);
+    const cloudEnabled = isCloudInferenceSelectedInConfig(
+      config as Record<string, unknown>,
+    );
+    const cloudVoiceProxyAvailable = isElizaCloudServiceSelectedInConfig(
+      config as Record<string, unknown>,
+      "tts",
+    );
+    const configApiKey = resolveCloudApiKey(config, runtime);
+    const hasApiKey = Boolean(configApiKey);
+    const cloudAuth = runtime
+      ? runtime.getService<Service & CloudAuthIdentityService>("CLOUD_AUTH")
+      : null;
+    const authConnected = Boolean(cloudAuth?.isAuthenticated());
+
+    if (authConnected || hasApiKey) {
+      json(res, {
+        connected: true,
+        enabled: cloudEnabled,
+        cloudVoiceProxyAvailable,
+        hasApiKey,
+        userId: authConnected ? cloudAuth?.getUserId?.() : undefined,
+        organizationId: authConnected
+          ? cloudAuth?.getOrganizationId?.()
+          : undefined,
+        topUpUrl: CLOUD_BILLING_URL,
+        reason: authConnected
+          ? undefined
+          : runtime
+            ? "api_key_present_not_authenticated"
+            : "api_key_present_runtime_not_started",
+      });
+      return true;
+    }
+
+    if (!runtime) {
+      json(res, {
+        connected: false,
+        enabled: cloudEnabled,
+        cloudVoiceProxyAvailable,
+        hasApiKey,
+        reason: "runtime_not_started",
+      });
+      return true;
+    }
+
+    json(res, {
+      connected: false,
+      enabled: cloudEnabled,
+      cloudVoiceProxyAvailable,
+      hasApiKey,
+      reason: "not_authenticated",
+    });
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/cloud/credits") {
+    const cloudAuth = runtime
+      ? runtime.getService<Service & CloudAuthCreditsService>("CLOUD_AUTH")
+      : null;
+    const configApiKey = resolveCloudApiKey(config, runtime);
+
+    if (!cloudAuth?.isAuthenticated()) {
+      if (!configApiKey) {
+        json(res, { balance: null, connected: false });
+        return true;
+      }
+
+      const resolvedBaseUrl = resolveCloudApiBaseUrl(config.cloud?.baseUrl);
+      const baseUrlRejection = await validateCloudBaseUrl(resolvedBaseUrl);
+      if (baseUrlRejection) {
+        json(res, { balance: null, connected: true, error: baseUrlRejection });
+        return true;
+      }
+
+      const balance = await fetchCloudCreditsByApiKey(
+        resolvedBaseUrl,
+        configApiKey,
+      );
+      if (typeof balance !== "number") {
+        throw new Error("unexpected response");
+      }
+      const low = balance < 2.0;
+      const critical = balance < 0.5;
+      json(res, {
+        connected: true,
+        balance,
+        low,
+        critical,
+        topUpUrl: CLOUD_BILLING_URL,
+      });
+      return true;
+    }
+
+    const client = cloudAuth.getClient();
+    const creditResponse =
+      await client.get<Record<string, unknown>>("/credits/balance");
+    const balance =
+      coerceCloudBalance(creditResponse?.balance) ??
+      coerceCloudBalance(
+        (creditResponse?.data as Record<string, unknown> | undefined)?.balance,
+      );
+    if (typeof balance !== "number") {
+      throw new Error(
+        `Unexpected response shape: ${JSON.stringify(creditResponse)}`,
+      );
+    }
+
+    const low = balance < 2.0;
+    const critical = balance < 0.5;
+    json(res, {
+      connected: true,
+      balance,
+      low,
+      critical,
+      topUpUrl: CLOUD_BILLING_URL,
+    });
+    return true;
+  }
+
+  return false;
+}

package/src/routes/cloud-status-routes.ts

@@ -0,0 +1,73 @@
+import type {
+  CloudConfigLike,
+  CloudStatusRouteContext,
+} from "./cloud-status-routes-autonomous.js";
+import type { ElizaConfig } from "../lib/config-like";
+import { isElizaCloudServiceSelectedInConfig } from "@elizaos/core";
+import {
+  CLOUD_BILLING_URL,
+  fetchCloudCredits,
+  resolveCloudConnectionSnapshot,
+} from "../lib/cloud-connection";
+
+export type { CloudConfigLike, CloudStatusRouteContext };
+
+export async function handleCloudStatusRoutes(
+  ctx: CloudStatusRouteContext,
+): Promise<boolean> {
+  const { res, method, pathname, config, runtime, json } = ctx;
+  const typedConfig = config as ElizaConfig;
+
+  if (method === "GET" && pathname === "/api/cloud/status") {
+    const snapshot = resolveCloudConnectionSnapshot(typedConfig, runtime);
+    const cloudVoiceProxyAvailable = isElizaCloudServiceSelectedInConfig(
+      typedConfig as Record<string, unknown>,
+      "tts",
+    );
+
+    if (snapshot.connected) {
+      json(res, {
+        connected: true,
+        enabled: snapshot.enabled,
+        cloudVoiceProxyAvailable,
+        hasApiKey: snapshot.hasApiKey,
+        userId: snapshot.userId,
+        organizationId: snapshot.organizationId,
+        topUpUrl: CLOUD_BILLING_URL,
+        reason: snapshot.authConnected
+          ? undefined
+          : runtime
+            ? "api_key_present_not_authenticated"
+            : "api_key_present_runtime_not_started",
+      });
+      return true;
+    }
+
+    if (!runtime) {
+      json(res, {
+        connected: false,
+        enabled: snapshot.enabled,
+        cloudVoiceProxyAvailable,
+        hasApiKey: snapshot.hasApiKey,
+        reason: "runtime_not_started",
+      });
+      return true;
+    }
+
+    json(res, {
+      connected: false,
+      enabled: snapshot.enabled,
+      cloudVoiceProxyAvailable,
+      hasApiKey: snapshot.hasApiKey,
+      reason: "not_authenticated",
+    });
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/cloud/credits") {
+    json(res, await fetchCloudCredits(typedConfig, runtime));
+    return true;
+  }
+
+  return false;
+}

package/src/routes/home-remote-runner-access-url.ts

@@ -0,0 +1,83 @@
+import { normalizeCloudSiteUrl } from "@elizaos/shared";
+
+export const HOME_REMOTE_RUNNER_ACCESS_SESSION_PARAM = "homeRemoteRunnerSession";
+
+export interface HomeRemoteRunnerSshTunnel {
+  command: string;
+  localUrl: string;
+}
+
+export function buildHomeRemoteRunnerAccessUrl(input: {
+  cloudBaseUrl?: string | null;
+  sessionId?: string | null;
+}): string | null {
+  const sessionId = input.sessionId?.trim();
+  if (!sessionId) return null;
+
+  try {
+    const url = new URL(normalizeCloudSiteUrl(input.cloudBaseUrl ?? undefined));
+    url.pathname = "/dashboard/app";
+    url.search = "";
+    url.hash = "";
+    url.searchParams.set(HOME_REMOTE_RUNNER_ACCESS_SESSION_PARAM, sessionId);
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+
+export function buildHomeRemoteRunnerSshTunnel(input: {
+  remoteBaseUrl?: string | null;
+  sshTarget?: string | null;
+  sshIdentity?: string | null;
+  localPort?: string | number | null;
+}): HomeRemoteRunnerSshTunnel | null {
+  const sshTarget = normalizeSshTarget(input.sshTarget);
+  if (!sshTarget) return null;
+
+  let parsed: URL;
+  try {
+    parsed = new URL(input.remoteBaseUrl?.trim() ?? "");
+  } catch {
+    return null;
+  }
+
+  if (parsed.protocol !== "http:") {
+    return null;
+  }
+
+  const remotePort = parsed.port || "80";
+  const localPort = normalizePort(input.localPort) ?? remotePort;
+  const remoteHost =
+    parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1"
+      ? "127.0.0.1"
+      : parsed.hostname;
+  const identityArg = input.sshIdentity?.trim()
+    ? ` -i ${quoteShellArg(input.sshIdentity.trim())}`
+    : "";
+  const command = `ssh -N${identityArg} -L 127.0.0.1:${localPort}:${remoteHost}:${remotePort} ${sshTarget}`;
+  return {
+    command,
+    localUrl: `${parsed.protocol}//127.0.0.1:${localPort}`,
+  };
+}
+
+function normalizePort(value: string | number | null | undefined): string | null {
+  if (value === null || value === undefined) return null;
+  const raw = String(value).trim();
+  if (!/^\d+$/.test(raw)) return null;
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+  return String(port);
+}
+
+function normalizeSshTarget(value: string | null | undefined): string | null {
+  const target = value?.trim();
+  if (!target) return null;
+  if (!/^[A-Za-z0-9._~%+-]+@[A-Za-z0-9.-]+$/.test(target)) return null;
+  return target;
+}
+
+function quoteShellArg(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/src/routes/travel-provider-relay-routes.ts

@@ -0,0 +1,193 @@
+import type http from "node:http";
+import {
+  type IAgentRuntime,
+  type Service,
+  sendJson,
+  sendJsonError,
+} from "@elizaos/core";
+import {
+  isCloudAuthApiKeyService,
+  normalizeCloudApiKey,
+} from "../cloud/auth-service-types.js";
+import { normalizeCloudSiteUrl } from "../cloud/base-url.js";
+import { resolveCloudApiKey } from "../cloud/cloud-api-key.js";
+import { validateCloudBaseUrl } from "../cloud/validate-url.js";
+import type { CloudProxyConfigLike } from "../lib/config-like";
+
+export interface TravelProviderRelayRouteState {
+  config: CloudProxyConfigLike;
+  runtime?: IAgentRuntime | null;
+}
+
+const PROXY_TIMEOUT_MS = 30_000;
+const MAX_BODY_BYTES = 1_048_576;
+const TRAVEL_PROVIDER_PATH_RE =
+  /^\/api\/cloud\/travel-providers\/([a-z0-9][a-z0-9-]*)(\/.*)$/;
+
+function resolveProxyApiKey(
+  state: TravelProviderRelayRouteState,
+): string | null {
+  const cloudAuth = state.runtime?.getService<Service>("CLOUD_AUTH");
+  const runtimeApiKey =
+    isCloudAuthApiKeyService(cloudAuth) && cloudAuth.isAuthenticated() === true
+      ? normalizeCloudApiKey(cloudAuth.getApiKey?.())
+      : null;
+  return runtimeApiKey ?? resolveCloudApiKey(state.config, state.runtime);
+}
+
+function buildAuthHeaders(
+  config: CloudProxyConfigLike,
+  apiKey: string,
+): Record<string, string> {
+  const serviceKey = config.cloud?.serviceKey?.trim();
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+  };
+  if (serviceKey) headers["X-Service-Key"] = serviceKey;
+  return headers;
+}
+
+function readBody(req: http.IncomingMessage): Promise<string | undefined> {
+  return new Promise<string | undefined>((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    let size = 0;
+    req.on("data", (chunk: Buffer) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () =>
+      resolve(
+        chunks.length > 0 ? Buffer.concat(chunks).toString("utf-8") : undefined,
+      ),
+    );
+    req.on("error", reject);
+  });
+}
+
+async function readJsonResponse(response: Response): Promise<unknown> {
+  return response.json().catch(async () => ({
+    success: response.ok,
+    error: await response
+      .text()
+      .catch(() => "Travel-provider relay request failed"),
+  }));
+}
+
+function buildUpstreamPath(localPath: string): string {
+  const parsed = parseTravelProviderPath(localPath);
+  if (!parsed) {
+    throw new Error("Invalid travel-provider relay path");
+  }
+  return `/api/v1/${parsed.provider}${parsed.providerPath}`;
+}
+
+const TRAVEL_PROVIDER_RELAY_ROUTES: ReadonlyArray<{
+  method: "GET" | "POST";
+  pattern: RegExp;
+}> = [
+  { method: "POST", pattern: /^\/offer-requests$/ },
+  { method: "GET", pattern: /^\/offers\/[^/]+$/ },
+  { method: "POST", pattern: /^\/orders$/ },
+  { method: "GET", pattern: /^\/orders\/[^/]+$/ },
+  { method: "POST", pattern: /^\/payments$/ },
+];
+
+function parseTravelProviderPath(
+  pathname: string,
+): { provider: string; providerPath: string } | null {
+  const match = TRAVEL_PROVIDER_PATH_RE.exec(pathname);
+  if (!match) return null;
+  const [, provider, providerPath] = match;
+  return provider ? { provider, providerPath } : null;
+}
+
+function matchRoute(method: string, pathname: string): boolean {
+  const parsed = parseTravelProviderPath(pathname);
+  if (!parsed) return false;
+  return TRAVEL_PROVIDER_RELAY_ROUTES.some(
+    (route) => route.method === method && route.pattern.test(parsed.providerPath),
+  );
+}
+
+export async function handleTravelProviderRelayRoute(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  pathname: string,
+  method: string,
+  state: TravelProviderRelayRouteState,
+): Promise<boolean> {
+  const parsed = parseTravelProviderPath(pathname);
+  if (!parsed) return false;
+
+  if (!matchRoute(method, pathname)) {
+    sendJsonError(res, "Unknown travel-provider relay route", 404);
+    return true;
+  }
+
+  const apiKey = resolveProxyApiKey(state);
+  if (!apiKey) {
+    sendJsonError(
+      res,
+      "Not connected to Eliza Cloud. Sign in to use travel search.",
+      401,
+    );
+    return true;
+  }
+
+  const baseUrl = normalizeCloudSiteUrl(state.config.cloud?.baseUrl);
+  const urlError = await validateCloudBaseUrl(baseUrl);
+  if (urlError) {
+    sendJsonError(res, urlError, 502);
+    return true;
+  }
+
+  const headers = buildAuthHeaders(state.config, apiKey);
+  let body: string | undefined;
+  if (method === "POST") {
+    try {
+      body = await readBody(req);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to read body";
+      sendJsonError(res, msg, 413);
+      return true;
+    }
+  }
+
+  const fullUrl = new URL(req.url ?? pathname, "http://localhost");
+  const upstreamUrl = `${baseUrl}${buildUpstreamPath(pathname)}${fullUrl.search}`;
+  const upstreamResponse = await fetch(upstreamUrl, {
+    method,
+    headers,
+    body,
+    redirect: "manual",
+    signal: AbortSignal.timeout(PROXY_TIMEOUT_MS),
+  });
+
+  if (upstreamResponse.status === 402) {
+    await forward402(res, upstreamResponse);
+    return true;
+  }
+
+  const payload = await readJsonResponse(upstreamResponse);
+  sendJson(res, payload, upstreamResponse.status);
+  return true;
+}
+
+async function forward402(
+  res: http.ServerResponse,
+  upstream: Response,
+): Promise<void> {
+  const wwwAuth = upstream.headers.get("www-authenticate");
+  const contentType = upstream.headers.get("content-type") ?? "application/json";
+  const bodyText = await upstream.text();
+  res.statusCode = 402;
+  res.setHeader("Content-Type", contentType);
+  if (wwwAuth) res.setHeader("WWW-Authenticate", wwwAuth);
+  res.end(bodyText);
+}