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

package/dist/onboarding.js

@@ -0,0 +1,883 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cloud/base-url.ts
+function isLoopbackHost(hostname) {
+  const normalized = hostname.toLowerCase();
+  return normalized === "localhost" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1" || normalized.startsWith("127.");
+}
+function trimApiPath(pathname) {
+  const normalized = pathname.trim().replace(/\/+$/, "");
+  if (!normalized)
+    return "";
+  if (normalized === "/api/v1")
+    return "";
+  if (normalized.endsWith("/api/v1")) {
+    return normalized.slice(0, -"/api/v1".length);
+  }
+  return normalized;
+}
+function normalizeCloudSiteUrl(rawUrl) {
+  const envOverride = process.env.ELIZAOS_CLOUD_BASE_URL?.trim();
+  const candidate = envOverride || rawUrl?.trim() || DEFAULT_CLOUD_SITE_URL;
+  try {
+    const parsed = new URL(candidate);
+    const pathname = trimApiPath(parsed.pathname);
+    const host = parsed.hostname.toLowerCase();
+    const preserveLocalOrigin = isLoopbackHost(host);
+    parsed.hash = "";
+    parsed.search = "";
+    if (!preserveLocalOrigin) {
+      parsed.protocol = "https:";
+      parsed.port = "";
+    }
+    parsed.pathname = pathname;
+    if (LEGACY_CLOUD_HOST_ALIASES.has(host)) {
+      parsed.hostname = "www.elizacloud.ai";
+      parsed.pathname = "";
+    }
+    return parsed.toString().replace(/\/{1,1024}$/, "");
+  } catch {
+    const safeCandidate = candidate.length > 8192 ? candidate.slice(0, 8192) : candidate;
+    return safeCandidate.replace(/\/{1,1024}$/, "");
+  }
+}
+function resolveCloudApiBaseUrl(rawUrl) {
+  return `${normalizeCloudSiteUrl(rawUrl)}/api/v1`;
+}
+var DEFAULT_CLOUD_SITE_URL = "https://www.elizacloud.ai", LEGACY_CLOUD_HOST_ALIASES;
+var init_base_url = __esm(() => {
+  LEGACY_CLOUD_HOST_ALIASES = new Set([
+    "elizacloud.ai",
+    "www.elizacloud.ai"
+  ]);
+});
+
+// src/cloud/validate-url.ts
+import dns from "node:dns";
+import net from "node:net";
+import { promisify } from "node:util";
+function normalizeHostLike(value) {
+  return value.trim().toLowerCase().replace(/^\[|\]$/g, "");
+}
+function decodeIpv6MappedHex(mapped) {
+  const parts = mapped.split(":");
+  if (parts.length < 1 || parts.length > 2)
+    return null;
+  const parsed = parts.map((part) => {
+    if (!/^[0-9a-f]{1,4}$/i.test(part))
+      return Number.NaN;
+    return Number.parseInt(part, 16);
+  });
+  if (parsed.some((value) => !Number.isFinite(value)))
+    return null;
+  const [hi, lo] = parsed.length === 1 ? [0, parsed[0]] : parsed;
+  const octets = [hi >> 8, hi & 255, lo >> 8, lo & 255];
+  return octets.join(".");
+}
+function canonicalizeIpv6(ip) {
+  try {
+    return new URL(`http://[${ip}]/`).hostname.replace(/^\[|\]$/g, "");
+  } catch {
+    return null;
+  }
+}
+function normalizeIpForPolicy(ip) {
+  const base = normalizeHostLike(ip).split("%")[0];
+  if (!base)
+    return base;
+  let normalized = base;
+  if (net.isIP(normalized) === 6) {
+    normalized = canonicalizeIpv6(normalized) ?? normalized;
+  }
+  let mapped = null;
+  if (normalized.startsWith("::ffff:")) {
+    mapped = normalized.slice("::ffff:".length);
+  } else if (normalized.startsWith("0:0:0:0:0:ffff:")) {
+    mapped = normalized.slice("0:0:0:0:0:ffff:".length);
+  }
+  if (!mapped)
+    return normalized;
+  if (net.isIP(mapped) === 4)
+    return mapped;
+  return decodeIpv6MappedHex(mapped) ?? normalized;
+}
+function cidrV4(base, prefix) {
+  const parsed = parseIpv4ToInt(base);
+  if (parsed === null) {
+    throw new Error(`Invalid CIDR base IPv4 address: ${base}`);
+  }
+  const shift = 32 - prefix;
+  const mask = shift === 32 ? 0 : 4294967295 << shift >>> 0;
+  return { base: parsed & mask, mask };
+}
+function parseIpv4ToInt(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4)
+    return null;
+  let value = 0;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part))
+      return null;
+    const octet = Number.parseInt(part, 10);
+    if (!Number.isInteger(octet) || octet < 0 || octet > 255)
+      return null;
+    value = value << 8 | octet;
+  }
+  return value >>> 0;
+}
+function isBlockedIpv4(ip) {
+  const asInt = parseIpv4ToInt(ip);
+  if (asInt === null)
+    return true;
+  return BLOCKED_IPV4_CIDRS.some((cidr) => (asInt & cidr.mask) === cidr.base);
+}
+function isBlockedIpv6(ip) {
+  const normalized = ip.toLowerCase();
+  return normalized === "::" || normalized === "::1" || /^fe[89ab][0-9a-f]:/.test(normalized) || /^f[cd][0-9a-f]{2}:/i.test(normalized) || normalized.startsWith("ff");
+}
+function isBlockedIp(ip) {
+  const normalized = normalizeIpForPolicy(ip);
+  const family = net.isIP(normalized);
+  if (family === 4)
+    return isBlockedIpv4(normalized);
+  if (family === 6)
+    return isBlockedIpv6(normalized);
+  return false;
+}
+async function validateCloudBaseUrl(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    return `Invalid cloud base URL: "${rawUrl}"`;
+  }
+  if (parsed.protocol !== "https:") {
+    return `Cloud base URL must use HTTPS, got "${parsed.protocol}" in "${rawUrl}"`;
+  }
+  const hostname = normalizeHostLike(parsed.hostname);
+  if (!hostname) {
+    return `Invalid cloud base URL: "${rawUrl}"`;
+  }
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local")) {
+    return `Cloud base URL "${rawUrl}" points to a blocked local hostname.`;
+  }
+  if (true) {
+    return null;
+  }
+  if (isBlockedIp(hostname)) {
+    return `Cloud base URL "${rawUrl}" points to a blocked address.`;
+  }
+  try {
+    const results = await dnsLookupAll(hostname, { all: true });
+    const addresses = Array.isArray(results) ? results : [results];
+    for (const entry of addresses) {
+      const ip = typeof entry === "string" ? entry : entry.address;
+      if (isBlockedIp(ip)) {
+        return `Cloud base URL "${rawUrl}" resolves to ${ip}, ` + "which is a blocked internal/metadata address.";
+      }
+    }
+  } catch {
+    return `Cloud base URL "${rawUrl}" could not be resolved via DNS.`;
+  }
+  return null;
+}
+var dnsLookupAll, BLOCKED_IPV4_CIDRS;
+var init_validate_url = __esm(() => {
+  dnsLookupAll = promisify(dns.lookup);
+  BLOCKED_IPV4_CIDRS = [
+    cidrV4("0.0.0.0", 8),
+    cidrV4("10.0.0.0", 8),
+    cidrV4("172.16.0.0", 12),
+    cidrV4("192.168.0.0", 16),
+    cidrV4("100.64.0.0", 10),
+    cidrV4("127.0.0.0", 8),
+    cidrV4("169.254.0.0", 16),
+    cidrV4("192.0.0.0", 24),
+    cidrV4("198.18.0.0", 15),
+    cidrV4("192.0.2.0", 24),
+    cidrV4("198.51.100.0", 24),
+    cidrV4("203.0.113.0", 24),
+    cidrV4("224.0.0.0", 4),
+    cidrV4("240.0.0.0", 4)
+  ];
+});
+
+// src/cloud/auth.ts
+init_base_url();
+init_validate_url();
+import crypto2 from "node:crypto";
+import { logger } from "@elizaos/core";
+var DEFAULT_CLOUD_REQUEST_TIMEOUT_MS = 1e4;
+function isRedirectResponse(response) {
+  return response.status >= 300 && response.status < 400;
+}
+function isTimeoutError(err) {
+  if (!(err instanceof Error))
+    return false;
+  if (err.name === "TimeoutError" || err.name === "AbortError")
+    return true;
+  const msg = err.message.toLowerCase();
+  return msg.includes("timed out") || msg.includes("timeout");
+}
+async function fetchWithTimeout(input, init, timeoutMs) {
+  return fetch(input, {
+    ...init,
+    redirect: "manual",
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+}
+async function cloudLogin(options = {}) {
+  const baseUrl = normalizeCloudSiteUrl(options.baseUrl);
+  const urlError = await validateCloudBaseUrl(baseUrl);
+  if (urlError) {
+    throw new Error(urlError);
+  }
+  const timeoutMs = options.timeoutMs ?? 300000;
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_CLOUD_REQUEST_TIMEOUT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? 2000;
+  const sessionId = crypto2.randomUUID();
+  logger.info("[cloud-auth] Creating auth session...");
+  let createResponse;
+  try {
+    createResponse = await fetchWithTimeout(`${baseUrl}/api/auth/cli-session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sessionId })
+    }, requestTimeoutMs);
+  } catch (err) {
+    if (isTimeoutError(err)) {
+      throw new Error(`Cloud login request timed out while creating session (>${requestTimeoutMs}ms).`);
+    }
+    throw new Error(`Failed to create auth session: ${String(err)}`);
+  }
+  if (!createResponse.ok) {
+    if (isRedirectResponse(createResponse)) {
+      throw new Error("Cloud login request was redirected; redirects are not allowed.");
+    }
+    const errorText = await createResponse.text();
+    throw new Error(`Failed to create auth session (HTTP ${createResponse.status}): ${errorText}`);
+  }
+  const browserUrl = `${baseUrl}/auth/cli-login?session=${encodeURIComponent(sessionId)}`;
+  logger.info(`[cloud-auth] Browser URL: ${browserUrl}`);
+  options.onBrowserUrl?.(browserUrl);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const remainingBeforeSleep = deadline - Date.now();
+    if (remainingBeforeSleep <= 0)
+      break;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remainingBeforeSleep)));
+    const remaining = deadline - Date.now();
+    if (remaining <= 0)
+      break;
+    let pollResponse;
+    try {
+      pollResponse = await fetchWithTimeout(`${baseUrl}/api/auth/cli-session/${encodeURIComponent(sessionId)}`, {}, Math.min(requestTimeoutMs, remaining));
+    } catch (err) {
+      if (isTimeoutError(err)) {
+        if (remaining <= requestTimeoutMs) {
+          break;
+        }
+        throw new Error(`Cloud login polling request timed out (>${Math.min(requestTimeoutMs, remaining)}ms).`);
+      }
+      throw new Error(`Cloud login polling failed: ${String(err)}`);
+    }
+    if (!pollResponse.ok) {
+      if (isRedirectResponse(pollResponse)) {
+        throw new Error("Cloud login polling request was redirected; redirects are not allowed.");
+      }
+      if (pollResponse.status === 404) {
+        throw new Error("Auth session expired or not found. Please try again.");
+      }
+      options.onPollStatus?.("error");
+      continue;
+    }
+    const data = await pollResponse.json();
+    options.onPollStatus?.(data.status);
+    if (data.status === "authenticated" && data.apiKey) {
+      logger.info("[cloud-auth] Authentication complete");
+      return {
+        apiKey: data.apiKey,
+        keyPrefix: data.keyPrefix ?? "",
+        expiresAt: data.expiresAt ?? null
+      };
+    }
+    if (data.status === "authenticated" && !data.apiKey) {
+      throw new Error("Auth session was completed but the API key was already retrieved. Please try logging in again.");
+    }
+  }
+  throw new Error(`Cloud login timed out. The browser login was not completed within ${Math.round(timeoutMs / 1000)} seconds.`);
+}
+
+// src/cloud/bridge-client.ts
+init_base_url();
+
+class CloudBridgeError extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "CloudBridgeError";
+  }
+}
+
+class SignatureInvalidError extends CloudBridgeError {
+  constructor(message, body) {
+    super(message, 401, body);
+    this.name = "SignatureInvalidError";
+  }
+}
+
+class NonceReplayError extends CloudBridgeError {
+  constructor(message, body) {
+    super(message, 409, body);
+    this.name = "NonceReplayError";
+  }
+}
+
+class SessionExpiredError extends CloudBridgeError {
+  constructor(message, body) {
+    super(message, 410, body);
+    this.name = "SessionExpiredError";
+  }
+}
+
+class CloudUnavailableError extends CloudBridgeError {
+  constructor(message, status, body) {
+    super(message, status, body);
+    this.name = "CloudUnavailableError";
+  }
+}
+function formatApiErrorBody(text) {
+  if (!text)
+    return null;
+  try {
+    const parsed = JSON.parse(text);
+    const baseError = typeof parsed.error === "string" && parsed.error.trim().length > 0 ? parsed.error.trim() : null;
+    const details = Array.isArray(parsed.details) ? parsed.details.map((detail) => typeof detail?.message === "string" ? detail.message.trim() : "").filter((message) => message.length > 0) : [];
+    if (baseError && details.length > 0) {
+      return `${baseError}: ${details.join("; ")}`;
+    }
+    if (baseError)
+      return baseError;
+  } catch {}
+  return text.slice(0, 200) || null;
+}
+function isRedirectResponse2(response) {
+  return response.status >= 300 && response.status < 400;
+}
+function normalizeChainAddress(addresses, chain) {
+  const value = addresses?.[chain];
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function looksLikeChainAddress(address, chain) {
+  if (chain === "evm") {
+    return /^0x[a-fA-F0-9]{40}$/.test(address);
+  }
+  return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
+}
+function resolveRequestedWalletAddress(data, chain) {
+  const explicit = normalizeChainAddress(data.walletAddresses, chain);
+  if (explicit)
+    return explicit;
+  if (typeof data.walletAddress !== "string")
+    return null;
+  const trimmed = data.walletAddress.trim();
+  if (!trimmed)
+    return null;
+  return looksLikeChainAddress(trimmed, chain) ? trimmed : null;
+}
+
+class ElizaCloudClient {
+  baseUrl;
+  apiKey;
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = normalizeCloudSiteUrl(baseUrl);
+    this.apiKey = apiKey;
+  }
+  async listAgents() {
+    const res = await this.request("GET", "/api/v1/eliza/agents");
+    return res.data ?? [];
+  }
+  async createAgent(params) {
+    const res = await this.request("POST", "/api/v1/eliza/agents", params);
+    if (!res.success || !res.data)
+      throw new Error(res.error ?? "Failed to create cloud agent");
+    return res.data;
+  }
+  async getAgent(agentId) {
+    const res = await this.request("GET", `/api/v1/eliza/agents/${agentId}`);
+    if (!res.success || !res.data)
+      throw new Error(res.error ?? "Agent not found");
+    return res.data;
+  }
+  async deleteAgent(agentId) {
+    const res = await this.request("DELETE", `/api/v1/eliza/agents/${agentId}`);
+    if (!res.success)
+      throw new Error(res.error ?? "Failed to delete agent");
+  }
+  async provision(agentId) {
+    const res = await this.request("POST", `/api/v1/eliza/agents/${agentId}/provision`);
+    if (!res.success || !res.data)
+      throw new Error(res.error ?? "Failed to provision sandbox");
+    return res.data;
+  }
+  async sendMessage(agentId, text, roomId = "web-chat", channelType = "DM") {
+    const url = `${this.baseUrl}/api/v1/eliza/agents/${agentId}/bridge`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Api-Key": this.apiKey },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: crypto.randomUUID(),
+        method: "message.send",
+        params: { text, roomId, channelType }
+      }),
+      redirect: "manual",
+      signal: AbortSignal.timeout(60000)
+    });
+    if (isRedirectResponse2(response)) {
+      throw new Error("Bridge request was redirected; redirects are not allowed");
+    }
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      throw new Error(`Bridge request failed: HTTP ${response.status} ${errorText.slice(0, 200)}`);
+    }
+    const rpc = await response.json();
+    if (rpc.error)
+      throw new Error(rpc.error.message);
+    return rpc.result?.text ?? "(no response)";
+  }
+  async* sendMessageStream(agentId, text, roomId = "web-chat", channelType = "DM") {
+    const url = `${this.baseUrl}/api/v1/eliza/agents/${agentId}/stream`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Api-Key": this.apiKey },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: crypto.randomUUID(),
+        method: "message.send",
+        params: { text, roomId, channelType }
+      }),
+      redirect: "manual"
+    });
+    if (isRedirectResponse2(response)) {
+      throw new Error("Stream request was redirected; redirects are not allowed");
+    }
+    if (!response.ok || !response.body) {
+      throw new Error(`Stream request failed: HTTP ${response.status}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split(`
+
+`);
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        if (!part.trim())
+          continue;
+        let eventType = "message";
+        let eventData = "";
+        for (const line of part.split(`
+`)) {
+          if (line.startsWith("event: "))
+            eventType = line.slice(7).trim();
+          else if (line.startsWith("data: "))
+            eventData += (eventData ? `
+` : "") + line.slice(6);
+        }
+        if (eventData) {
+          let data;
+          try {
+            data = JSON.parse(eventData);
+          } catch {
+            continue;
+          }
+          yield { type: eventType, data };
+        }
+      }
+    }
+  }
+  async snapshot(agentId) {
+    const res = await this.request("POST", `/api/v1/eliza/agents/${agentId}/snapshot`);
+    if (!res.success || !res.data)
+      throw new Error(res.error ?? "Snapshot failed");
+    return res.data;
+  }
+  async listBackups(agentId) {
+    const res = await this.request("GET", `/api/v1/eliza/agents/${agentId}/backups`);
+    return res.data ?? [];
+  }
+  async restore(agentId, backupId) {
+    const res = await this.request("POST", `/api/v1/eliza/agents/${agentId}/restore`, backupId ? { backupId } : {});
+    if (!res.success)
+      throw new Error(res.error ?? "Restore failed");
+  }
+  async heartbeat(agentId) {
+    const url = `${this.baseUrl}/api/v1/eliza/agents/${agentId}/bridge`;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Api-Key": this.apiKey
+        },
+        body: JSON.stringify({ jsonrpc: "2.0", method: "heartbeat" }),
+        redirect: "manual",
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (isRedirectResponse2(response))
+        return false;
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async getAgentWallet(agentId, chain) {
+    const res = await this.request("GET", `/api/v1/eliza/agents/${encodeURIComponent(agentId)}/wallet?chain=${encodeURIComponent(chain)}`);
+    if (!res.success || !res.data) {
+      throw new CloudBridgeError(res.error ?? "Failed to fetch agent wallet");
+    }
+    const data = res.data;
+    const walletAddress = resolveRequestedWalletAddress(data, chain);
+    if (!walletAddress || !data.walletProvider) {
+      throw new CloudBridgeError(`Agent has no cloud ${chain} wallet provisioned`);
+    }
+    return {
+      agentWalletId: data.agentId ?? agentId,
+      walletAddress,
+      walletProvider: data.walletProvider,
+      chainType: chain,
+      balance: data.balance ?? undefined
+    };
+  }
+  async provisionWallet(input) {
+    const res = await this.request("POST", "/api/v1/user/wallets/provision", input);
+    if (!res.success || !res.data) {
+      throw new CloudBridgeError(res.error ?? "Failed to provision wallet");
+    }
+    return {
+      walletId: res.data.id,
+      address: res.data.address,
+      chainType: res.data.chainType,
+      provider: res.data.provider ?? "privy"
+    };
+  }
+  async executeRpc(envelope) {
+    const { correlationId, ...body } = envelope;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (correlationId) {
+      headers["X-Correlation-Id"] = correlationId;
+    }
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/api/v1/user/wallets/rpc`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        redirect: "manual",
+        signal: AbortSignal.timeout(60000)
+      });
+    } catch (err) {
+      throw new CloudUnavailableError(`Cloud RPC network error: ${err.message}`, 0);
+    }
+    if (isRedirectResponse2(response)) {
+      throw new CloudBridgeError("Cloud RPC request was redirected; redirects are not allowed", response.status);
+    }
+    const text = await response.text().catch(() => "");
+    if (response.ok) {
+      try {
+        const parsed = JSON.parse(text);
+        if (!parsed.success || parsed.data === undefined) {
+          throw new CloudBridgeError(parsed.error ?? "Cloud RPC returned no data", response.status, text);
+        }
+        return parsed.data;
+      } catch (err) {
+        if (err instanceof CloudBridgeError)
+          throw err;
+        throw new CloudBridgeError(`Cloud RPC returned malformed JSON: ${err.message}`, response.status, text);
+      }
+    }
+    let errMessage = `HTTP ${response.status}`;
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed.error)
+        errMessage = parsed.error;
+    } catch {
+      if (text)
+        errMessage = text.slice(0, 200);
+    }
+    if (response.status === 401) {
+      throw new SignatureInvalidError(errMessage, text);
+    }
+    if (response.status === 409) {
+      throw new NonceReplayError(errMessage, text);
+    }
+    if (response.status === 410) {
+      throw new SessionExpiredError(errMessage, text);
+    }
+    if (response.status >= 500) {
+      throw new CloudUnavailableError(errMessage, response.status, text);
+    }
+    throw new CloudBridgeError(errMessage, response.status, text);
+  }
+  async request(method, path, body) {
+    const headers = { "X-Api-Key": this.apiKey };
+    if (body !== undefined)
+      headers["Content-Type"] = "application/json";
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+      redirect: "manual",
+      signal: AbortSignal.timeout(30000)
+    });
+    if (isRedirectResponse2(response)) {
+      return {
+        success: false,
+        error: "Cloud API request was redirected; redirects are not allowed"
+      };
+    }
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      return {
+        success: false,
+        error: formatApiErrorBody(text) ?? `HTTP ${response.status}`
+      };
+    }
+    return await response.json();
+  }
+}
+
+// src/onboarding.ts
+import { logger as logger2 } from "@elizaos/core";
+init_base_url();
+var DEFAULT_CLOUD_BASE_URL = "https://www.elizacloud.ai";
+var PROVISION_TIMEOUT_MS = 120000;
+var PROVISION_POLL_INTERVAL_MS = 3000;
+async function checkCloudAvailability(baseUrl) {
+  try {
+    const url = `${normalizeCloudSiteUrl(baseUrl)}/api/compat/availability`;
+    const res = await fetch(url, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      return `Cloud returned HTTP ${res.status}. It may be temporarily unavailable.`;
+    }
+    const body = await res.json();
+    if (!body.success || !body.data?.acceptingNewAgents) {
+      return "Eliza Cloud is currently at capacity. Try again later or run locally.";
+    }
+    return null;
+  } catch (err) {
+    const msg = String(err);
+    if (msg.includes("timed out") || msg.includes("timeout")) {
+      return "Could not reach Eliza Cloud (request timed out). Check your internet connection.";
+    }
+    return `Could not reach Eliza Cloud: ${msg}`;
+  }
+}
+async function runCloudAuth(clack, baseUrl) {
+  const spinner = clack.spinner();
+  spinner.start("Connecting to Eliza Cloud...");
+  try {
+    const result = await cloudLogin({
+      baseUrl,
+      timeoutMs: 300000,
+      onBrowserUrl: (url) => {
+        spinner.stop("Opening your browser to log in...");
+        clack.log.info(`If the browser didn't open, visit:
+  ${url}`);
+        openBrowser(url).catch(() => {});
+        spinner.start("Waiting for login in browser...");
+      },
+      onPollStatus: (status) => {
+        if (status === "pending") {
+          spinner.message("Waiting for login in browser...");
+        }
+      }
+    });
+    spinner.stop("✓ Logged in to Eliza Cloud!");
+    return result;
+  } catch (err) {
+    const msg = String(err);
+    spinner.stop(`Login failed: ${msg}`);
+    return null;
+  }
+}
+async function provisionCloudAgent(clack, client, agentName, preset) {
+  const spinner = clack.spinner();
+  spinner.start("Creating your cloud agent...");
+  try {
+    const agentConfig = {};
+    if (preset) {
+      agentConfig.bio = preset.bio;
+      agentConfig.system = preset.system;
+      agentConfig.style = preset.style;
+      agentConfig.adjectives = preset.adjectives;
+      agentConfig.topics = preset.topics;
+      agentConfig.postExamples = preset.postExamples;
+      agentConfig.messageExamples = preset.messageExamples;
+    }
+    const params = {
+      agentName,
+      agentConfig
+    };
+    const agent = await client.createAgent(params);
+    const agentId = agent.id;
+    spinner.message("Agent created! Provisioning cloud environment...");
+    const deadline = Date.now() + PROVISION_TIMEOUT_MS;
+    let lastStatus = agent.status;
+    while (Date.now() < deadline) {
+      await sleep(PROVISION_POLL_INTERVAL_MS);
+      try {
+        const current = await client.getAgent(agentId);
+        lastStatus = current.status;
+        switch (lastStatus) {
+          case "running":
+          case "completed":
+            spinner.stop(`☁️  Cloud agent "${agentName}" is running!`);
+            return { agentId, bridgeUrl: current.bridgeUrl };
+          case "failed":
+          case "error":
+            spinner.stop(`Provisioning failed: ${current.errorMessage ?? "unknown error"}`);
+            return null;
+          case "queued":
+            spinner.message("Queued — waiting for available slot...");
+            break;
+          case "provisioning":
+            spinner.message("Provisioning cloud environment...");
+            break;
+          default:
+            spinner.message(`Status: ${lastStatus}...`);
+        }
+      } catch (pollErr) {
+        logger2.debug(`[cloud-onboarding] Poll error: ${String(pollErr)}`);
+      }
+    }
+    spinner.stop(`Provisioning timed out (last status: ${lastStatus}). The agent may still be starting up.`);
+    return { agentId };
+  } catch (err) {
+    const msg = String(err);
+    spinner.stop(`Failed to create cloud agent: ${msg}`);
+    return null;
+  }
+}
+async function runCloudOnboarding(clack, agentName, preset, baseUrl) {
+  const resolvedBaseUrl = normalizeCloudSiteUrl(baseUrl ?? DEFAULT_CLOUD_BASE_URL);
+  const unavailableReason = await checkCloudAvailability(resolvedBaseUrl);
+  if (unavailableReason) {
+    clack.log.warn(unavailableReason);
+    const fallback = await clack.confirm({
+      message: "Run locally instead?",
+      initialValue: true
+    });
+    if (clack.isCancel(fallback) || fallback) {
+      return null;
+    }
+  }
+  const authResult = await runCloudAuth(clack, resolvedBaseUrl);
+  if (!authResult) {
+    clack.log.warn("Cloud login was not completed.");
+    const retry = await clack.confirm({
+      message: "Try again, or run locally?",
+      active: "Try again",
+      inactive: "Run locally",
+      initialValue: false
+    });
+    if (clack.isCancel(retry) || !retry) {
+      return null;
+    }
+    const retryResult = await runCloudAuth(clack, resolvedBaseUrl);
+    if (!retryResult) {
+      clack.log.warn("Login was not completed. Falling back to local mode.");
+      return null;
+    }
+    return await finishProvisioning(clack, resolvedBaseUrl, retryResult, agentName, preset);
+  }
+  return await finishProvisioning(clack, resolvedBaseUrl, authResult, agentName, preset);
+}
+async function finishProvisioning(clack, baseUrl, authResult, agentName, preset) {
+  const client = new ElizaCloudClient(baseUrl, authResult.apiKey);
+  const provisionResult = await provisionCloudAgent(clack, client, agentName, preset);
+  if (!provisionResult) {
+    clack.log.warn("Cloud provisioning did not complete. You can try `eliza cloud connect` later.");
+    const runLocal = await clack.confirm({
+      message: "Continue with local setup instead?",
+      initialValue: true
+    });
+    if (clack.isCancel(runLocal) || runLocal) {
+      return null;
+    }
+    return {
+      apiKey: authResult.apiKey,
+      agentId: undefined,
+      baseUrl
+    };
+  }
+  return {
+    apiKey: authResult.apiKey,
+    agentId: provisionResult.agentId,
+    baseUrl,
+    bridgeUrl: provisionResult.bridgeUrl
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function openBrowser(url) {
+  const { execFile } = await import("node:child_process");
+  const { platform } = await import("node:os");
+  const p = platform();
+  return new Promise((resolve) => {
+    const onError = (err) => {
+      if (err) {
+        logger2.debug(`[cloud-onboarding] Failed to open browser: ${err.message}`);
+      }
+      resolve();
+    };
+    if (p === "darwin") {
+      execFile("open", [url], onError);
+    } else if (p === "win32") {
+      execFile("cmd.exe", ["/c", "start", "", url], onError);
+    } else {
+      execFile("xdg-open", [url], onError);
+    }
+  });
+}
+export {
+  runCloudOnboarding,
+  checkCloudAvailability
+};
+
+//# debugId=298D6EFBB02E82E964756E2164756E21