@elizaos/autonomous 2.0.0-alpha.37

package/dist/packages/autonomous/src/services/registry-client-local.js

@@ -0,0 +1,377 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { mergeAppMeta, resolveAppOverride, } from "./registry-client-app-meta.js";
+const LOCAL_PLUGIN_TAG_STOPWORDS = new Set([
+    "plugin",
+    "plugins",
+    "eliza",
+    "elizaos",
+    "milady",
+    "elizaos-plugin",
+    "elizaos-plugins",
+    "feature",
+]);
+function uniquePaths(paths) {
+    const seen = new Set();
+    const ordered = [];
+    for (const p of paths) {
+        const resolved = path.resolve(p);
+        if (!seen.has(resolved)) {
+            seen.add(resolved);
+            ordered.push(resolved);
+        }
+    }
+    return ordered;
+}
+function resolveWorkspaceRoots() {
+    const envRoot = process.env.MILADY_WORKSPACE_ROOT?.trim();
+    if (envRoot)
+        return uniquePaths([envRoot]);
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(moduleDir, "..", "..");
+    const cwd = process.cwd();
+    const roots = [
+        packageRoot,
+        cwd,
+        path.resolve(cwd, ".."),
+        path.resolve(cwd, "..", ".."),
+    ].filter((candidate) => Boolean(candidate));
+    return uniquePaths(roots);
+}
+function repoString(repo) {
+    if (!repo)
+        return null;
+    if (typeof repo === "string")
+        return repo;
+    if (typeof repo.url === "string" && repo.url.length > 0)
+        return repo.url;
+    return null;
+}
+function normaliseGitHubRepo(repo) {
+    if (!repo)
+        return null;
+    const cleaned = repo
+        .replace(/^git\+/, "")
+        .replace(/\.git$/, "")
+        .replace(/^https?:\/\/github\.com\//, "")
+        .replace(/^git@github\.com:/, "")
+        .trim();
+    if (!cleaned.includes("/"))
+        return null;
+    return cleaned;
+}
+async function readJsonFile(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeLocalTag(tag) {
+    const normalized = tag
+        .trim()
+        .toLowerCase()
+        .replace(/&/g, " and ")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!normalized || LOCAL_PLUGIN_TAG_STOPWORDS.has(normalized))
+        return null;
+    return normalized;
+}
+function normalizeLocalTags(values) {
+    if (!Array.isArray(values))
+        return [];
+    const tags = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const normalized = normalizeLocalTag(value);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        tags.push(normalized);
+    }
+    return tags;
+}
+function toLocalAppMeta(app, fallbackDisplayName) {
+    if (!app)
+        return undefined;
+    const launchType = app.launchType ?? "url";
+    return {
+        displayName: app.displayName ?? fallbackDisplayName,
+        category: app.category ?? "game",
+        launchType,
+        launchUrl: app.launchUrl ?? null,
+        icon: app.icon ?? null,
+        capabilities: app.capabilities ?? [],
+        minPlayers: app.minPlayers ?? null,
+        maxPlayers: app.maxPlayers ?? null,
+        uiExtension: app.uiExtension,
+        viewer: app.viewer,
+    };
+}
+function toDisplayNameFromDirName(dirName) {
+    return dirName
+        .replace(/^app-/, "")
+        .split("-")
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function parseRepositoryMetadata(repository) {
+    const repoValue = repoString(repository);
+    const gitRepo = normaliseGitHubRepo(repoValue) ?? "local/workspace";
+    return {
+        gitRepo,
+        gitUrl: `https://github.com/${gitRepo}.git`,
+    };
+}
+function buildDiscoveredEntry(packageDir, dirName, packageJson, manifest) {
+    if (!packageJson?.name || packageJson.name.length === 0)
+        return null;
+    const packageAppMeta = toLocalAppMeta(packageJson.elizaos?.app, toDisplayNameFromDirName(dirName));
+    const manifestAppMeta = toLocalAppMeta(manifest?.app, toDisplayNameFromDirName(dirName));
+    const mergedMeta = mergeAppMeta(manifestAppMeta, packageAppMeta);
+    const overriddenMeta = resolveAppOverride(packageJson.name, mergedMeta);
+    const kind = packageJson.elizaos?.kind === "app" || manifest?.kind === "app"
+        ? "app"
+        : overriddenMeta
+            ? "app"
+            : undefined;
+    const repo = parseRepositoryMetadata(packageJson.repository ?? manifest?.repository);
+    const description = packageJson.description ?? manifest?.description ?? "";
+    const topics = normalizeLocalTags([
+        ...(packageJson.keywords ?? []),
+        ...(manifest?.tags ?? []),
+    ]);
+    const homepage = packageJson.homepage ??
+        manifest?.homepage ??
+        overriddenMeta?.launchUrl ??
+        null;
+    const version = packageJson.version ?? manifest?.version ?? null;
+    return {
+        name: packageJson.name,
+        gitRepo: repo.gitRepo,
+        gitUrl: repo.gitUrl,
+        description,
+        homepage,
+        topics,
+        stars: 0,
+        language: "TypeScript",
+        npm: {
+            package: packageJson.name,
+            v0Version: null,
+            v1Version: null,
+            v2Version: version,
+        },
+        git: {
+            v0Branch: null,
+            v1Branch: null,
+            v2Branch: "main",
+        },
+        supports: { v0: false, v1: false, v2: true },
+        localPath: packageDir,
+        kind,
+        appMeta: overriddenMeta ?? undefined,
+    };
+}
+async function discoverLocalWorkspaceApps() {
+    const discovered = new Map();
+    for (const workspaceRoot of resolveWorkspaceRoots()) {
+        const pluginsDir = path.join(workspaceRoot, "plugins");
+        let entries;
+        try {
+            entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if ((!entry.isDirectory() && !entry.isSymbolicLink()) ||
+                !entry.name.startsWith("app-"))
+                continue;
+            const packageDir = path.join(pluginsDir, entry.name);
+            const packageJson = await readJsonFile(path.join(packageDir, "package.json"));
+            if (!packageJson)
+                continue;
+            const manifest = await readJsonFile(path.join(packageDir, "elizaos.plugin.json"));
+            const info = buildDiscoveredEntry(packageDir, entry.name, packageJson, manifest);
+            if (info)
+                discovered.set(info.name, info);
+        }
+    }
+    const stateDir = process.env.MILADY_STATE_DIR?.trim() || path.join(os.homedir(), ".milady");
+    const installedBase = path.join(stateDir, "plugins", "installed");
+    try {
+        const installedEntries = await fs.readdir(installedBase, {
+            withFileTypes: true,
+        });
+        for (const entry of installedEntries) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const installDir = path.join(installedBase, entry.name);
+            const nmDir = path.join(installDir, "node_modules");
+            const pkgDirs = [];
+            try {
+                const nmEntries = await fs.readdir(nmDir, { withFileTypes: true });
+                for (const nm of nmEntries) {
+                    if (nm.name.startsWith("@")) {
+                        const scopeDir = path.join(nmDir, nm.name);
+                        try {
+                            const scopeEntries = await fs.readdir(scopeDir, {
+                                withFileTypes: true,
+                            });
+                            for (const se of scopeEntries) {
+                                pkgDirs.push(path.join(scopeDir, se.name));
+                            }
+                        }
+                        catch {
+                            // skip
+                        }
+                    }
+                    else if (nm.isDirectory() || nm.isSymbolicLink()) {
+                        pkgDirs.push(path.join(nmDir, nm.name));
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+            for (const pkgDir of pkgDirs) {
+                const pkgJson = await readJsonFile(path.join(pkgDir, "package.json"));
+                if (!pkgJson?.name)
+                    continue;
+                if (pkgJson.elizaos?.kind !== "app")
+                    continue;
+                if (discovered.has(pkgJson.name))
+                    continue;
+                const manifest = await readJsonFile(path.join(pkgDir, "elizaos.plugin.json"));
+                const dirName = pkgJson.name
+                    .replace(/^@[^/]+\//, "")
+                    .replace(/^plugin-/, "app-");
+                const info = buildDiscoveredEntry(pkgDir, dirName, pkgJson, manifest);
+                if (info)
+                    discovered.set(info.name, info);
+            }
+        }
+    }
+    catch {
+        // installed dir may not exist
+    }
+    return discovered;
+}
+async function discoverNodeModulePlugins() {
+    const discovered = new Map();
+    for (const workspaceRoot of resolveWorkspaceRoots()) {
+        const elizaosDir = path.join(workspaceRoot, "node_modules", "@elizaos");
+        let entries;
+        try {
+            entries = await fs.readdir(elizaosDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.name.startsWith("plugin-"))
+                continue;
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const packageDir = path.join(elizaosDir, entry.name);
+            const packageJson = await readJsonFile(path.join(packageDir, "package.json"));
+            if (!packageJson?.name)
+                continue;
+            const isPlugin = packageJson.packageType === "plugin" ||
+                packageJson.keywords?.includes("elizaos") ||
+                packageJson.elizaos !== undefined ||
+                packageJson.agentConfig !== undefined;
+            if (!isPlugin)
+                continue;
+            if (packageJson.elizaos?.kind === "app")
+                continue;
+            const repo = parseRepositoryMetadata(packageJson.repository);
+            const version = packageJson.version ?? null;
+            let localPath = packageDir;
+            try {
+                const realPath = await fs.realpath(packageDir);
+                if (realPath !== packageDir)
+                    localPath = realPath;
+            }
+            catch {
+                // fallback
+            }
+            discovered.set(packageJson.name, {
+                name: packageJson.name,
+                gitRepo: repo.gitRepo,
+                gitUrl: repo.gitUrl,
+                description: packageJson.description ?? "",
+                homepage: packageJson.homepage ?? null,
+                topics: normalizeLocalTags(packageJson.keywords),
+                stars: 0,
+                language: "TypeScript",
+                npm: {
+                    package: packageJson.name,
+                    v0Version: null,
+                    v1Version: null,
+                    v2Version: version,
+                },
+                git: {
+                    v0Branch: null,
+                    v1Branch: null,
+                    v2Branch: "main",
+                },
+                supports: { v0: false, v1: false, v2: true },
+                localPath,
+            });
+        }
+    }
+    return discovered;
+}
+export async function applyNodeModulePlugins(plugins) {
+    const localPlugins = await discoverNodeModulePlugins();
+    if (localPlugins.size === 0)
+        return;
+    for (const [name, localInfo] of localPlugins.entries()) {
+        const existing = plugins.get(name);
+        if (!existing) {
+            plugins.set(name, localInfo);
+        }
+        else if (!existing.localPath) {
+            plugins.set(name, { ...existing, localPath: localInfo.localPath });
+        }
+    }
+}
+export async function applyLocalWorkspaceApps(plugins) {
+    const localApps = await discoverLocalWorkspaceApps();
+    if (localApps.size === 0)
+        return;
+    for (const [name, localInfo] of localApps.entries()) {
+        const existing = plugins.get(name);
+        if (!existing) {
+            plugins.set(name, localInfo);
+            continue;
+        }
+        plugins.set(name, {
+            ...existing,
+            localPath: localInfo.localPath,
+            kind: localInfo.kind ?? existing.kind,
+            appMeta: mergeAppMeta(existing.appMeta, localInfo.appMeta),
+            description: localInfo.description || existing.description,
+            homepage: localInfo.homepage ?? existing.homepage,
+            npm: {
+                ...existing.npm,
+                package: existing.npm.package || localInfo.npm.package,
+                v2Version: existing.npm.v2Version ?? localInfo.npm.v2Version,
+            },
+            git: {
+                v0Branch: existing.git.v0Branch ?? localInfo.git.v0Branch,
+                v1Branch: existing.git.v1Branch ?? localInfo.git.v1Branch,
+                v2Branch: existing.git.v2Branch ?? localInfo.git.v2Branch,
+            },
+        });
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { RegistryPluginInfo } from "./registry-client-types.js";
+export declare function fetchFromNetwork(params: {
+    generatedRegistryUrl: string;
+    indexRegistryUrl: string;
+    applyLocalWorkspaceApps: (plugins: Map<string, RegistryPluginInfo>) => Promise<void>;
+    applyNodeModulePlugins: (plugins: Map<string, RegistryPluginInfo>) => Promise<void>;
+    sanitizeSandbox: (value?: string) => string;
+}): Promise<Map<string, RegistryPluginInfo>>;
+//# sourceMappingURL=registry-client-network.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry-client-network.d.ts","sourceRoot":"","sources":["../../../../../src/services/registry-client-network.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC7C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,uBAAuB,EAAE,CACvB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,KACrC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,sBAAsB,EAAE,CACtB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,KACrC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,eAAe,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CA+J3C"}

package/dist/packages/autonomous/src/services/registry-client-network.js

@@ -0,0 +1,109 @@
+import { createIntegrationTelemetrySpan } from "../diagnostics/integration-observability";
+export async function fetchFromNetwork(params) {
+    const { generatedRegistryUrl, indexRegistryUrl, applyLocalWorkspaceApps, applyNodeModulePlugins, sanitizeSandbox, } = params;
+    const generatedSpan = createIntegrationTelemetrySpan({
+        boundary: "marketplace",
+        operation: "fetch_generated_registry",
+    });
+    try {
+        const resp = await fetch(generatedRegistryUrl, { redirect: "error" });
+        if (resp.ok) {
+            const data = (await resp.json());
+            const plugins = new Map();
+            for (const [name, e] of Object.entries(data.registry)) {
+                const info = {
+                    name,
+                    gitRepo: e.git.repo,
+                    gitUrl: `https://github.com/${e.git.repo}.git`,
+                    description: e.description || "",
+                    homepage: e.homepage,
+                    topics: e.topics || [],
+                    stars: e.stargazers_count || 0,
+                    language: e.language || "TypeScript",
+                    npm: {
+                        package: e.npm.repo,
+                        v0Version: e.npm.v0,
+                        v1Version: e.npm.v1,
+                        v2Version: e.npm.v2,
+                    },
+                    git: {
+                        v0Branch: e.git.v0?.branch ?? null,
+                        v1Branch: e.git.v1?.branch ?? null,
+                        v2Branch: e.git.v2?.branch ?? null,
+                    },
+                    supports: e.supports,
+                };
+                if (e.kind === "app" || e.app) {
+                    info.kind = "app";
+                }
+                if (e.app) {
+                    info.appMeta = {
+                        displayName: e.app.displayName,
+                        category: e.app.category,
+                        launchType: e.app.launchType,
+                        launchUrl: e.app.launchUrl,
+                        icon: e.app.icon,
+                        capabilities: e.app.capabilities || [],
+                        minPlayers: e.app.minPlayers ?? null,
+                        maxPlayers: e.app.maxPlayers ?? null,
+                        uiExtension: e.app.uiExtension,
+                        viewer: e.app.viewer
+                            ? {
+                                ...e.app.viewer,
+                                sandbox: sanitizeSandbox(e.app.viewer.sandbox),
+                            }
+                            : undefined,
+                    };
+                }
+                plugins.set(name, info);
+            }
+            await applyLocalWorkspaceApps(plugins);
+            await applyNodeModulePlugins(plugins);
+            generatedSpan.success({ statusCode: resp.status });
+            return plugins;
+        }
+        generatedSpan.failure({ statusCode: resp.status, errorKind: "http_error" });
+    }
+    catch (err) {
+        generatedSpan.failure({ error: err });
+        // caller logs fallback warnings
+    }
+    const indexSpan = createIntegrationTelemetrySpan({
+        boundary: "marketplace",
+        operation: "fetch_index_registry",
+    });
+    let resp;
+    try {
+        resp = await fetch(indexRegistryUrl, { redirect: "error" });
+    }
+    catch (err) {
+        indexSpan.failure({ error: err });
+        throw err;
+    }
+    if (!resp.ok) {
+        indexSpan.failure({ statusCode: resp.status, errorKind: "http_error" });
+        throw new Error(`index.json: ${resp.status} ${resp.statusText}`);
+    }
+    const data = (await resp.json());
+    const plugins = new Map();
+    for (const [name, gitRef] of Object.entries(data)) {
+        const repo = gitRef.replace(/^github:/, "");
+        plugins.set(name, {
+            name,
+            gitRepo: repo,
+            gitUrl: `https://github.com/${repo}.git`,
+            description: "",
+            homepage: null,
+            topics: [],
+            stars: 0,
+            language: "TypeScript",
+            npm: { package: name, v0Version: null, v1Version: null, v2Version: null },
+            git: { v0Branch: null, v1Branch: null, v2Branch: "next" },
+            supports: { v0: false, v1: false, v2: false },
+        });
+    }
+    await applyLocalWorkspaceApps(plugins);
+    await applyNodeModulePlugins(plugins);
+    indexSpan.success({ statusCode: resp.status });
+    return plugins;
+}

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

@@ -0,0 +1,15 @@
+import type { RegistryAppInfo, RegistryPluginInfo, RegistryPluginListItem, RegistrySearchResult } from "./registry-client-types.js";
+export declare function normalizePluginLookupAlias(name: string): string;
+export declare function getPluginInfoFromRegistry(registry: Map<string, RegistryPluginInfo>, name: string): RegistryPluginInfo | null;
+export declare function scoreEntries(entries: Iterable<RegistryPluginInfo>, query: string, limit: number, extraNames?: (p: RegistryPluginInfo) => string[], extraTerms?: (p: RegistryPluginInfo) => string[]): Array<{
+    p: RegistryPluginInfo;
+    s: number;
+}>;
+export declare function toSearchResults(results: Array<{
+    p: RegistryPluginInfo;
+    s: number;
+}>): RegistrySearchResult[];
+export declare function toAppInfo(p: RegistryPluginInfo, sanitizeSandbox: (value?: string) => string, defaultSandbox: string): RegistryAppInfo;
+export declare function toAppEntry(p: RegistryPluginInfo, resolveAppOverride: (packageName: string, appMeta: RegistryPluginInfo["appMeta"]) => RegistryPluginInfo["appMeta"]): RegistryPluginInfo | null;
+export declare function toPluginListItem(p: RegistryPluginInfo): RegistryPluginListItem;
+//# sourceMappingURL=registry-client-queries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry-client-queries.d.ts","sourceRoot":"","sources":["../../../../../src/services/registry-client-queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AAEpC,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAU/D;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EACzC,IAAI,EAAE,MAAM,GACX,kBAAkB,GAAG,IAAI,CAkB3B;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EACrC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,kBAAkB,KAAK,MAAM,EAAE,EAChD,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,kBAAkB,KAAK,MAAM,EAAE,GAC/C,KAAK,CAAC;IAAE,CAAC,EAAE,kBAAkB,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAiC7C;AAED,wBAAgB,eAAe,CAC7B,OAAO,EAAE,KAAK,CAAC;IAAE,CAAC,EAAE,kBAAkB,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACnD,oBAAoB,EAAE,CAYxB;AAED,wBAAgB,SAAS,CACvB,CAAC,EAAE,kBAAkB,EACrB,eAAe,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,EAC3C,cAAc,EAAE,MAAM,GACrB,eAAe,CAiCjB;AAED,wBAAgB,UAAU,CACxB,CAAC,EAAE,kBAAkB,EACrB,kBAAkB,EAAE,CAClB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,kBAAkB,CAAC,SAAS,CAAC,KACnC,kBAAkB,CAAC,SAAS,CAAC,GACjC,kBAAkB,GAAG,IAAI,CAgB3B;AAED,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,kBAAkB,GACpB,sBAAsB,CAWxB"}

package/dist/packages/autonomous/src/services/registry-client-queries.js

@@ -0,0 +1,150 @@
+export function normalizePluginLookupAlias(name) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        return trimmed;
+    const lower = trimmed.toLowerCase();
+    if (lower === "obsidan")
+        return "obsidian";
+    if (lower === "plugin-obsidan")
+        return "plugin-obsidian";
+    if (lower === "@elizaos/plugin-obsidan")
+        return "@elizaos/plugin-obsidian";
+    return trimmed;
+}
+export function getPluginInfoFromRegistry(registry, name) {
+    let p = registry.get(name);
+    if (p)
+        return p;
+    if (!name.startsWith("@")) {
+        p = registry.get(`@elizaos/${name}`);
+        if (p)
+            return p;
+        p = registry.get(`@elizaos/plugin-${name}`);
+        if (p)
+            return p;
+    }
+    const bare = name.replace(/^@[^/]+\//, "");
+    for (const [key, value] of registry) {
+        if (key.endsWith(`/${bare}`))
+            return value;
+    }
+    return null;
+}
+export function scoreEntries(entries, query, limit, extraNames, extraTerms) {
+    const lq = query.toLowerCase();
+    const terms = lq.split(/\s+/).filter((t) => t.length > 1);
+    const scored = [];
+    for (const p of entries) {
+        const ln = p.name.toLowerCase();
+        const ld = p.description.toLowerCase();
+        const aliases = extraNames?.(p) ?? [];
+        let s = 0;
+        if (ln === lq || ln === `@elizaos/${lq}` || aliases.some((a) => a === lq))
+            s += 100;
+        else if (ln.includes(lq) || aliases.some((a) => a.includes(lq)))
+            s += 50;
+        if (ld.includes(lq))
+            s += 30;
+        for (const t of p.topics)
+            if (t.toLowerCase().includes(lq))
+                s += 25;
+        for (const t of extraTerms?.(p) ?? [])
+            if (t.toLowerCase().includes(lq))
+                s += 25;
+        for (const term of terms) {
+            if (ln.includes(term) || aliases.some((a) => a.includes(term)))
+                s += 15;
+            if (ld.includes(term))
+                s += 10;
+            for (const t of p.topics)
+                if (t.toLowerCase().includes(term))
+                    s += 8;
+        }
+        if (s > 0) {
+            if (p.stars > 100)
+                s += 3;
+            if (p.stars > 500)
+                s += 3;
+            if (p.stars > 1000)
+                s += 4;
+            scored.push({ p, s });
+        }
+    }
+    scored.sort((a, b) => b.s - a.s || b.p.stars - a.p.stars);
+    return scored.slice(0, limit);
+}
+export function toSearchResults(results) {
+    const max = results[0]?.s || 1;
+    return results.map(({ p, s }) => ({
+        name: p.name,
+        description: p.description,
+        score: s / max,
+        tags: p.topics,
+        latestVersion: p.npm.v2Version || p.npm.v1Version || p.npm.v0Version,
+        stars: p.stars,
+        supports: p.supports,
+        repository: `https://github.com/${p.gitRepo}`,
+    }));
+}
+export function toAppInfo(p, sanitizeSandbox, defaultSandbox) {
+    const meta = p.appMeta;
+    const viewer = meta?.viewer
+        ? {
+            url: meta.viewer.url,
+            embedParams: meta.viewer.embedParams,
+            postMessageAuth: meta.viewer.postMessageAuth,
+            sandbox: sanitizeSandbox(meta.viewer.sandbox),
+        }
+        : meta?.launchType === "connect" || meta?.launchType === "local"
+            ? {
+                url: meta?.launchUrl ?? "",
+                sandbox: defaultSandbox,
+            }
+            : undefined;
+    return {
+        name: p.name,
+        displayName: meta?.displayName ?? p.name.replace(/^@elizaos\/app-/, ""),
+        description: p.description,
+        category: meta?.category ?? "game",
+        launchType: meta?.launchType ?? "url",
+        launchUrl: meta?.launchUrl ?? p.homepage,
+        icon: meta?.icon ?? null,
+        capabilities: meta?.capabilities ?? [],
+        stars: p.stars,
+        repository: `https://github.com/${p.gitRepo}`,
+        latestVersion: p.npm.v2Version || p.npm.v1Version || p.npm.v0Version,
+        supports: p.supports,
+        npm: p.npm,
+        uiExtension: meta?.uiExtension,
+        viewer,
+    };
+}
+export function toAppEntry(p, resolveAppOverride) {
+    if (p.kind === "app" || p.appMeta) {
+        return {
+            ...p,
+            kind: "app",
+            appMeta: p.appMeta,
+        };
+    }
+    const appMeta = resolveAppOverride(p.name, undefined);
+    if (!appMeta)
+        return null;
+    return {
+        ...p,
+        kind: "app",
+        appMeta,
+    };
+}
+export function toPluginListItem(p) {
+    return {
+        name: p.name,
+        description: p.description,
+        stars: p.stars,
+        repository: `https://github.com/${p.gitRepo}`,
+        topics: p.topics,
+        latestVersion: p.npm.v2Version || p.npm.v1Version || p.npm.v0Version,
+        supports: p.supports,
+        npm: p.npm,
+    };
+}