@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/services/registry-client.js

@@ -0,0 +1,292 @@
+/**
+ * Registry Client for Eliza.
+ *
+ * Provides a 3-tier cached registry (memory → file → network) that works
+ * offline, in .app bundles, and in dev. Fetches from plugins.elizacloud.ai.
+ *
+ * @module services/registry-client
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import { loadElizaConfig, saveElizaConfig } from "../config/config.js";
+import { resolveStateDir } from "../config/paths.js";
+import { LOCAL_APP_DEFAULT_SANDBOX, resolveAppOverride, sanitizeSandbox, } from "./registry-client-app-meta.js";
+import { isDefaultEndpoint as isDefaultEndpointForUrl, mergeCustomEndpoints, normaliseEndpointUrl, parseRegistryEndpointUrl, } from "./registry-client-endpoints.js";
+import { applyLocalWorkspaceApps, applyNodeModulePlugins, } from "./registry-client-local.js";
+import { fetchFromNetwork as fetchRegistryFromNetwork, isExpectedRegistryNetworkFallback, } from "./registry-client-network.js";
+import { getPluginInfoFromRegistry, normalizePluginLookupAlias, scoreEntries, toAppEntry, toAppInfo, toPluginListItem, toSearchResults, } from "./registry-client-queries.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const GENERATED_REGISTRY_URL = "https://plugins.elizacloud.ai/generated-registry.json";
+const INDEX_REGISTRY_URL = "https://plugins.elizacloud.ai/index.json";
+const CACHE_TTL_MS = 3_600_000; // 1 hour
+// ---------------------------------------------------------------------------
+// Cache state
+// ---------------------------------------------------------------------------
+let memoryCache = null;
+let registryLoadPromise = null;
+const LOCAL_FALLBACK_CACHE_TTL_MS = 5 * 60_000;
+// ---------------------------------------------------------------------------
+// Network fetch + parse (inlined wire types — not exported)
+// ---------------------------------------------------------------------------
+async function fetchFromNetwork() {
+    try {
+        return await fetchRegistryFromNetwork({
+            generatedRegistryUrl: GENERATED_REGISTRY_URL,
+            indexRegistryUrl: INDEX_REGISTRY_URL,
+            applyLocalWorkspaceApps,
+            applyNodeModulePlugins,
+            sanitizeSandbox,
+        });
+    }
+    catch (err) {
+        if (!isExpectedRegistryNetworkFallback(err)) {
+            logger.warn(`[registry-client] generated-registry/index fallback failed: ${String(err)}`);
+        }
+        throw err;
+    }
+}
+async function buildLocalRegistrySnapshot() {
+    const plugins = new Map();
+    await applyLocalWorkspaceApps(plugins);
+    await applyNodeModulePlugins(plugins);
+    return plugins;
+}
+// ---------------------------------------------------------------------------
+// File cache
+// ---------------------------------------------------------------------------
+function cacheFilePath() {
+    return path.join(resolveStateDir(), "cache", "registry.json");
+}
+async function readFileCache() {
+    try {
+        const raw = await fs.readFile(cacheFilePath(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.fetchedAt !== "number" || !Array.isArray(parsed.plugins))
+            return null;
+        if (Date.now() - parsed.fetchedAt > CACHE_TTL_MS)
+            return null;
+        return new Map(parsed.plugins);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeFileCache(plugins) {
+    const filePath = cacheFilePath();
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify({
+        fetchedAt: Date.now(),
+        plugins: [...plugins.entries()],
+    }), "utf-8");
+}
+// ---------------------------------------------------------------------------
+// Multi-endpoint management
+// ---------------------------------------------------------------------------
+/** Return the list of custom registry endpoints from config. */
+export function getConfiguredEndpoints() {
+    try {
+        const cfg = loadElizaConfig();
+        return cfg.plugins?.registryEndpoints ?? [];
+    }
+    catch (err) {
+        logger.warn(`[registry-client] Failed to load config for custom endpoints: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+/** Add a custom registry endpoint. Blocks duplicate URLs. */
+export function addRegistryEndpoint(label, url) {
+    const parsed = parseRegistryEndpointUrl(url);
+    const normalised = normaliseEndpointUrl(parsed.toString());
+    if (isDefaultEndpoint(normalised)) {
+        throw new Error("Cannot add the default registry as a custom endpoint.");
+    }
+    const cfg = loadElizaConfig();
+    const endpoints = cfg.plugins?.registryEndpoints ?? [];
+    if (endpoints.some((ep) => normaliseEndpointUrl(ep.url) === normalised)) {
+        throw new Error(`Endpoint already exists: ${url}`);
+    }
+    if (!cfg.plugins)
+        cfg.plugins = {};
+    cfg.plugins.registryEndpoints = [
+        ...endpoints,
+        { label, url: normalised, enabled: true },
+    ];
+    saveElizaConfig(cfg);
+    memoryCache = null;
+}
+/** Remove a custom registry endpoint by URL. Cannot remove the default. */
+export function removeRegistryEndpoint(url) {
+    const normalised = normaliseEndpointUrl(url);
+    if (isDefaultEndpoint(normalised)) {
+        throw new Error("Cannot remove the default elizaOS registry.");
+    }
+    const cfg = loadElizaConfig();
+    const endpoints = cfg.plugins?.registryEndpoints ?? [];
+    const updated = endpoints.filter((ep) => normaliseEndpointUrl(ep.url) !== normalised);
+    if (updated.length === endpoints.length) {
+        throw new Error(`Endpoint not found: ${url}`);
+    }
+    if (!cfg.plugins)
+        cfg.plugins = {};
+    cfg.plugins.registryEndpoints = updated;
+    saveElizaConfig(cfg);
+    memoryCache = null;
+}
+/** Toggle an endpoint's enabled status. */
+export function toggleRegistryEndpoint(url, enabled) {
+    const normalised = normaliseEndpointUrl(url);
+    const cfg = loadElizaConfig();
+    const endpoints = cfg.plugins?.registryEndpoints ?? [];
+    const ep = endpoints.find((e) => normaliseEndpointUrl(e.url) === normalised);
+    if (!ep)
+        throw new Error(`Endpoint not found: ${url}`);
+    ep.enabled = enabled;
+    if (!cfg.plugins)
+        cfg.plugins = {};
+    cfg.plugins.registryEndpoints = endpoints;
+    saveElizaConfig(cfg);
+    memoryCache = null;
+}
+export function isDefaultEndpoint(url) {
+    return isDefaultEndpointForUrl(url, GENERATED_REGISTRY_URL);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Get all plugins. Resolution: memory → file → network. */
+export async function getRegistryPlugins() {
+    if (memoryCache &&
+        Date.now() - memoryCache.fetchedAt < (memoryCache.ttlMs ?? CACHE_TTL_MS)) {
+        return memoryCache.plugins;
+    }
+    const fromFile = await readFileCache();
+    if (fromFile) {
+        await applyLocalWorkspaceApps(fromFile);
+        await applyNodeModulePlugins(fromFile);
+        await mergeCustomEndpoints(fromFile, getConfiguredEndpoints());
+        memoryCache = { plugins: fromFile, fetchedAt: Date.now() };
+        return fromFile;
+    }
+    if (registryLoadPromise) {
+        return registryLoadPromise;
+    }
+    registryLoadPromise = (async () => {
+        logger.info("[registry-client] Fetching plugin registry...");
+        let plugins;
+        let usedLocalFallback = false;
+        try {
+            plugins = await fetchFromNetwork();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (isExpectedRegistryNetworkFallback(err)) {
+                logger.debug(`[registry-client] Remote registry unavailable; using local registry discovery: ${message}`);
+            }
+            else {
+                logger.warn(`[registry-client] Falling back to local registry discovery: ${message}`);
+            }
+            plugins = await buildLocalRegistrySnapshot();
+            usedLocalFallback = true;
+        }
+        await mergeCustomEndpoints(plugins, getConfiguredEndpoints());
+        logger.info(`[registry-client] Loaded ${plugins.size} plugins`);
+        memoryCache = {
+            plugins,
+            fetchedAt: Date.now(),
+            ttlMs: usedLocalFallback ? LOCAL_FALLBACK_CACHE_TTL_MS : CACHE_TTL_MS,
+        };
+        if (!usedLocalFallback) {
+            writeFileCache(plugins).catch((err) => logger.warn(`[registry-client] Cache write failed: ${String(err)}`));
+        }
+        return plugins;
+    })().finally(() => {
+        registryLoadPromise = null;
+    });
+    return registryLoadPromise;
+}
+/** Force-refresh from network. */
+export async function refreshRegistry() {
+    memoryCache = null;
+    try {
+        await fs.unlink(cacheFilePath());
+    }
+    catch {
+        // Missing cache files are fine; the network refresh below repopulates it.
+    }
+    return getRegistryPlugins();
+}
+/** Look up a plugin by name (exact → @elizaos/ prefix → bare suffix). */
+export async function getPluginInfo(name) {
+    const registry = await getRegistryPlugins();
+    const normalizedName = normalizePluginLookupAlias(name);
+    const candidates = Array.from(new Set([normalizedName, name]));
+    for (const candidate of candidates) {
+        const info = getPluginInfoFromRegistry(registry, candidate);
+        if (info)
+            return info;
+    }
+    return null;
+}
+/** Search plugins by query (local fuzzy match on name/description/topics). */
+export async function searchPlugins(query, limit = 15) {
+    const registry = await getRegistryPlugins();
+    const results = scoreEntries(registry.values(), query, limit);
+    return toSearchResults(results);
+}
+/** List all registered apps. */
+export async function listApps() {
+    const registry = await getRegistryPlugins();
+    const apps = [];
+    for (const p of registry.values()) {
+        const appEntry = toAppEntry(p, resolveAppOverride);
+        if (!appEntry)
+            continue;
+        apps.push(toAppInfo(appEntry, sanitizeSandbox, LOCAL_APP_DEFAULT_SANDBOX));
+    }
+    apps.sort((a, b) => b.stars - a.stars);
+    return apps;
+}
+/** Look up a specific app by name. */
+export async function getAppInfo(name) {
+    const info = await getPluginInfo(name);
+    if (!info)
+        return null;
+    const appEntry = toAppEntry(info, resolveAppOverride);
+    if (!appEntry)
+        return null;
+    return toAppInfo(appEntry, sanitizeSandbox, LOCAL_APP_DEFAULT_SANDBOX);
+}
+/** Search apps by query. */
+export async function searchApps(query, limit = 15) {
+    const registry = await getRegistryPlugins();
+    const appEntries = [];
+    for (const p of registry.values()) {
+        const appEntry = toAppEntry(p, resolveAppOverride);
+        if (appEntry)
+            appEntries.push(appEntry);
+    }
+    const results = scoreEntries(appEntries, query, limit, (p) => [p.appMeta?.displayName?.toLowerCase() ?? ""], (p) => p.appMeta?.capabilities ?? []);
+    return results.map(({ p }) => toAppInfo(p, sanitizeSandbox, LOCAL_APP_DEFAULT_SANDBOX));
+}
+/** List all non-app plugins from the registry. */
+export async function listNonAppPlugins() {
+    const registry = await getRegistryPlugins();
+    const plugins = [];
+    for (const p of registry.values()) {
+        if (p.kind !== "app") {
+            plugins.push(toPluginListItem(p));
+        }
+    }
+    plugins.sort((a, b) => b.stars - a.stars);
+    return plugins;
+}
+/** Search non-app plugins by query. */
+export async function searchNonAppPlugins(query, limit = 15) {
+    const registry = await getRegistryPlugins();
+    const pluginEntries = [...registry.values()].filter((p) => p.kind !== "app");
+    const results = scoreEntries(pluginEntries, query, limit);
+    return results.map(({ p }) => toPluginListItem(p));
+}

package/services/relationships-graph.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Agent-side wiring for the merged relationships graph in `@elizaos/core`.
+ * Import graph types and helpers from `@elizaos/core` directly.
+ */
+import type { IAgentRuntime, RelationshipsGraphService } from "@elizaos/core";
+export { type ClusterMemoriesQuery, type ClusterSearchQuery, createNativeRelationshipsGraphService, getMemoriesForCluster, type RelationshipsConversationMessage, type RelationshipsConversationSnippet, type RelationshipsFactExtractedInformation, type RelationshipsFactProvenance, type RelationshipsGraphEdge, type RelationshipsGraphQuery, type RelationshipsGraphService, type RelationshipsGraphSnapshot, type RelationshipsGraphStats, type RelationshipsIdentityEdge, type RelationshipsIdentityHandle, type RelationshipsIdentitySummary, type RelationshipsMergeCandidate, type RelationshipsPersonDetail, type RelationshipsPersonFact, type RelationshipsPersonSummary, type RelationshipsProfile, type RelationshipsRelevantMemory, type RelationshipsServiceLike, type RelationshipsUserPersonalityPreference, searchMemoriesForCluster, } from "../../../core/src/services/relationships-graph-builder.ts";
+/**
+ * Resolve the merged RelationshipsService and wire its agent-side owner
+ * resolvers. Compatibility wrapper for the old factory; prefer
+ * `runtime.getService("relationships")` directly.
+ */
+export declare function resolveRelationshipsGraphService(runtime: IAgentRuntime): Promise<RelationshipsGraphService | null>;
+//# sourceMappingURL=relationships-graph.d.ts.map

package/services/relationships-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationships-graph.d.ts","sourceRoot":"","sources":["../../src/services/relationships-graph.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,yBAAyB,EAE1B,MAAM,eAAe,CAAC;AAIvB,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,qCAAqC,EACrC,qBAAqB,EACrB,KAAK,gCAAgC,EACrC,KAAK,gCAAgC,EACrC,KAAK,qCAAqC,EAC1C,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,sCAAsC,EAC3C,wBAAwB,GACzB,MAAM,2DAA2D,CAAC;AAqCnE;;;;GAIG;AACH,wBAAsB,gCAAgC,CACpD,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC,CAwB3C"}

package/services/relationships-graph.js

@@ -0,0 +1,48 @@
+/**
+ * Agent-side wiring for the merged relationships graph in `@elizaos/core`.
+ * Import graph types and helpers from `@elizaos/core` directly.
+ */
+import { resolveOwnerEntityId } from "../runtime/owner-entity.js";
+import { fetchConfiguredOwnerName } from "./owner-name.js";
+export { createNativeRelationshipsGraphService, getMemoriesForCluster, searchMemoriesForCluster, } from "../../../core/src/services/relationships-graph-builder.js";
+/** Methods the {@link RelationshipsGraphService} return type promises to callers. */
+const REQUIRED_GRAPH_METHODS = [
+    "getGraphSnapshot",
+    "getPersonDetail",
+    "getCandidateMerges",
+    "acceptMerge",
+    "rejectMerge",
+    "proposeMerge",
+];
+function isRelationshipsServiceWithGraph(service) {
+    if (typeof service !== "object" || service === null) {
+        return false;
+    }
+    const candidate = service;
+    return REQUIRED_GRAPH_METHODS.every((method) => typeof candidate[method] === "function");
+}
+/**
+ * Resolve the merged RelationshipsService and wire its agent-side owner
+ * resolvers. Compatibility wrapper for the old factory; prefer
+ * `runtime.getService("relationships")` directly.
+ */
+export async function resolveRelationshipsGraphService(runtime) {
+    const runtimeWithFeatures = runtime;
+    if (typeof runtimeWithFeatures.isRelationshipsEnabled === "function" &&
+        !runtimeWithFeatures.isRelationshipsEnabled() &&
+        typeof runtimeWithFeatures.enableRelationships === "function") {
+        await runtimeWithFeatures.enableRelationships();
+    }
+    const service = runtime.getService("relationships");
+    if (!isRelationshipsServiceWithGraph(service)) {
+        return null;
+    }
+    const graphService = service;
+    if (typeof graphService.setGraphResolvers === "function") {
+        graphService.setGraphResolvers({
+            resolveOwnerEntityId: (rt) => resolveOwnerEntityId(rt),
+            fetchConfiguredOwnerName: () => fetchConfiguredOwnerName(),
+        });
+    }
+    return graphService;
+}

package/services/remote-capability-cloud-sandbox.d.ts

@@ -0,0 +1,45 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { buildRemoteCapabilityEndpointTrustPolicy, installRemoteCapabilityEndpoint, type RemoteCapabilityEndpointProvider, type RemoteCapabilityEndpointTrustPolicyOptions } from "./remote-capability-endpoint-provider.ts";
+import type { RemoteCapabilityEndpointConfig } from "./remote-capability-router.ts";
+import type { RemotePluginSyncResult } from "./remote-plugin-adapter.ts";
+export type CloudCapabilitySandboxProvisionOptions = {
+    cloudApiBase: string;
+    authToken: string;
+    name: string;
+    bio?: string[];
+    endpointId?: string;
+    token?: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    fetch?: typeof fetch;
+    onProgress?: (status: string, detail?: string) => void;
+    allowedModuleIds?: string[];
+    trustPolicy?: RemoteCapabilityEndpointTrustPolicyOptions;
+};
+export type CloudCapabilitySandboxProvisionResult = {
+    agentId: string;
+    endpoint: RemoteCapabilityEndpointConfig;
+    jobId?: string;
+};
+export type WaitForCloudCapabilityEndpointAvailabilityOptions = {
+    endpoint: RemoteCapabilityEndpointConfig;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    requestTimeoutMs?: number;
+    fetch?: typeof fetch;
+    onProgress?: (detail: string) => void;
+};
+export type ConnectCloudCapabilitySandboxOptions = CloudCapabilitySandboxProvisionOptions & {
+    unloadMissing?: boolean;
+    requestTimeoutMs?: number;
+};
+export type ConnectCloudCapabilitySandboxResult = CloudCapabilitySandboxProvisionResult & {
+    providerId: string;
+    sync: RemotePluginSyncResult;
+};
+export declare const cloudCapabilityEndpointProvider: RemoteCapabilityEndpointProvider<CloudCapabilitySandboxProvisionOptions>;
+export declare function provisionCloudCapabilitySandbox(options: CloudCapabilitySandboxProvisionOptions): Promise<CloudCapabilitySandboxProvisionResult>;
+export declare function connectCloudCapabilitySandbox(runtime: IAgentRuntime, options: ConnectCloudCapabilitySandboxOptions): Promise<ConnectCloudCapabilitySandboxResult>;
+export declare function waitForCloudCapabilityEndpointAvailability(options: WaitForCloudCapabilityEndpointAvailabilityOptions): Promise<void>;
+export { buildRemoteCapabilityEndpointTrustPolicy as buildEndpointTrustPolicy, installRemoteCapabilityEndpoint, };
+//# sourceMappingURL=remote-capability-cloud-sandbox.d.ts.map

package/services/remote-capability-cloud-sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-capability-cloud-sandbox.d.ts","sourceRoot":"","sources":["../../src/services/remote-capability-cloud-sandbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,wCAAwC,EAExC,+BAA+B,EAE/B,KAAK,gCAAgC,EACrC,KAAK,0CAA0C,EAChD,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAC;AACpF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAKzE,MAAM,MAAM,sCAAsC,GAAG;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACvD,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,CAAC,EAAE,0CAA0C,CAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,qCAAqC,GAAG;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,8BAA8B,CAAC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,iDAAiD,GAAG;IAC9D,QAAQ,EAAE,8BAA8B,CAAC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAC9C,sCAAsC,GAAG;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEJ,MAAM,MAAM,mCAAmC,GAC7C,qCAAqC,GAAG;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,sBAAsB,CAAC;CAC9B,CAAC;AAEJ,eAAO,MAAM,+BAA+B,EAAE,gCAAgC,CAAC,sCAAsC,CAelH,CAAC;AA8CJ,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,sCAAsC,GAC9C,OAAO,CAAC,qCAAqC,CAAC,CA8GhD;AAED,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,oCAAoC,GAC5C,OAAO,CAAC,mCAAmC,CAAC,CAqB9C;AAED,wBAAsB,0CAA0C,CAC9D,OAAO,EAAE,iDAAiD,GACzD,OAAO,CAAC,IAAI,CAAC,CA2Df;AAkCD,OAAO,EACL,wCAAwC,IAAI,wBAAwB,EACpE,+BAA+B,GAChC,CAAC"}

package/services/remote-capability-cloud-sandbox.js

@@ -0,0 +1,253 @@
+import { buildRemoteCapabilityEndpointTrustPolicy, connectRemoteCapabilityEndpointProvider, installRemoteCapabilityEndpoint, } from "./remote-capability-endpoint-provider.js";
+const DEFAULT_CLOUD_PROVISION_TIMEOUT_MS = 120_000;
+const DEFAULT_CLOUD_PROVISION_POLL_MS = 2_000;
+export const cloudCapabilityEndpointProvider = {
+    id: "cloud",
+    provision: async (options) => ({
+        providerId: "cloud",
+        ...(await provisionCloudCapabilitySandbox(options)),
+        ...(options.allowedModuleIds === undefined
+            ? {}
+            : { allowedModuleIds: options.allowedModuleIds }),
+        ...(options.trustPolicy === undefined
+            ? {}
+            : { trustPolicy: options.trustPolicy }),
+    }),
+};
+export async function provisionCloudCapabilitySandbox(options) {
+    const request = options.fetch ?? fetch;
+    const baseUrl = normalizeCloudApiBase(options.cloudApiBase);
+    const headers = {
+        "content-type": "application/json",
+        authorization: `Bearer ${options.authToken}`,
+    };
+    options.onProgress?.("creating", "Creating cloud capability sandbox agent.");
+    const create = await cloudJson(request, `${baseUrl}/api/v1/eliza/agents`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            agentName: options.name,
+            statefulRuntime: true,
+            ...(options.bio?.length ? { agentConfig: { bio: options.bio } } : {}),
+        }),
+    });
+    if (!create.ok) {
+        throw new Error(`Failed to create cloud capability sandbox: ${create.text ?? create.status}`);
+    }
+    const agentId = create.data?.data?.id ?? create.data?.id;
+    if (!agentId) {
+        throw new Error("Failed to create cloud capability sandbox: missing agent id.");
+    }
+    options.onProgress?.("provisioning", "Provisioning cloud capability endpoint.");
+    const provision = await cloudJson(request, `${baseUrl}/api/v1/eliza/agents/${encodeURIComponent(agentId)}/provision`, {
+        method: "POST",
+        headers,
+    });
+    if (!provision.ok) {
+        throw new Error(`Failed to provision cloud capability sandbox: ${provision.text ?? provision.status}`);
+    }
+    const immediate = endpointFromProvisionPayload(options, provision.data);
+    if (immediate) {
+        options.onProgress?.("ready", "Cloud capability endpoint ready.");
+        return { agentId, endpoint: immediate };
+    }
+    const jobId = provision.data?.data?.jobId ?? provision.data?.jobId;
+    if (!jobId) {
+        throw new Error("Failed to provision cloud capability sandbox: missing job id and endpoint URL.");
+    }
+    const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_CLOUD_PROVISION_TIMEOUT_MS);
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_CLOUD_PROVISION_POLL_MS;
+    let lastStatus;
+    let lastError;
+    while (Date.now() < deadline) {
+        await sleep(pollIntervalMs);
+        const job = await cloudJson(request, `${baseUrl}/api/v1/jobs/${encodeURIComponent(jobId)}`, {
+            method: "GET",
+            headers,
+        });
+        if (!job.ok)
+            continue;
+        const status = job.data?.data?.status ?? job.data?.status;
+        const result = job.data?.data?.result ?? job.data?.result;
+        const error = job.data?.data?.error ?? job.data?.error;
+        lastStatus = status;
+        lastError = error;
+        const endpoint = endpointFromProvisionPayload(options, result);
+        if (status === "completed" && endpoint) {
+            options.onProgress?.("ready", "Cloud capability endpoint ready.");
+            return { agentId, jobId, endpoint };
+        }
+        if (status === "failed") {
+            throw new Error(`Cloud capability sandbox provisioning failed: ${error ?? "unknown error"}`);
+        }
+        options.onProgress?.("provisioning", `Cloud capability sandbox status: ${status ?? "pending"}.`);
+    }
+    throw new Error(`Cloud capability sandbox provisioning timed out.${lastStatus ? ` Last status: ${lastStatus}.` : ""}${lastError ? ` Last error: ${lastError}.` : ""}`);
+}
+export async function connectCloudCapabilitySandbox(runtime, options) {
+    const result = await connectRemoteCapabilityEndpointProvider(runtime, {
+        provider: cloudCapabilityEndpointProvider,
+        provisionOptions: options,
+        unloadMissing: options.unloadMissing,
+        requestTimeoutMs: options.requestTimeoutMs,
+        ...(options.allowedModuleIds === undefined
+            ? {}
+            : { allowedModuleIds: options.allowedModuleIds }),
+        ...(options.trustPolicy === undefined
+            ? {}
+            : { trustPolicy: options.trustPolicy }),
+    });
+    assertCloudProvisionResult(result);
+    return {
+        agentId: result.agentId,
+        providerId: result.providerId,
+        endpoint: result.endpoint,
+        ...(result.jobId === undefined ? {} : { jobId: result.jobId }),
+        sync: result.sync,
+    };
+}
+export async function waitForCloudCapabilityEndpointAvailability(options) {
+    const request = options.fetch ?? fetch;
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 5_000;
+    const requestTimeoutMs = options.requestTimeoutMs ?? 60_000;
+    const deadline = Date.now() + timeoutMs;
+    let lastError = "availability was not checked";
+    do {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), requestTimeoutMs);
+            try {
+                const response = await request(new URL("/v1/capabilities", options.endpoint.baseUrl), {
+                    method: "GET",
+                    headers: {
+                        accept: "application/json",
+                        ...(options.endpoint.token
+                            ? { authorization: `Bearer ${options.endpoint.token}` }
+                            : {}),
+                    },
+                    signal: controller.signal,
+                });
+                const text = await response.text();
+                if (!response.ok) {
+                    lastError = `HTTP ${response.status}: ${text.slice(0, 500)}`;
+                }
+                else {
+                    const availability = JSON.parse(text);
+                    if (availability.available === true &&
+                        availability.capabilities?.plugin === true) {
+                        return;
+                    }
+                    lastError = `unexpected availability payload: ${text.slice(0, 500)}`;
+                }
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+        catch (error) {
+            lastError = describeAvailabilityError(error);
+        }
+        options.onProgress?.(`waiting for endpoint ${options.endpoint.id}: ${lastError}`);
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            break;
+        await sleep(Math.min(pollIntervalMs, remainingMs));
+    } while (Date.now() < deadline);
+    throw new Error(`Cloud capability endpoint ${options.endpoint.id} did not report plugin availability within ${timeoutMs}ms. Last error: ${lastError}`);
+}
+function describeAvailabilityError(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const cause = error.cause;
+    if (cause instanceof Error) {
+        return `${error.message}: ${cause.message}`;
+    }
+    if (cause && typeof cause === "object") {
+        const detail = cause;
+        const parts = [
+            detail.code,
+            detail.errno,
+            detail.syscall,
+            detail.hostname,
+            detail.address,
+            detail.port,
+        ]
+            .filter((value) => typeof value === "string" || typeof value === "number")
+            .map(String);
+        if (parts.length > 0) {
+            return `${error.message}: ${parts.join(" ")}`;
+        }
+    }
+    return error.message;
+}
+export { buildRemoteCapabilityEndpointTrustPolicy as buildEndpointTrustPolicy, installRemoteCapabilityEndpoint, };
+function assertCloudProvisionResult(result) {
+    if (!result.agentId) {
+        throw new Error("Cloud capability sandbox provisioning returned no agent id.");
+    }
+}
+function endpointFromProvisionPayload(options, payload) {
+    const data = payload && "data" in payload && payload.data ? payload.data : payload;
+    const baseUrl = firstString(data?.capabilityRouterUrl, data?.capability_router_url, data?.bridgeUrl, data?.bridge_url);
+    if (!baseUrl)
+        return null;
+    const token = firstString(options.token, data?.capabilityRouterToken, data?.capability_router_token, data?.token);
+    return {
+        id: options.endpointId ?? "cloud-capability",
+        baseUrl: stripTrailingSlash(baseUrl),
+        ...(token === null ? {} : { token }),
+    };
+}
+async function cloudJson(request, url, init) {
+    const response = await request(url, {
+        ...init,
+        headers: lowercaseHeaders(init.headers),
+    });
+    const text = await response.text();
+    let data;
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        }
+        catch {
+            // keep raw text for errors
+        }
+    }
+    return { ok: response.ok, status: response.status, data, text };
+}
+function lowercaseHeaders(headers) {
+    if (!headers || headers instanceof Headers || Array.isArray(headers)) {
+        return headers ?? {};
+    }
+    return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+}
+function normalizeCloudApiBase(value) {
+    const trimmed = value.trim().replace(/\/+$/, "");
+    if (!trimmed)
+        throw new Error("cloudApiBase is required.");
+    try {
+        const url = new URL(trimmed);
+        if (url.hostname === "www.elizacloud.ai" ||
+            url.hostname === "elizacloud.ai") {
+            url.hostname = "api.elizacloud.ai";
+        }
+        return url.toString().replace(/\/+$/, "");
+    }
+    catch {
+        throw new Error(`Invalid cloudApiBase: ${value}`);
+    }
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return null;
+}
+function stripTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}