Spaces:
Running
Running
| import { access, cp } from "node:fs/promises"; | |
| import path from "node:path"; | |
| import { runInherit, runQuiet } from "./exec.js"; | |
| import { sourcePath, venvBin } from "./paths.js"; | |
| import type { PluginSource } from "../types.js"; | |
| export interface PluginSearchResult { | |
| name: string; | |
| version: string; | |
| description: string; | |
| source: PluginSource; | |
| path?: string; | |
| } | |
| interface LocalPluginManifest { | |
| name: string; | |
| version: string; | |
| path: string; | |
| description: string; | |
| } | |
| function pluginScript(script: string): string[] { | |
| return ["-c", script]; | |
| } | |
| async function runPluginJson<T>(script: string): Promise<T> { | |
| const result = await runQuiet(venvBin("python"), pluginScript(script), { | |
| cwd: sourcePath(), | |
| }); | |
| if (!result.ok) { | |
| const details = result.stderr.trim() || result.stdout.trim() || "unknown error"; | |
| throw new Error(details); | |
| } | |
| const text = result.stdout.trim(); | |
| if (!text) { | |
| throw new Error("Plugin command returned empty output"); | |
| } | |
| return JSON.parse(text) as T; | |
| } | |
| export async function listInstalledPlugins(): Promise<PluginSearchResult[]> { | |
| const script = [ | |
| "import json", | |
| "from src.core.plugins.manager import PluginManager", | |
| "manager = PluginManager(plugins_dir=__import__('pathlib').Path('plugins'), registry_url=None)", | |
| "plugins = manager.list_installed()", | |
| "print(json.dumps([{'name': p.name, 'version': p.version, 'description': p.description or ''} for p in plugins]))", | |
| ].join(";"); | |
| const installed = await runPluginJson<Array<{ name: string; version: string; description: string }>>(script); | |
| return installed.map((plugin) => ({ ...plugin, source: "local" })); | |
| } | |
| async function listRegistryPlugins(): Promise<PluginSearchResult[]> { | |
| const script = [ | |
| "import json", | |
| "from src.core.plugins.manager import PluginManager", | |
| "registry_url = __import__('os').getenv('PLUGIN_REGISTRY_URL', 'https://registry.brain-api.dev')", | |
| "manager = PluginManager(plugins_dir=__import__('pathlib').Path('plugins'), registry_url=registry_url)", | |
| "plugins = manager.list_available()", | |
| "print(json.dumps([{'name': p.name, 'version': p.version, 'description': p.description or ''} for p in plugins]))", | |
| ].join(";"); | |
| const available = await runPluginJson<Array<{ name: string; version: string; description: string }>>(script); | |
| return available.map((plugin) => ({ ...plugin, source: "registry" })); | |
| } | |
| async function listWorkspacePlugins(): Promise<LocalPluginManifest[]> { | |
| const script = [ | |
| "import json", | |
| "from pathlib import Path", | |
| "from src.core.plugins.manifest import MANIFEST_FILENAME, parse_manifest", | |
| "base = Path.cwd() / 'plugins'", | |
| "results = []", | |
| "if base.exists():", | |
| " for child in sorted(base.iterdir()):", | |
| " manifest_path = child / MANIFEST_FILENAME", | |
| " if not manifest_path.exists():", | |
| " continue", | |
| " try:", | |
| " m = parse_manifest(manifest_path)", | |
| " except Exception:", | |
| " continue", | |
| " results.append({'name': m.name, 'version': m.version, 'description': m.description or '', 'path': str(child.resolve())})", | |
| "print(json.dumps(results))", | |
| ].join("\n"); | |
| return runPluginJson<LocalPluginManifest[]>(script); | |
| } | |
| export async function searchPlugins(query: string): Promise<PluginSearchResult[]> { | |
| const normalized = (query ?? "").trim().toLowerCase(); | |
| if (!normalized) return []; | |
| const [localInstalled, localWorkspace, registry] = await Promise.all([ | |
| listInstalledPlugins().catch(() => []), | |
| listWorkspacePlugins().catch(() => []), | |
| listRegistryPlugins().catch(() => []), | |
| ]); | |
| const workspaceCandidates: PluginSearchResult[] = localWorkspace.map((plugin) => ({ | |
| name: plugin.name, | |
| version: plugin.version, | |
| description: plugin.description ?? "", | |
| source: "local", | |
| path: plugin.path, | |
| })); | |
| const merged = [...localInstalled, ...workspaceCandidates, ...registry]; | |
| const dedup = new Map<string, PluginSearchResult>(); | |
| for (const candidate of merged) { | |
| if (!candidate?.name) continue; | |
| const key = `${candidate.source}:${candidate.name}:${candidate.path ?? ""}`; | |
| if (!dedup.has(key)) { | |
| dedup.set(key, { | |
| ...candidate, | |
| description: candidate.description ?? "", | |
| version: candidate.version ?? "0.0.0", | |
| }); | |
| } | |
| } | |
| return [...dedup.values()].filter((plugin) => | |
| plugin.name.toLowerCase().includes(normalized) || | |
| plugin.description.toLowerCase().includes(normalized), | |
| ); | |
| } | |
| export async function runPluginCli(args: string[]): Promise<void> { | |
| const result = await runInherit( | |
| venvBin("python"), | |
| ["-m", "src.core.plugins.cli", "plugins", ...args], | |
| { cwd: sourcePath() }, | |
| ); | |
| if (!result.ok) { | |
| throw new Error("Plugin command failed"); | |
| } | |
| } | |
| export async function installRegistryPlugin(name: string, version?: string): Promise<void> { | |
| const args = ["install", name]; | |
| if (version && version.trim()) { | |
| args.push("--version", version.trim()); | |
| } | |
| try { | |
| await runPluginCli(args); | |
| } catch { | |
| throw new Error(`Failed to install registry plugin '${name}'`); | |
| } | |
| } | |
| export async function uninstallPlugin(name: string): Promise<void> { | |
| try { | |
| await runPluginCli(["uninstall", name]); | |
| } catch { | |
| throw new Error(`Failed to uninstall plugin '${name}'`); | |
| } | |
| } | |
| async function resolveLocalPluginName(pluginPath: string): Promise<string> { | |
| const quotedPath = JSON.stringify(pluginPath); | |
| const script = [ | |
| "from pathlib import Path", | |
| "from src.core.plugins.manifest import MANIFEST_FILENAME, parse_manifest", | |
| `p = Path(${quotedPath})`, | |
| "manifest = p / MANIFEST_FILENAME", | |
| "if not manifest.exists():", | |
| " raise SystemExit('plugin.yaml not found')", | |
| "parsed = parse_manifest(manifest)", | |
| "print(parsed.name)", | |
| ].join("\n"); | |
| const result = await runQuiet(venvBin("python"), pluginScript(script), { cwd: sourcePath() }); | |
| if (!result.ok) { | |
| throw new Error(result.stderr.trim() || result.stdout.trim() || "Invalid local plugin"); | |
| } | |
| const name = result.stdout.trim(); | |
| if (!name) throw new Error("Invalid local plugin manifest"); | |
| return name; | |
| } | |
| export async function installLocalPlugin(pluginPath: string): Promise<string> { | |
| await access(pluginPath); | |
| const name = await resolveLocalPluginName(pluginPath); | |
| const targetPath = path.join(sourcePath(), "plugins", name); | |
| await cp(pluginPath, targetPath, { recursive: true, force: true }); | |
| return name; | |
| } | |