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

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

@@ -0,0 +1,314 @@
+import type http from "node:http";
+import type { AgentRuntime, Service } from "@elizaos/core";
+import { logger } from "@elizaos/core";
+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";
+import { sendJson, sendJsonError } from "../lib/http";
+
+export interface CloudCompatRouteState {
+  config: CloudProxyConfigLike;
+  runtime?: AgentRuntime | null;
+}
+
+const PROXY_TIMEOUT_MS = 15_000;
+const MAX_BODY_BYTES = 1_048_576;
+const JSON_CONTENT_TYPE_RE = /\b(?:application\/json|[^;\s]+\+json)\b/i;
+
+interface CloudAuthApiKeyService {
+  isAuthenticated: () => boolean;
+  getApiKey?: () => string | undefined;
+}
+
+export function resolveCloudBaseUrl(config: CloudProxyConfigLike): string {
+  return normalizeCloudSiteUrl(config.cloud?.baseUrl);
+}
+
+function normalizeCloudApiKey(value: string | null | undefined): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.toUpperCase() === "[REDACTED]") {
+    return null;
+  }
+  return trimmed;
+}
+
+function resolveProxyApiKey(state: CloudCompatRouteState): string | null {
+  const cloudAuth = state.runtime
+    ? state.runtime.getService<Service & CloudAuthApiKeyService>("CLOUD_AUTH")
+    : null;
+  const runtimeApiKey =
+    cloudAuth?.isAuthenticated() === true
+      ? normalizeCloudApiKey(cloudAuth.getApiKey?.())
+      : null;
+
+  return runtimeApiKey ?? resolveCloudApiKey(state.config, state.runtime);
+}
+
+function buildAuthHeaders(
+  config: CloudProxyConfigLike,
+  apiKeyOverride?: string | null,
+): Record<string, string> {
+  const serviceKey = config.cloud?.serviceKey?.trim();
+  const apiKey =
+    normalizeCloudApiKey(apiKeyOverride) ?? resolveCloudApiKey(config);
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  };
+
+  if (serviceKey) {
+    headers["X-Service-Key"] = serviceKey;
+  }
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+
+  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 fetchUpstream(
+  url: string,
+  method: string,
+  headers: Record<string, string>,
+  body: string | undefined,
+): Promise<Response> {
+  const res = await fetch(url, {
+    method,
+    headers,
+    body,
+    redirect: "manual",
+    signal: AbortSignal.timeout(PROXY_TIMEOUT_MS),
+  });
+
+  if (res.status >= 300 && res.status < 400) {
+    throw Object.assign(new Error("redirect"), { code: "REDIRECT" });
+  }
+
+  return res;
+}
+
+function summarizeUpstreamBody(bodyText: string): string {
+  const trimmed = bodyText.trim();
+  if (!trimmed) return "";
+  return trimmed.length > 300 ? `${trimmed.slice(0, 297)}...` : trimmed;
+}
+
+function isResourceCompatPath(pathname: string): boolean {
+  return pathname.split("/").filter(Boolean).length >= 5;
+}
+
+function sendUpstreamNotFound(
+  res: http.ServerResponse,
+  pathname: string,
+  upstreamBody?: unknown,
+): void {
+  if (isResourceCompatPath(pathname)) {
+    sendJson(
+      res,
+      upstreamBody ?? {
+        success: false,
+        error: "Eliza Cloud returned 404 for this API route.",
+        code: "CLOUD_ROUTE_NOT_FOUND",
+      },
+      404,
+    );
+    return;
+  }
+
+  sendJson(
+    res,
+    {
+      success: false,
+      error: "This Cloud feature is not available yet.",
+      code: "CLOUD_NOT_READY",
+    },
+    404,
+  );
+}
+
+async function parseUpstreamJsonResponse(
+  upstreamRes: Response,
+  method: string,
+): Promise<
+  | { kind: "head" }
+  | { kind: "empty" }
+  | { kind: "json"; body: unknown }
+  | { kind: "invalid-json"; bodyText: string }
+  | { kind: "non-json"; bodyText: string }
+> {
+  if (method === "HEAD") {
+    return { kind: "head" };
+  }
+
+  const bodyText = await upstreamRes.text();
+  if (bodyText.trim().length === 0) {
+    return { kind: "empty" };
+  }
+
+  const contentType = upstreamRes.headers.get("content-type");
+  const expectsJson = JSON_CONTENT_TYPE_RE.test(contentType ?? "");
+
+  if (!expectsJson && !/^\s*[[{]/.test(bodyText)) {
+    return { kind: "non-json", bodyText };
+  }
+
+  try {
+    return { kind: "json", body: JSON.parse(bodyText) };
+  } catch {
+    return expectsJson
+      ? { kind: "invalid-json", bodyText }
+      : { kind: "non-json", bodyText };
+  }
+}
+
+function handleUpstreamError(error: unknown, res: http.ServerResponse): void {
+  if (error instanceof Error) {
+    const errorCode = (error as { code?: string }).code;
+    if (errorCode === "REDIRECT") {
+      sendJsonError(res, "Eliza Cloud returned an unexpected redirect.", 502);
+      return;
+    }
+    if (error.name === "TimeoutError" || error.name === "AbortError") {
+      sendJsonError(res, "Eliza Cloud request timed out.", 504);
+      return;
+    }
+    if (error.message === "Request body too large") {
+      sendJsonError(res, error.message, 413);
+      return;
+    }
+    sendJsonError(
+      res,
+      `Failed to reach Eliza Cloud: ${error.message || "Unknown error"}`,
+      502,
+    );
+    return;
+  }
+
+  sendJsonError(res, "Failed to reach Eliza Cloud.", 502);
+}
+
+/** Paths under /api/cloud/v1/ are forwarded directly as /api/v1/ on the cloud backend. */
+const CLOUD_V1_PREFIX = "/api/cloud/v1/";
+
+export async function handleCloudCompatRoute(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  pathname: string,
+  method: string,
+  state: CloudCompatRouteState,
+): Promise<boolean> {
+  const isCompatRoute = pathname.startsWith("/api/cloud/compat/");
+  const isV1Route = pathname.startsWith(CLOUD_V1_PREFIX);
+  if (!isCompatRoute && !isV1Route) return false;
+
+  const apiKey = resolveProxyApiKey(state);
+  if (!apiKey) {
+    sendJsonError(
+      res,
+      "Not connected to Eliza Cloud. Please log in first.",
+      401,
+    );
+    return true;
+  }
+
+  const baseUrl = resolveCloudBaseUrl(state.config);
+  const urlError = await validateCloudBaseUrl(baseUrl);
+  if (urlError) {
+    sendJsonError(res, urlError, 502);
+    return true;
+  }
+
+  // /api/cloud/compat/* → /api/compat/*  (existing mapping)
+  // /api/cloud/v1/*    → /api/v1/*       (eliza v1 endpoints, e.g. pairing-token)
+  // Both branches strip the leading `/api/cloud` and re-prefix `/api`. The
+  // earlier v1 branch used `.slice("/api/cloud".length)` which left
+  // `/v1/...` (no `/api/` prefix), causing upstream to return 405 for
+  // valid POSTs to e.g. /api/v1/app/agents/{id}/provision.
+  const compatPath = pathname.replace("/api/cloud", "/api");
+  const fullUrl = req.url ?? pathname;
+  const qsIndex = fullUrl.indexOf("?");
+  const queryString = qsIndex >= 0 ? fullUrl.slice(qsIndex) : "";
+  const upstreamUrl = `${baseUrl}${compatPath}${queryString}`;
+  const headers = buildAuthHeaders(state.config, apiKey);
+
+  try {
+    let body: string | undefined;
+    if (method !== "GET" && method !== "HEAD") {
+      body = await readBody(req);
+    }
+
+    const upstreamRes = await fetchUpstream(upstreamUrl, method, headers, body);
+    const parsed = await parseUpstreamJsonResponse(upstreamRes, method);
+
+    if (parsed.kind === "head") {
+      res.statusCode = upstreamRes.status;
+      res.end();
+      return true;
+    }
+
+    if (parsed.kind === "json") {
+      if (upstreamRes.status === 404) {
+        sendUpstreamNotFound(res, pathname, parsed.body);
+        return true;
+      }
+      sendJson(res, parsed.body, upstreamRes.status);
+      return true;
+    }
+
+    if (upstreamRes.status === 404) {
+      sendUpstreamNotFound(res, pathname);
+      return true;
+    }
+
+    const upstreamStatus = upstreamRes.ok ? 502 : upstreamRes.status;
+    if (parsed.kind === "empty") {
+      const message = upstreamRes.ok
+        ? "Eliza Cloud returned an empty response."
+        : `Eliza Cloud returned HTTP ${upstreamRes.status} with an empty response body.`;
+      sendJsonError(res, message, upstreamStatus);
+      return true;
+    }
+
+    const message =
+      parsed.kind === "invalid-json"
+        ? "Eliza Cloud returned malformed JSON."
+        : "Eliza Cloud returned a non-JSON response.";
+    const detail = summarizeUpstreamBody(parsed.bodyText);
+    logger.warn(
+      `[cloud-compat] ${message} ${method} ${compatPath} (${upstreamRes.status})${detail ? `: ${detail}` : ""}`,
+    );
+    sendJsonError(
+      res,
+      detail ? `${message} ${detail}` : message,
+      upstreamStatus,
+    );
+    return true;
+  } catch (error) {
+    handleUpstreamError(error, res);
+    return true;
+  }
+}

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

@@ -0,0 +1,57 @@
+import type http from "node:http";
+import type { AgentRuntime } from "@elizaos/core";
+import type { CloudProxyConfigLike } from "../lib/config-like";
+import { sendJsonError } from "../lib/http";
+
+const LIFEOPS_CLOUD_FEATURES_MODULE: string =
+  "@elizaos/app-lifeops";
+
+export interface CloudFeaturesRouteState {
+  config: CloudProxyConfigLike;
+  runtime?: AgentRuntime | null;
+}
+
+type CloudFeaturesRoutesModule = {
+  handleCloudFeaturesRoute?: (
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    pathname: string,
+    method: string,
+    state: CloudFeaturesRouteState,
+  ) => Promise<boolean> | boolean;
+};
+
+export async function handleCloudFeaturesRoute(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  pathname: string,
+  method: string,
+  state: CloudFeaturesRouteState,
+): Promise<boolean> {
+  if (
+    pathname !== "/api/cloud/features" &&
+    pathname !== "/api/cloud/features/sync"
+  ) {
+    return false;
+  }
+
+  try {
+    const loaded = (await import(
+      /* @vite-ignore */ LIFEOPS_CLOUD_FEATURES_MODULE
+    )) as CloudFeaturesRoutesModule;
+    if (typeof loaded.handleCloudFeaturesRoute !== "function") {
+      sendJsonError(res, "LifeOps cloud feature routes are not available", 503);
+      return true;
+    }
+    return await loaded.handleCloudFeaturesRoute(
+      req,
+      res,
+      pathname,
+      method,
+      state,
+    );
+  } catch {
+    sendJsonError(res, "LifeOps cloud feature routes are not available", 503);
+    return true;
+  }
+}

package/src/routes/cloud-provisioning.ts

@@ -0,0 +1,37 @@
+function hasValue(value: string | undefined): boolean {
+  return Boolean(value?.trim());
+}
+
+function hasCompatApiToken(): boolean {
+  return hasValue(process.env.ELIZA_API_TOKEN);
+}
+
+function hasCloudApiKeyProvisioning(): boolean {
+  return (
+    process.env.ELIZAOS_CLOUD_ENABLED === "true" &&
+    hasValue(process.env.ELIZAOS_CLOUD_API_KEY)
+  );
+}
+
+/**
+ * Platform-managed cloud containers should skip local pairing and onboarding UI.
+ *
+ * In production we may have either:
+ * - a Steward sidecar token (older / sidecar-managed path),
+ * - an inbound API token injected directly into the container, or
+ * - cloud-managed API-key access injected into the runtime environment.
+ *
+ * Requiring the cloud flag plus one of those credentials keeps accidental local
+ * env leakage from triggering cloud behavior, while still matching real deployed
+ * cloud containers.
+ */
+export function isCloudProvisionedContainer(): boolean {
+  const hasCloudFlag = process.env.ELIZA_CLOUD_PROVISIONED === "1";
+
+  return (
+    hasCloudFlag &&
+    (hasValue(process.env.STEWARD_AGENT_TOKEN) ||
+      hasCompatApiToken() ||
+      hasCloudApiKeyProvisioning())
+  );
+}

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

@@ -0,0 +1,89 @@
+/**
+ * Cloud gateway relay status route.
+ *
+ * Exposes the current state of the CloudManagedGatewayRelayService
+ * so the UI can show whether this local instance is registered with
+ * Eliza Cloud and actively receiving routed messages.
+ *
+ *   GET /api/cloud/relay-status
+ *
+ * The relay service lives in plugin-elizacloud and registers itself
+ * as a runtime service named "cloud-managed-gateway-relay". We query
+ * it via the runtime.getService interface to avoid a build-time dep.
+ */
+
+import type http from "node:http";
+import type { RouteHelpers } from "../lib/http";
+
+interface RelayServiceLike {
+  getSessionInfo(): {
+    sessionId: string | null;
+    organizationId: string | null;
+    userId: string | null;
+    agentName: string | null;
+    platform: string | null;
+    lastSeenAt: string | null;
+    status: "idle" | "registered" | "polling" | "error" | "stopped";
+  };
+}
+
+export interface CloudRelayRouteState {
+  runtime?: {
+    getService(type: string): unknown;
+  };
+}
+
+export async function handleCloudRelayRoute(
+  _req: http.IncomingMessage,
+  res: http.ServerResponse,
+  pathname: string,
+  method: string,
+  state: CloudRelayRouteState,
+  helpers: RouteHelpers,
+): Promise<boolean> {
+  if (method !== "GET" || pathname !== "/api/cloud/relay-status") {
+    return false;
+  }
+
+  if (!state.runtime) {
+    helpers.json(res, {
+      available: false,
+      status: "no_runtime",
+      reason: "Runtime not initialized",
+    });
+    return true;
+  }
+
+  // Try known service names used across package boundaries.
+  const service = (state.runtime.getService("CLOUD_MANAGED_GATEWAY_RELAY") ??
+    state.runtime.getService("cloud-managed-gateway-relay") ??
+    state.runtime.getService(
+      "cloudManagedGatewayRelay",
+    )) as RelayServiceLike | null;
+
+  if (!service || typeof service.getSessionInfo !== "function") {
+    helpers.json(res, {
+      available: false,
+      status: "not_registered",
+      reason:
+        "Gateway relay service not active. Connect to Eliza Cloud in Settings to enable instance routing.",
+    });
+    return true;
+  }
+
+  try {
+    const info = service.getSessionInfo();
+    helpers.json(res, {
+      available: true,
+      ...info,
+    });
+  } catch (err) {
+    helpers.json(res, {
+      available: false,
+      status: "error",
+      reason: err instanceof Error ? err.message : String(err),
+    });
+  }
+
+  return true;
+}