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

package/src/routes/cloud-coding-container-routes.ts

@@ -0,0 +1,198 @@
+import type http from "node:http";
+import {
+  PromoteVfsToCloudContainerRequestSchema,
+  RequestCodingAgentContainerRequestSchema,
+  SyncCloudCodingContainerRequestSchema,
+} from "@elizaos/shared";
+import type {
+  PromoteVfsToCloudContainerRequest,
+  PromoteVfsToCloudContainerResponse,
+  RequestCodingAgentContainerRequest,
+  RequestCodingAgentContainerResponse,
+  SyncCloudCodingContainerRequest,
+  SyncCloudCodingContainerResponse,
+} from "../types/cloud";
+import { sendJson, sendJsonError } from "../lib/http";
+
+export interface CloudCodingContainerRouteState {
+  runtime: {
+    getService?: (name: string) => unknown;
+  } | null;
+}
+
+interface CodingContainerServiceLike {
+  promoteVfsToCloudContainer(
+    request: PromoteVfsToCloudContainerRequest,
+  ): Promise<PromoteVfsToCloudContainerResponse>;
+  requestCodingAgentContainer(
+    request: RequestCodingAgentContainerRequest,
+  ): Promise<RequestCodingAgentContainerResponse>;
+  syncCodingContainerChanges(
+    containerId: string,
+    request: SyncCloudCodingContainerRequest,
+  ): Promise<SyncCloudCodingContainerResponse>;
+}
+
+export async function handleCloudCodingContainerRoute(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  pathname: string,
+  method: string,
+  state: CloudCodingContainerRouteState,
+): Promise<boolean> {
+  if (
+    method === "POST" &&
+    pathname === "/api/cloud/coding-containers/promotions"
+  ) {
+    const service = getCloudContainerService(state);
+    if (!service) {
+      sendJsonError(res, "Cloud container service is not available", 503);
+      return true;
+    }
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const parsed = PromoteVfsToCloudContainerRequestSchema.safeParse(body);
+    if (!parsed.success) {
+      sendJsonError(
+        res,
+        parsed.error.issues[0]?.message ?? "Invalid promotion request",
+        400,
+      );
+      return true;
+    }
+    await sendServiceResponse(res, () =>
+      service.promoteVfsToCloudContainer(
+        parsed.data as PromoteVfsToCloudContainerRequest,
+      ),
+    );
+    return true;
+  }
+
+  if (method === "POST" && pathname === "/api/cloud/coding-containers") {
+    const service = getCloudContainerService(state);
+    if (!service) {
+      sendJsonError(res, "Cloud container service is not available", 503);
+      return true;
+    }
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const parsed = RequestCodingAgentContainerRequestSchema.safeParse(body);
+    if (!parsed.success) {
+      sendJsonError(
+        res,
+        parsed.error.issues[0]?.message ?? "Invalid coding container request",
+        400,
+      );
+      return true;
+    }
+    await sendServiceResponse(res, () =>
+      service.requestCodingAgentContainer(
+        parsed.data as RequestCodingAgentContainerRequest,
+      ),
+    );
+    return true;
+  }
+
+  const syncMatch = /^\/api\/cloud\/coding-containers\/([^/]+)\/sync$/.exec(
+    pathname,
+  );
+  if (method === "POST" && syncMatch) {
+    const service = getCloudContainerService(state);
+    if (!service) {
+      sendJsonError(res, "Cloud container service is not available", 503);
+      return true;
+    }
+    const containerId = decodeURIComponent(syncMatch[1]);
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const parsed = SyncCloudCodingContainerRequestSchema.safeParse(body);
+    if (!parsed.success) {
+      sendJsonError(
+        res,
+        parsed.error.issues[0]?.message ?? "Invalid sync request",
+        400,
+      );
+      return true;
+    }
+    await sendServiceResponse(res, () =>
+      service.syncCodingContainerChanges(
+        containerId,
+        parsed.data as SyncCloudCodingContainerRequest,
+      ),
+    );
+    return true;
+  }
+
+  return false;
+}
+
+function getCloudContainerService(
+  state: CloudCodingContainerRouteState,
+): CodingContainerServiceLike | null {
+  const service =
+    state.runtime?.getService?.("CLOUD_CONTAINER") ??
+    state.runtime?.getService?.("cloud-container") ??
+    state.runtime?.getService?.("cloudContainer");
+  if (!service || typeof service !== "object") return null;
+  const candidate = service as Partial<CodingContainerServiceLike>;
+  if (
+    typeof candidate.promoteVfsToCloudContainer === "function" &&
+    typeof candidate.requestCodingAgentContainer === "function" &&
+    typeof candidate.syncCodingContainerChanges === "function"
+  ) {
+    return candidate as CodingContainerServiceLike;
+  }
+  return null;
+}
+
+async function readJsonBody(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+): Promise<Record<string, unknown> | null> {
+  const preParsed = (req as http.IncomingMessage & { body?: unknown }).body;
+  if (
+    preParsed &&
+    typeof preParsed === "object" &&
+    !Array.isArray(preParsed)
+  ) {
+    return preParsed as Record<string, unknown>;
+  }
+
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw) as unknown;
+  } catch {
+    sendJsonError(res, "Invalid JSON body", 400);
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    sendJsonError(res, "Invalid JSON body", 400);
+    return null;
+  }
+  return parsed as Record<string, unknown>;
+}
+
+async function sendServiceResponse(
+  res: http.ServerResponse,
+  fn: () => Promise<unknown>,
+): Promise<void> {
+  try {
+    sendJson(res, await fn());
+  } catch (error) {
+    const status =
+      typeof (error as { statusCode?: unknown })?.statusCode === "number"
+        ? (error as { statusCode: number }).statusCode
+        : 500;
+    sendJsonError(
+      res,
+      error instanceof Error ? error.message : String(error),
+      status,
+    );
+  }
+}

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

@@ -0,0 +1,304 @@
+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 {
+  type CloudAuthApiKeyService,
+  normalizeCloudApiKey,
+} from "../cloud/auth-service-types";
+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;
+
+export function resolveCloudBaseUrl(config: CloudProxyConfigLike): string {
+  return normalizeCloudSiteUrl(config.cloud?.baseUrl);
+}
+
+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/plugin-personal-assistant/routes/cloud-features-routes";
+
+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())
+  );
+}