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

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);
+}

package/src/services/cloud-auth.ts

@@ -26,6 +26,7 @@ import {
   resolveApiSecurityConfig,
   resolveDesktopApiPort,
 } from "@elizaos/core";
+import { isCloudReachable } from "@elizaos/shared";
 import { createRemoteJWKSet, jwtVerify } from "jose";
 import type { CloudCredentials, DeviceAuthResponse, DevicePlatform } from "../types/cloud";
 import { DEFAULT_CLOUD_CONFIG } from "../types/cloud";
@@ -91,7 +92,7 @@ export interface CloudSsoSession {
 export interface SsoRedirectArgs {
   /**
    * Local URL the user should land on after the SSO round-trip
-   * (e.g. `/onboarding/setup`). The dashboard's callback route forwards
+   * (e.g. `/first-run/setup`). The dashboard's callback route forwards
    * to this once the session cookie is set; it is NOT sent to the cloud
    * issuer.
    */
@@ -474,9 +475,15 @@ export class CloudAuthService extends Service {
   }
 
   private async validateApiKey(key: string): Promise<boolean> {
+    if (!(await isCloudReachable())) {
+      logger.warn(
+        "[CloudAuth] Cloud unreachable at boot — skipping API key validation; key will be used as-is"
+      );
+      return false;
+    }
     try {
       const validationClient = new CloudApiClient(this.client.getBaseUrl(), key);
-      await validationClient.get("/models", { timeoutMs: 10_000 });
+      await validationClient.get("/models", { timeoutMs: 2_500 });
       return true;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);

package/src/services/cloud-bootstrap.ts

@@ -15,7 +15,7 @@
  * trusts a default URL.
  */
 
-import { type IAgentRuntime, logger, Service } from "@elizaos/core";
+import { type IAgentRuntime, logger, type ProcessEnvLike, Service } from "@elizaos/core";
 
 export interface CloudBootstrapService {
   /** Returns `${ELIZA_CLOUD_ISSUER}/.well-known/jwks.json`. */
@@ -28,8 +28,6 @@ export interface CloudBootstrapService {
   getExpectedContainerId(): string | null;
 }
 
-type ProcessEnvLike = Record<string, string | undefined>;
-
 function readEnv(): ProcessEnvLike {
   if (typeof process === "undefined") {
     return {};

package/src/services/cloud-bridge.ts

@@ -182,7 +182,7 @@ export class CloudBridgeService extends Service {
       }
     });
 
-    ws.addEventListener("close", (event: CloseEvent) => {
+    ws.addEventListener("close", (event) => {
       conn.state = "disconnected";
       if (conn.heartbeatTimer) clearInterval(conn.heartbeatTimer);
 

package/src/services/cloud-container.ts

@@ -15,6 +15,12 @@ import type {
   ContainerListResponse,
   CreateContainerRequest,
   CreateContainerResponse,
+  PromoteVfsToCloudContainerRequest,
+  PromoteVfsToCloudContainerResponse,
+  RequestCodingAgentContainerRequest,
+  RequestCodingAgentContainerResponse,
+  SyncCloudCodingContainerRequest,
+  SyncCloudCodingContainerResponse,
 } from "../types/cloud";
 import { DEFAULT_CLOUD_CONFIG } from "../types/cloud";
 import type { CloudApiClient } from "../utils/cloud-api";
@@ -277,6 +283,75 @@ export class CloudContainerService extends Service {
     return client.get<ContainerHealthResponse>(`/containers/${containerId}/health`);
   }
 
+  // ─── Coding Containers / VFS Promotion ────────────────────────────────
+
+  async promoteVfsToCloudContainer(
+    request: PromoteVfsToCloudContainerRequest,
+  ): Promise<PromoteVfsToCloudContainerResponse> {
+    if (!this.isAuthenticated()) {
+      throw cloudCodingUnavailable("Cloud auth is not connected");
+    }
+
+    try {
+      return await this.getClient().post<PromoteVfsToCloudContainerResponse>(
+        "/coding-containers/promotions",
+        request,
+      );
+    } catch (error) {
+      if (isMissingCloudCodingEndpoint(error)) {
+        throw cloudCodingUnavailable(
+          "Eliza Cloud coding-container promotion endpoint is not deployed yet",
+        );
+      }
+      throw error;
+    }
+  }
+
+  async requestCodingAgentContainer(
+    request: RequestCodingAgentContainerRequest,
+  ): Promise<RequestCodingAgentContainerResponse> {
+    if (!this.isAuthenticated()) {
+      throw cloudCodingUnavailable("Cloud auth is not connected");
+    }
+
+    try {
+      return await this.getClient().post<RequestCodingAgentContainerResponse>(
+        "/coding-containers",
+        request,
+      );
+    } catch (error) {
+      if (isMissingCloudCodingEndpoint(error)) {
+        throw cloudCodingUnavailable(
+          "Eliza Cloud coding-container endpoint is not deployed yet",
+        );
+      }
+      throw error;
+    }
+  }
+
+  async syncCodingContainerChanges(
+    containerId: string,
+    request: SyncCloudCodingContainerRequest,
+  ): Promise<SyncCloudCodingContainerResponse> {
+    if (!this.isAuthenticated()) {
+      throw cloudCodingUnavailable("Cloud auth is not connected");
+    }
+
+    try {
+      return await this.getClient().post<SyncCloudCodingContainerResponse>(
+        `/coding-containers/${encodeURIComponent(containerId)}/sync`,
+        request,
+      );
+    } catch (error) {
+      if (isMissingCloudCodingEndpoint(error)) {
+        throw cloudCodingUnavailable(
+          "Eliza Cloud coding-container sync endpoint is not deployed yet",
+        );
+      }
+      throw error;
+    }
+  }
+
   // ─── Accessors ─────────────────────────────────────────────────────────
 
   getTrackedContainers(): CloudContainer[] {
@@ -294,4 +369,22 @@ export class CloudContainerService extends Service {
   getContainerUrl(containerId: string): string | null {
     return this.tracked.get(containerId)?.container.load_balancer_url ?? null;
   }
+
+  private isAuthenticated(): boolean {
+    return this.authService?.isAuthenticated?.() === true;
+  }
+}
+
+function isMissingCloudCodingEndpoint(error: unknown): boolean {
+  const statusCode =
+    typeof (error as { statusCode?: unknown })?.statusCode === "number"
+      ? (error as { statusCode: number }).statusCode
+      : undefined;
+  return statusCode === 404 || statusCode === 501;
+}
+
+function cloudCodingUnavailable(message: string): Error & { statusCode: number } {
+  const error = new Error(message) as Error & { statusCode: number };
+  error.statusCode = 503;
+  return error;
 }

package/src/services/cloud-credential-provider.ts

@@ -93,7 +93,7 @@ export class CloudCredentialProvider extends Service {
   }
 
   override async stop(): Promise<void> {
-    // No-op: holds no per-instance state.
+    // Holds no per-instance state.
   }
 
   async resolve(_userId: string, credType: string): Promise<CredentialProviderResult> {

package/src/services/cloud-model-registry.ts

@@ -111,7 +111,7 @@ export class CloudModelRegistryService extends Service {
     const client = auth.getClient();
 
     const response = await client.get<ModelListResponse>("/models");
-    const entries = response.data ?? [];
+    const entries: ModelListEntry[] = response.data ?? [];
 
     this.models = entries.map((entry) => ({
       id: entry.id,

package/src/types/cloud.ts

@@ -5,6 +5,28 @@
  * for containers, auth, credits, bridge messaging, and agent state snapshots.
  */
 
+export type {
+  CloudCodingAgent,
+  CloudCodingContainerSession,
+  CloudCodingContainerStatus,
+  CloudCodingPatch,
+  CloudCodingPatchFormat,
+  CloudCodingPromotion,
+  CloudCodingSyncDirection,
+  CloudCodingSyncResult,
+  CloudVfsBundle,
+  CloudVfsDeletedFile,
+  CloudVfsFile,
+  CloudVfsFileEncoding,
+  CloudVfsSourceKind,
+  PromoteVfsToCloudContainerRequest,
+  PromoteVfsToCloudContainerResponse,
+  RequestCodingAgentContainerRequest,
+  RequestCodingAgentContainerResponse,
+  SyncCloudCodingContainerRequest,
+  SyncCloudCodingContainerResponse,
+} from "@elizaos/shared";
+
 // ─── Container Types ────────────────────────────────────────────────────────
 
 export type ContainerStatus =

package/src/types/index.ts

@@ -43,9 +43,22 @@ export type {
   BridgeMessage,
   BridgeMessageHandler,
   CloudApiErrorBody,
+  CloudCodingAgent,
+  CloudCodingContainerSession,
+  CloudCodingContainerStatus,
+  CloudCodingPatch,
+  CloudCodingPatchFormat,
+  CloudCodingPromotion,
+  CloudCodingSyncDirection,
+  CloudCodingSyncResult,
   CloudContainer,
   CloudCredentials,
   CloudPluginConfig,
+  CloudVfsBundle,
+  CloudVfsDeletedFile,
+  CloudVfsFile,
+  CloudVfsFileEncoding,
+  CloudVfsSourceKind,
   ContainerArchitecture,
   ContainerBillingStatus,
   ContainerDeleteResponse,
@@ -69,11 +82,17 @@ export type {
   GatewayRelaySession,
   InferenceMode,
   PollGatewayRelayResponse,
+  PromoteVfsToCloudContainerRequest,
+  PromoteVfsToCloudContainerResponse,
   RegisterGatewayRelaySessionResponse,
+  RequestCodingAgentContainerRequest,
+  RequestCodingAgentContainerResponse,
   RestoreSnapshotRequest,
   RestoreSnapshotResponse,
   SnapshotListResponse,
   SnapshotType,
+  SyncCloudCodingContainerRequest,
+  SyncCloudCodingContainerResponse,
 } from "./cloud";
 
 export {

package/src/utils/cloud-sdk/client.ts

@@ -95,7 +95,45 @@ function normalizeBaseUrl(value: string | undefined, fallback: string): string {
 }
 
 function apiOriginFromApiBaseUrl(value: string): string {
-  return value.replace(/\/api\/v1\/?$/, "");
+  return new URL(value).origin;
+}
+
+function normalizeCloudApiBaseUrl(value: string | undefined, fallback: string): string {
+  const baseUrl = normalizeBaseUrl(value, fallback);
+  let url: URL;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    throw new Error(`Invalid Eliza Cloud API base URL: ${baseUrl}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Invalid Eliza Cloud API base URL protocol: ${baseUrl}`);
+  }
+  if (url.search || url.hash) {
+    throw new Error(`Eliza Cloud API base URL must not include query or hash: ${baseUrl}`);
+  }
+
+  const pathname = trimTrailingSlash(url.pathname);
+  if (!pathname || pathname === "/") {
+    url.pathname = "/api/v1";
+  } else if (pathname === "/api/v1") {
+    url.pathname = "/api/v1";
+  } else {
+    throw new Error(`Eliza Cloud API base URL must be an origin or end at /api/v1: ${baseUrl}`);
+  }
+  return trimTrailingSlash(url.toString());
+}
+
+function browserBaseUrlForCliLogin(baseUrl: string): string {
+  try {
+    const url = new URL(baseUrl);
+    if (url.hostname.toLowerCase() === "api.elizacloud.ai") {
+      return DEFAULT_ELIZA_CLOUD_BASE_URL;
+    }
+  } catch {
+    // Fall through to the configured base URL.
+  }
+  return baseUrl;
 }
 
 function encodePathParam(value: string | number): string {
@@ -129,7 +167,7 @@ export class ElizaCloudClient {
 
   constructor(options: ElizaCloudClientOptions = {}) {
     this.baseUrl = normalizeBaseUrl(options.baseUrl, DEFAULT_ELIZA_CLOUD_BASE_URL);
-    this.apiBaseUrl = normalizeBaseUrl(
+    this.apiBaseUrl = normalizeCloudApiBaseUrl(
       options.apiBaseUrl,
       options.baseUrl ? `${this.baseUrl}/api/v1` : DEFAULT_ELIZA_CLOUD_API_BASE_URL,
     );
@@ -192,7 +230,8 @@ export class ElizaCloudClient {
   startCliLogin(options: CliLoginStartOptions = {}): Promise<CliLoginStartResponse> {
     const sessionId = options.sessionId ?? getCryptoRandomUuid();
     const query = options.returnTo ? `?returnTo=${encodeURIComponent(options.returnTo)}` : "";
-    const browserUrl = `${this.baseUrl}/auth/cli-login?session=${encodeURIComponent(
+    const browserBaseUrl = browserBaseUrlForCliLogin(this.baseUrl);
+    const browserUrl = `${browserBaseUrl}/auth/cli-login?session=${encodeURIComponent(
       sessionId,
     )}${query}`;