@elizaos/autonomous 2.0.0-alpha.71 → 2.0.0-alpha.72

package/packages/autonomous/src/services/privy-wallets.js

@@ -0,0 +1,225 @@
+import { logger } from "@elizaos/core";
+const PRIVY_DEFAULT_API_BASE_URL = "https://auth.privy.io/api/v1";
+const PRIVY_TIMEOUT_MS = 12_000;
+function normalizeEnvValue(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function resolvePrivyConfig(env = process.env) {
+    const appId = normalizeEnvValue(env.PRIVY_APP_ID) ??
+        normalizeEnvValue(env.BABYLON_PRIVY_APP_ID);
+    const appSecret = normalizeEnvValue(env.PRIVY_APP_SECRET) ??
+        normalizeEnvValue(env.BABYLON_PRIVY_APP_SECRET);
+    if (!appId || !appSecret)
+        return null;
+    const apiBaseUrl = normalizeEnvValue(env.PRIVY_API_BASE_URL) ?? PRIVY_DEFAULT_API_BASE_URL;
+    // Validate that the Privy API base URL uses HTTPS to prevent SSRF
+    // attacks that could leak credentials to arbitrary endpoints.
+    try {
+        const parsed = new URL(apiBaseUrl);
+        if (parsed.protocol !== "https:") {
+            logger.warn(`[privy] PRIVY_API_BASE_URL must use https:, got ${parsed.protocol} — falling back to default.`);
+            return {
+                appId,
+                appSecret,
+                apiBaseUrl: PRIVY_DEFAULT_API_BASE_URL,
+            };
+        }
+    }
+    catch {
+        logger.warn("[privy] PRIVY_API_BASE_URL is not a valid URL — falling back to default.");
+        return {
+            appId,
+            appSecret,
+            apiBaseUrl: PRIVY_DEFAULT_API_BASE_URL,
+        };
+    }
+    return {
+        appId,
+        appSecret,
+        apiBaseUrl: apiBaseUrl.replace(/\/+$/, ""),
+    };
+}
+export function isPrivyWalletProvisioningEnabled(env = process.env) {
+    return resolvePrivyConfig(env) !== null;
+}
+function assertPrivyConfig(env = process.env) {
+    const config = resolvePrivyConfig(env);
+    if (!config) {
+        throw new Error("Privy wallet provisioning is not configured (missing PRIVY_APP_ID / PRIVY_APP_SECRET).");
+    }
+    return config;
+}
+function authHeaders(config) {
+    const basic = Buffer.from(`${config.appId}:${config.appSecret}`).toString("base64");
+    return {
+        Authorization: `Basic ${basic}`,
+        "Content-Type": "application/json",
+        "privy-app-id": config.appId,
+    };
+}
+async function readResponseText(response) {
+    try {
+        return (await response.text()).trim();
+    }
+    catch {
+        return "";
+    }
+}
+async function privyRequest(config, path, init) {
+    const response = await fetch(`${config.apiBaseUrl}${path}`, {
+        ...init,
+        headers: {
+            ...authHeaders(config),
+            ...(init?.headers ?? {}),
+        },
+        signal: AbortSignal.timeout(PRIVY_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        const details = (await readResponseText(response)).slice(0, 240);
+        const suffix = details ? `: ${details}` : "";
+        throw new Error(`Privy request failed (${response.status}) for ${path}${suffix}`);
+    }
+    return (await response.json());
+}
+async function getUserByCustomAuthId(config, customUserId) {
+    const response = await fetch(`${config.apiBaseUrl}/users/custom_auth/id`, {
+        method: "POST",
+        headers: authHeaders(config),
+        body: JSON.stringify({ custom_user_id: customUserId }),
+        signal: AbortSignal.timeout(PRIVY_TIMEOUT_MS),
+    });
+    if (response.status === 404) {
+        return null;
+    }
+    if (!response.ok) {
+        const details = (await readResponseText(response)).slice(0, 240);
+        throw new Error(`Privy user lookup failed (${response.status})${details ? `: ${details}` : ""}`);
+    }
+    const payload = (await response.json());
+    if (typeof payload.id !== "string" || payload.id.length === 0) {
+        throw new Error("Privy user lookup returned an invalid response.");
+    }
+    return { id: payload.id };
+}
+async function createUserWithWallets(config, customUserId) {
+    const payload = await privyRequest(config, "/users", {
+        method: "POST",
+        body: JSON.stringify({
+            linked_accounts: [
+                {
+                    type: "custom_auth",
+                    custom_user_id: customUserId,
+                },
+            ],
+            wallets: [{ chain_type: "ethereum" }, { chain_type: "solana" }],
+        }),
+    });
+    if (typeof payload.id !== "string" || payload.id.length === 0) {
+        throw new Error("Privy user creation returned an invalid response.");
+    }
+    return { id: payload.id };
+}
+function parseWalletList(payload) {
+    if (Array.isArray(payload)) {
+        return payload.filter((entry) => typeof entry === "object" && entry !== null);
+    }
+    if (typeof payload !== "object" || payload === null)
+        return [];
+    const candidate = payload;
+    const arrays = [candidate.data, candidate.results, candidate.wallets];
+    for (const value of arrays) {
+        if (!Array.isArray(value))
+            continue;
+        return value.filter((entry) => typeof entry === "object" && entry !== null);
+    }
+    return [];
+}
+function normalizeWalletChain(wallet) {
+    const rawChain = typeof wallet.chain_type === "string"
+        ? wallet.chain_type.toLowerCase()
+        : "";
+    if (rawChain.includes("sol"))
+        return "solana";
+    if (rawChain.includes("eth") || rawChain === "evm")
+        return "ethereum";
+    const address = typeof wallet.address === "string" ? wallet.address : "";
+    if (address.startsWith("0x"))
+        return "ethereum";
+    if (address.length > 0)
+        return "solana";
+    return null;
+}
+function normalizeWalletSummary(wallet) {
+    const chain = normalizeWalletChain(wallet);
+    const address = typeof wallet.address === "string" ? wallet.address.trim() : "";
+    const id = typeof wallet.id === "string" ? wallet.id : "";
+    if (!chain || !address || !id)
+        return null;
+    return { id, chain, address };
+}
+async function listUserWallets(config, userId) {
+    const payload = await privyRequest(config, `/wallets?user_id=${encodeURIComponent(userId)}&limit=100`, { method: "GET" });
+    const rawWallets = parseWalletList(payload);
+    const wallets = [];
+    for (const raw of rawWallets) {
+        const summary = normalizeWalletSummary(raw);
+        if (!summary)
+            continue;
+        if (wallets.some((wallet) => wallet.chain === summary.chain && wallet.address === summary.address)) {
+            continue;
+        }
+        wallets.push(summary);
+    }
+    return wallets;
+}
+async function createWalletForUser(config, userId, chain) {
+    await privyRequest(config, `/users/${encodeURIComponent(userId)}/wallets`, {
+        method: "POST",
+        body: JSON.stringify({ chain_type: chain }),
+    });
+}
+function pickAddresses(wallets) {
+    const evmAddress = wallets.find((wallet) => wallet.chain === "ethereum")?.address ?? null;
+    const solanaAddress = wallets.find((wallet) => wallet.chain === "solana")?.address ?? null;
+    return { evmAddress, solanaAddress };
+}
+export async function ensurePrivyWalletsForCustomUser(customUserId, chains = ["ethereum", "solana"], env = process.env) {
+    const normalizedCustomUserId = customUserId.trim();
+    if (!normalizedCustomUserId) {
+        throw new Error("customUserId is required.");
+    }
+    const targetChains = Array.from(new Set(chains));
+    const config = assertPrivyConfig(env);
+    let user = await getUserByCustomAuthId(config, normalizedCustomUserId);
+    let createdUser = false;
+    if (!user) {
+        user = await createUserWithWallets(config, normalizedCustomUserId);
+        createdUser = true;
+    }
+    let wallets = await listUserWallets(config, user.id);
+    for (const chain of targetChains) {
+        const exists = wallets.some((wallet) => wallet.chain === chain);
+        if (!exists) {
+            await createWalletForUser(config, user.id, chain);
+        }
+    }
+    if (targetChains.some((chain) => !wallets.some((w) => w.chain === chain))) {
+        wallets = await listUserWallets(config, user.id);
+    }
+    const addresses = pickAddresses(wallets);
+    if (targetChains.includes("ethereum") &&
+        !addresses.evmAddress &&
+        targetChains.includes("solana") &&
+        !addresses.solanaAddress) {
+        logger.warn(`[privy] Wallet ensure returned no addresses for user ${user.id}`);
+    }
+    return {
+        userId: user.id,
+        createdUser,
+        wallets,
+        ...addresses,
+    };
+}

package/packages/autonomous/src/services/registry-client-app-meta.d.ts

@@ -0,0 +1,6 @@
+import type { RegistryAppMeta } from "./registry-client-types.js";
+export declare const LOCAL_APP_DEFAULT_SANDBOX = "allow-scripts allow-same-origin allow-popups";
+export declare function sanitizeSandbox(rawSandbox?: string): string;
+export declare function mergeAppMeta(base: RegistryAppMeta | undefined, patch: RegistryAppMeta | undefined): RegistryAppMeta | undefined;
+export declare function resolveAppOverride(packageName: string, appMeta: RegistryAppMeta | undefined): RegistryAppMeta | undefined;
+//# sourceMappingURL=registry-client-app-meta.d.ts.map

package/packages/autonomous/src/services/registry-client-app-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-client-app-meta.d.ts","sourceRoot":"","sources":["../../../../../src/services/registry-client-app-meta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,eAAe,EAEhB,MAAM,4BAA4B,CAAC;AAEpC,eAAO,MAAM,yBAAyB,iDACU,CAAC;AAwEjD,wBAAgB,eAAe,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAwB3D;AA6BD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,eAAe,GAAG,SAAS,EACjC,KAAK,EAAE,eAAe,GAAG,SAAS,GACjC,eAAe,GAAG,SAAS,CAY7B;AAED,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,eAAe,GAAG,SAAS,GACnC,eAAe,GAAG,SAAS,CA8B7B"}

package/packages/autonomous/src/services/registry-client-app-meta.js

@@ -0,0 +1,147 @@
+import { logger } from "@elizaos/core";
+export const LOCAL_APP_DEFAULT_SANDBOX = "allow-scripts allow-same-origin allow-popups";
+const ALLOWED_SANDBOX_TOKENS = new Set([
+    "allow-downloads",
+    "allow-forms",
+    "allow-modals",
+    "allow-orientation-lock",
+    "allow-pointer-lock",
+    "allow-popups",
+    "allow-popups-to-escape-sandbox",
+    "allow-presentation",
+    "allow-same-origin",
+    "allow-scripts",
+    "allow-storage-access-by-user-activation",
+    "allow-top-navigation-by-user-activation",
+]);
+const LOCAL_APP_OVERRIDES = {
+    "@elizaos/app-babylon": {
+        launchType: "url",
+        launchUrl: "http://localhost:3000",
+        viewer: {
+            url: "http://localhost:3000",
+            sandbox: "allow-scripts allow-same-origin allow-popups allow-forms",
+        },
+    },
+    "@elizaos/app-hyperfy": {
+        launchType: "connect",
+        launchUrl: "http://localhost:3003",
+        viewer: {
+            url: "http://localhost:3003",
+            sandbox: LOCAL_APP_DEFAULT_SANDBOX,
+        },
+    },
+    "@elizaos/app-2004scape": {
+        launchType: "connect",
+        launchUrl: "http://localhost:8880",
+        viewer: {
+            url: "http://localhost:8880",
+            embedParams: { bot: "{RS_SDK_BOT_NAME}" },
+            postMessageAuth: true,
+            sandbox: "allow-scripts allow-same-origin allow-popups allow-forms",
+        },
+    },
+    "@elizaos/app-agent-town": {
+        launchType: "url",
+        launchUrl: "http://localhost:5173/ai-town/index.html",
+        viewer: {
+            url: "http://localhost:5173/ai-town/index.html",
+            sandbox: "allow-scripts allow-same-origin allow-popups allow-forms",
+        },
+    },
+    "@elizaos/app-dungeons": {
+        launchType: "local",
+        launchUrl: "http://localhost:3345",
+        viewer: {
+            url: "http://localhost:3345",
+            sandbox: "allow-scripts allow-same-origin allow-popups allow-forms",
+        },
+    },
+};
+export function sanitizeSandbox(rawSandbox) {
+    if (!rawSandbox || !rawSandbox.trim()) {
+        return LOCAL_APP_DEFAULT_SANDBOX;
+    }
+    const tokens = rawSandbox
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+        return LOCAL_APP_DEFAULT_SANDBOX;
+    }
+    for (const token of tokens) {
+        if (!ALLOWED_SANDBOX_TOKENS.has(token)) {
+            logger.warn(`[registry-client] rejecting untrusted sandbox token: ${token}`);
+            return LOCAL_APP_DEFAULT_SANDBOX;
+        }
+    }
+    return Array.from(new Set(tokens)).join(" ");
+}
+function normalizeViewer(viewer) {
+    if (!viewer)
+        return undefined;
+    return {
+        ...viewer,
+        sandbox: sanitizeSandbox(viewer.sandbox),
+    };
+}
+function mergeViewer(base, patch) {
+    if (!base && !patch)
+        return undefined;
+    if (!base)
+        return normalizeViewer(patch);
+    if (!patch)
+        return normalizeViewer(base);
+    return normalizeViewer({
+        ...base,
+        ...patch,
+        embedParams: {
+            ...(base.embedParams ?? {}),
+            ...(patch.embedParams ?? {}),
+        },
+    });
+}
+export function mergeAppMeta(base, patch) {
+    if (!base && !patch)
+        return undefined;
+    if (!base)
+        return patch;
+    if (!patch)
+        return base;
+    return {
+        ...base,
+        ...patch,
+        capabilities: patch.capabilities.length > 0 ? patch.capabilities : base.capabilities,
+        uiExtension: patch.uiExtension ?? base.uiExtension,
+        viewer: mergeViewer(base.viewer, patch.viewer),
+    };
+}
+export function resolveAppOverride(packageName, appMeta) {
+    const override = LOCAL_APP_OVERRIDES[packageName];
+    if (!override)
+        return appMeta;
+    const base = appMeta ?? {
+        displayName: override.displayName ?? packageName.replace(/^@elizaos\/app-/, ""),
+        category: override.category ?? "game",
+        launchType: override.launchType ?? "url",
+        launchUrl: override.launchUrl ?? null,
+        icon: null,
+        capabilities: override.capabilities ?? [],
+        minPlayers: null,
+        maxPlayers: null,
+        uiExtension: override.uiExtension,
+        viewer: override.viewer,
+    };
+    return {
+        ...base,
+        displayName: override.displayName ?? base.displayName,
+        category: override.category ?? base.category,
+        launchType: override.launchType ?? base.launchType,
+        launchUrl: override.launchUrl !== undefined ? override.launchUrl : base.launchUrl,
+        capabilities: override.capabilities !== undefined
+            ? override.capabilities
+            : base.capabilities,
+        uiExtension: override.uiExtension ?? base.uiExtension,
+        viewer: mergeViewer(base.viewer, override.viewer),
+    };
+}

package/packages/autonomous/src/services/registry-client-endpoints.d.ts

@@ -0,0 +1,7 @@
+import type { RegistryEndpoint } from "../config/types.eliza.js";
+import type { RegistryPluginInfo } from "./registry-client-types.js";
+export declare function normaliseEndpointUrl(url: string): string;
+export declare function isDefaultEndpoint(url: string, defaultUrl: string): boolean;
+export declare function parseRegistryEndpointUrl(rawUrl: string): URL;
+export declare function mergeCustomEndpoints(plugins: Map<string, RegistryPluginInfo>, endpoints: RegistryEndpoint[]): Promise<void>;
+//# sourceMappingURL=registry-client-endpoints.d.ts.map

package/packages/autonomous/src/services/registry-client-endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-client-endpoints.d.ts","sourceRoot":"","sources":["../../../../../src/services/registry-client-endpoints.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAKjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAUrE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAE1E;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CA4B5D;AA8KD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EACxC,SAAS,EAAE,gBAAgB,EAAE,GAC5B,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/packages/autonomous/src/services/registry-client-endpoints.js

@@ -0,0 +1,183 @@
+import { lookup as dnsLookup } from "node:dns/promises";
+import net from "node:net";
+import { logger } from "@elizaos/core";
+import { isBlockedPrivateOrLinkLocalIp, normalizeHostLike, } from "../security/network-policy.js";
+const BLOCKED_REGISTRY_HOST_LITERALS = new Set([
+    "localhost",
+    "127.0.0.1",
+    "::1",
+    "0.0.0.0",
+    "169.254.169.254",
+]);
+export function normaliseEndpointUrl(url) {
+    return url.replace(/\/+$/, "");
+}
+export function isDefaultEndpoint(url, defaultUrl) {
+    return normaliseEndpointUrl(url) === normaliseEndpointUrl(defaultUrl);
+}
+export function parseRegistryEndpointUrl(rawUrl) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        throw new Error("Endpoint URL must be a valid absolute URL");
+    }
+    if (parsed.protocol !== "https:") {
+        throw new Error("Endpoint URL must use https://");
+    }
+    const hostname = normalizeHostLike(parsed.hostname);
+    if (!hostname)
+        throw new Error("Endpoint URL hostname is required");
+    if (BLOCKED_REGISTRY_HOST_LITERALS.has(hostname) ||
+        hostname.endsWith(".localhost") ||
+        hostname.endsWith(".local")) {
+        throw new Error(`Endpoint host "${hostname}" is blocked`);
+    }
+    if (net.isIP(hostname) && isBlockedPrivateOrLinkLocalIp(hostname)) {
+        throw new Error(`Endpoint host "${hostname}" is blocked`);
+    }
+    return parsed;
+}
+async function resolveRegistryEndpointUrlRejection(rawUrl) {
+    let parsed;
+    try {
+        parsed = parseRegistryEndpointUrl(rawUrl);
+    }
+    catch (error) {
+        return {
+            rejection: error instanceof Error ? error.message : String(error),
+            endpoint: null,
+        };
+    }
+    const hostname = normalizeHostLike(parsed.hostname);
+    if (!hostname) {
+        return {
+            rejection: "Endpoint URL hostname is required",
+            endpoint: null,
+        };
+    }
+    if (net.isIP(hostname)) {
+        return {
+            rejection: null,
+            endpoint: { parsed, hostname, pinnedAddress: hostname },
+        };
+    }
+    let addresses;
+    try {
+        const resolved = await dnsLookup(hostname, { all: true });
+        addresses = Array.isArray(resolved) ? resolved : [resolved];
+    }
+    catch {
+        return {
+            rejection: `Could not resolve endpoint host "${hostname}"`,
+            endpoint: null,
+        };
+    }
+    if (addresses.length === 0) {
+        return {
+            rejection: `Could not resolve endpoint host "${hostname}"`,
+            endpoint: null,
+        };
+    }
+    for (const entry of addresses) {
+        if (isBlockedPrivateOrLinkLocalIp(entry.address)) {
+            return {
+                rejection: `Endpoint host "${hostname}" resolves to blocked address ${entry.address}`,
+                endpoint: null,
+            };
+        }
+    }
+    return {
+        rejection: null,
+        endpoint: {
+            parsed,
+            hostname,
+            pinnedAddress: addresses[0]?.address ?? null,
+        },
+    };
+}
+async function fetchSingleEndpoint(url, label) {
+    const { rejection, endpoint } = await resolveRegistryEndpointUrlRejection(url);
+    if (rejection || !endpoint) {
+        logger.warn(`[registry-client] Endpoint "${label}" (${url}) blocked: ${rejection ?? "validation failed"}`);
+        return null;
+    }
+    try {
+        if (endpoint.pinnedAddress && !net.isIP(endpoint.hostname)) {
+            const refreshed = await dnsLookup(endpoint.hostname, { all: true });
+            const refreshedAddresses = new Set((Array.isArray(refreshed) ? refreshed : [refreshed]).map((entry) => normalizeHostLike(entry.address)));
+            if (!refreshedAddresses.has(normalizeHostLike(endpoint.pinnedAddress))) {
+                logger.warn(`[registry-client] Endpoint "${label}" (${url}) blocked: host resolution changed before fetch`);
+                return null;
+            }
+            for (const address of refreshedAddresses) {
+                if (isBlockedPrivateOrLinkLocalIp(address)) {
+                    logger.warn(`[registry-client] Endpoint "${label}" (${url}) blocked: host resolves to blocked address ${address}`);
+                    return null;
+                }
+            }
+        }
+        const resp = await fetch(url, { redirect: "error" });
+        if (!resp.ok) {
+            logger.warn(`[registry-client] Endpoint "${label}" (${url}): ${resp.status} ${resp.statusText}`);
+            return null;
+        }
+        const data = (await resp.json());
+        if (!data.registry || typeof data.registry !== "object") {
+            logger.warn(`[registry-client] Endpoint "${label}" (${url}): missing registry field`);
+            return null;
+        }
+        const plugins = new Map();
+        for (const [name, raw] of Object.entries(data.registry)) {
+            const e = raw;
+            const git = (e.git ?? {});
+            const npm = (e.npm ?? {});
+            const supports = (e.supports ?? { v0: false, v1: false, v2: false });
+            plugins.set(name, {
+                name,
+                gitRepo: git.repo ?? "unknown/unknown",
+                gitUrl: `https://github.com/${git.repo ?? "unknown/unknown"}.git`,
+                description: e.description ?? "",
+                homepage: e.homepage ?? null,
+                topics: e.topics ?? [],
+                stars: e.stargazers_count ?? 0,
+                language: e.language ?? "TypeScript",
+                npm: {
+                    package: npm.repo ?? name,
+                    v0Version: npm.v0 ?? null,
+                    v1Version: npm.v1 ?? null,
+                    v2Version: npm.v2 ?? null,
+                },
+                git: {
+                    v0Branch: git.v0?.branch ?? null,
+                    v1Branch: git.v1?.branch ?? null,
+                    v2Branch: git.v2?.branch ?? null,
+                },
+                supports,
+            });
+        }
+        return plugins;
+    }
+    catch (err) {
+        logger.warn(`[registry-client] Endpoint "${label}" (${url}) failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+export async function mergeCustomEndpoints(plugins, endpoints) {
+    const enabledEndpoints = endpoints.filter((ep) => ep.enabled !== false);
+    if (enabledEndpoints.length === 0)
+        return;
+    const results = await Promise.allSettled(enabledEndpoints.map((ep) => fetchSingleEndpoint(ep.url, ep.label)));
+    for (const result of results) {
+        if (result.status === "fulfilled" && result.value) {
+            for (const [name, info] of result.value) {
+                if (plugins.has(name)) {
+                    logger.warn(`[registry-client] Ignoring custom endpoint override for ${name}`);
+                    continue;
+                }
+                plugins.set(name, info);
+            }
+        }
+    }
+}

package/packages/autonomous/src/services/registry-client-local.d.ts

@@ -0,0 +1,4 @@
+import type { RegistryPluginInfo } from "./registry-client-types.js";
+export declare function applyNodeModulePlugins(plugins: Map<string, RegistryPluginInfo>): Promise<void>;
+export declare function applyLocalWorkspaceApps(plugins: Map<string, RegistryPluginInfo>): Promise<void>;
+//# sourceMappingURL=registry-client-local.d.ts.map

package/packages/autonomous/src/services/registry-client-local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-client-local.d.ts","sourceRoot":"","sources":["../../../../../src/services/registry-client-local.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAIV,kBAAkB,EACnB,MAAM,4BAA4B,CAAC;AAuapC,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,GACvC,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,GACvC,OAAO,CAAC,IAAI,CAAC,CA8Bf"}