@schlenkr/ragents 0.1.4 → 0.1.6

package/apps/server/src/profile/plugin-discovery.ts

@@ -1,79 +1,108 @@
-import { readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import type { PluginWebAddresses } from "@ragents/engine";
+import { announceBundles } from "../host-resolution.js";
+import { checkedHostApiRecord } from "../host-version.js";
 import { isPluginModule, type PluginModule } from "../plugin-support/plugin-module.js";
 import {
+  bundlesRoot,
   isPluginPath,
-  PLUGIN_SERVER_FOLDER,
   pluginFolderFor,
   pluginIdOf,
   pluginsRoot,
   registerPluginFolder,
 } from "../plugin-support/plugins-root.js";
+import { assertHostNames, BUNDLE_MANIFEST_FILE, isBuiltInBundle, readBundleManifest, sourceStandOf, type BundleManifest } from "./bundle-manifest.js";
 
-const ENTRY_FILES = ["index.ts", "index.js"] as const;
-
-const entryFile = (folder: string): string | undefined =>
-  ENTRY_FILES
-    .map((name) => path.join(folder, PLUGIN_SERVER_FOLDER, name))
-    .find((candidate) => statSync(candidate, { throwIfNoEntry: false })?.isFile() === true);
-
-const assertEntryFile = (folder: string): string => {
-  const entry = entryFile(folder);
-  if (entry) return entry;
-  throw new Error(
-    `Der Plugin-Ordner ${folder} hat keinen Einstiegspunkt; erwartet wird `
-    + `${ENTRY_FILES.map((name) => `${PLUGIN_SERVER_FOLDER}/${name}`).join(" oder ")} `
-    + "mit \"export const plugin: PluginModule\"");
-};
-
-export const discoverPluginIds = (root = pluginsRoot): readonly string[] => {
+/** The built-in bundles; build folders of the build tool start with a dot and do not count. */
+export const discoverPluginIds = (root = bundlesRoot): readonly string[] => {
+  if (!existsSync(root)) return [];
   const folders = readdirSync(root, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
     .map((entry) => entry.name)
     .sort();
-  for (const id of folders) assertEntryFile(path.join(root, id));
+  for (const id of folders) {
+    if (!existsSync(path.join(root, id, BUNDLE_MANIFEST_FILE))) throw new Error(`${path.join(root, id)} ist kein Bundle: ${BUNDLE_MANIFEST_FILE} fehlt`);
+  }
   return folders;
 };
 
 export interface ResolvedPlugin {
   readonly id: string;
   readonly folder: string;
+  readonly manifest: BundleManifest;
 }
 
-/** Resolves the profile's entries to folders; ids come from plugins/, paths from anywhere on disk. */
+const builtInFolder = (id: string, root: string): string => {
+  const folder = path.join(root, id);
+  if (statSync(folder, { throwIfNoEntry: false })?.isDirectory()) return folder;
+  if (existsSync(path.join(pluginsRoot, id, "ragents-plugin.json"))) {
+    throw new Error(`Das eingebaute Plugin ${id} ist nicht gebaut: ${folder} fehlt; im Checkout mit pnpm build:plugins bauen`);
+  }
+  throw new Error(`Unbekanntes Plugin ${id}; eingebaut sind: ${discoverPluginIds(root).join(", ")}`);
+};
+
+/** Resolves the profile's entries to bundles; ids come from bundles/, paths from anywhere on disk. */
 export const resolvePluginEntries = (
   entries: readonly string[],
   base = process.cwd(),
-  root = pluginsRoot,
+  root = bundlesRoot,
 ): readonly ResolvedPlugin[] => {
-  const known = discoverPluginIds(root);
+  const record = checkedHostApiRecord();
   const resolved = entries.map((entry) => {
-    if (!isPluginPath(entry) && !known.includes(entry)) {
-      throw new Error(`Unbekanntes Plugin ${entry}; gefunden wurden: ${known.join(", ")}`);
-    }
-    const folder = pluginFolderFor(entry, base, root);
+    const folder = isPluginPath(entry) ? pluginFolderFor(entry, base, root) : builtInFolder(entry, root);
     if (!statSync(folder, { throwIfNoEntry: false })?.isDirectory()) {
       throw new Error(`Das Plugin ${entry} hat keinen Ordner ${folder}`);
     }
-    assertEntryFile(folder);
-    return { id: pluginIdOf(folder), folder };
+    const manifest = readBundleManifest(folder);
+    assertHostNames(folder, manifest, record);
+    return { id: pluginIdOf(folder), folder, manifest };
   });
   const duplicate = resolved.find((plugin, index) => resolved.findIndex((other) => other.id === plugin.id) !== index);
   if (duplicate) throw new Error(`Plugin ${duplicate.id} steht mehrfach in der Pluginliste`);
   return resolved;
 };
 
-const loadPluginModule = async (folder: string): Promise<PluginModule> => {
-  const entry = assertEntryFile(folder);
-  const loaded = await import(pathToFileURL(entry).href) as Record<string, unknown>;
-  const module = loaded.plugin;
-  if (!isPluginModule(module)) {
-    throw new Error(
-      `${entry} exportiert keinen gültigen Einstiegspunkt; erwartet wird `
-      + "\"export const plugin: PluginModule\" mit einer create-Funktion");
+/** The addresses of a web half: the host serves each bundle's web folder under /plugins/<id>/web/. */
+export const webAddressesOf = (plugin: ResolvedPlugin): PluginWebAddresses | undefined => {
+  const web = plugin.manifest.web;
+  if (web === undefined) return undefined;
+  const address = (file: string): string => `/plugins/${plugin.id}/${file}`;
+  return { entry: address(web.entry), ...(web.css === undefined ? {} : { css: address(web.css) }) };
+};
+
+/** The built-in bundles of the profile whose plugin sources changed since they were built; only a checkout has those sources. */
+export const staleBuiltInBundles = (plugins: readonly ResolvedPlugin[], sources = pluginsRoot, root = bundlesRoot): readonly string[] =>
+  plugins.filter((plugin) => isBuiltInBundle(plugin.folder, root)
+    && existsSync(path.join(sources, plugin.id, "ragents-plugin.json"))
+    && sourceStandOf(path.join(sources, plugin.id)) !== plugin.manifest.sourceStand)
+    .map((plugin) => plugin.id);
+
+const assertUsesInProfile = (plugins: readonly ResolvedPlugin[]): void => {
+  const ids = new Set(plugins.map((plugin) => plugin.id));
+  for (const plugin of plugins) {
+    const missing = plugin.manifest.uses.find((used) => !ids.has(used));
+    if (missing !== undefined) throw new Error(`Plugin ${plugin.id} benötigt das fehlende Plugin ${missing}; sein Bundle importiert dessen Exporte`);
+  }
+};
+
+/** Imports the server entry of every bundle; the loader thread learns their folders first, so cross imports resolve. */
+export const importBundles = async (plugins: readonly ResolvedPlugin[]): Promise<ReadonlyMap<string, Readonly<Record<string, unknown>>>> => {
+  assertUsesInProfile(plugins);
+  await announceBundles(new Map(plugins.map((plugin) => [plugin.id, realpathSync.native(plugin.folder)])));
+  const loaded = new Map<string, Readonly<Record<string, unknown>>>();
+  for (const plugin of plugins) {
+    registerPluginFolder(plugin.id, plugin.folder);
+    const entry = realpathSync.native(path.join(plugin.folder, plugin.manifest.server));
+    try {
+      loaded.set(plugin.id, await import(pathToFileURL(entry).href) as Record<string, unknown>);
+    } catch (cause) {
+      const reason = cause instanceof Error ? cause.message : String(cause);
+      throw new Error(`Das Bundle ${plugin.id} lädt nicht: ${reason}`, { cause });
+    }
   }
-  return module;
+  return loaded;
 };
 
 const assertRequires = (ids: readonly string[], modules: ReadonlyMap<string, PluginModule>): void => {
@@ -87,26 +116,49 @@ const assertRequires = (ids: readonly string[], modules: ReadonlyMap<string, Plu
   }
 };
 
+const assertUsesRequired = (plugins: readonly ResolvedPlugin[], modules: ReadonlyMap<string, PluginModule>): void => {
+  for (const plugin of plugins) {
+    const requires = modules.get(plugin.id)?.requires ?? [];
+    const undeclared = plugin.manifest.uses.filter((used) => !requires.includes(used));
+    if (undeclared.length > 0) {
+      throw new Error(`Das Bundle ${plugin.id} importiert Exporte von ${undeclared.join(", ")}, nennt es aber nicht in requires seines Modulvertrags`);
+    }
+  }
+};
+
 export interface LoadedPlugins {
   readonly known: readonly string[];
   readonly ids: readonly string[];
   readonly modules: ReadonlyMap<string, PluginModule>;
+  readonly bundles: readonly ResolvedPlugin[];
+  /** The plugins whose bundle carries a web half, with the addresses the browser loads it from. */
+  readonly web: ReadonlyMap<string, PluginWebAddresses>;
 }
 
 export const loadPlugins = async (
   entries: readonly string[],
-  root = pluginsRoot,
+  root = bundlesRoot,
   base = process.cwd(),
 ): Promise<LoadedPlugins> => {
   const plugins = resolvePluginEntries(entries, base, root);
   const discovered = discoverPluginIds(root);
   const known = [...discovered, ...plugins.map((plugin) => plugin.id).filter((id) => !discovered.includes(id))];
-  const modules = new Map<string, PluginModule>();
-  for (const plugin of plugins) {
-    registerPluginFolder(plugin.id, plugin.folder);
-    modules.set(plugin.id, await loadPluginModule(plugin.folder));
-  }
+  const imported = await importBundles(plugins);
+  const modules = new Map(plugins.map((plugin) => {
+    const module = imported.get(plugin.id)?.plugin;
+    if (!isPluginModule(module)) {
+      throw new Error(
+        `Das Bundle ${plugin.id} exportiert in ${plugin.manifest.server} keinen gültigen Einstiegspunkt; erwartet wird `
+        + "\"export const plugin: PluginModule\" mit einer create-Funktion");
+    }
+    return [plugin.id, module] as const;
+  }));
   const ids = plugins.map((plugin) => plugin.id);
   assertRequires(ids, modules);
-  return { known, ids, modules };
+  assertUsesRequired(plugins, modules);
+  const web = new Map(plugins.flatMap((plugin) => {
+    const addresses = webAddressesOf(plugin);
+    return addresses === undefined ? [] : [[plugin.id, addresses] as const];
+  }));
+  return { known, ids, modules, bundles: plugins, web };
 };

package/apps/server/src/profile/provisioning.ts

@@ -1,27 +1,18 @@
-import { statSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { hostDataDirectory, pluginToolsDirectory } from "@aicontainer/workspace-executor/src/tools.ts";
+import { hostDataDirectory, pluginToolsDirectory } from "@ragents/workspace-executor/src/tools.ts";
 import { isPluginProvision, type PluginProvision } from "../plugin-support/provision.js";
-import { resolvePluginEntries, type ResolvedPlugin } from "./plugin-discovery.js";
+import { importBundles, resolvePluginEntries, type ResolvedPlugin } from "./plugin-discovery.js";
 
-/** Die Sprachserver, die jeder Arbeitsplatz-Executor anbietet und deren Werkzeuge auf seiner Maschine liegen. */
-export const WORKSPACE_PROVISION_PLUGINS = ["ragents.lsp-roslyn", "ragents.lsp-fsharp"] as const;
+/** Die Plugins, deren Werkzeuge jeder Arbeitsplatz-Executor auf seiner Maschine braucht: Sprachserver und Browser. */
+export const WORKSPACE_PROVISION_PLUGINS = ["ragents.lsp-roslyn", "ragents.lsp-fsharp", "ragents.browser"] as const;
 
-const ENTRY_FILES = ["provision.ts", "provision.js"] as const;
-
-export const provisionEntry = (folder: string): string | undefined =>
-  ENTRY_FILES
-    .map((name) => path.join(folder, name))
-    .find((candidate) => statSync(candidate, { throwIfNoEntry: false })?.isFile() === true);
-
-export const loadProvision = async (entry: string): Promise<PluginProvision> => {
-  const loaded = await import(pathToFileURL(entry).href) as Record<string, unknown>;
-  if (!isPluginProvision(loaded.provision)) {
-    throw new Error(`${entry} exportiert keine Provisionierung; erwartet wird "export const provision: PluginProvision" mit check und apply`);
+/** The provisioning a bundle exports next to its plugin, if it brings one. */
+const provisionOf = (plugin: ResolvedPlugin, exported: Readonly<Record<string, unknown>>): PluginProvision | undefined => {
+  if (exported.provision === undefined) return undefined;
+  if (!isPluginProvision(exported.provision)) {
+    throw new Error(`Das Bundle ${plugin.id} exportiert eine ungültige Provisionierung; erwartet wird "export const provision: PluginProvision" mit check und apply`);
   }
-  return loaded.provision;
+  return exported.provision;
 };
 
 export type ProvisionOutcome = "ready" | "installed" | "missing";
@@ -40,13 +31,12 @@ const reason = (cause: unknown): string => cause instanceof Error ? cause.messag
 
 const provisionPlugin = async (
   plugin: ResolvedPlugin,
-  entry: string,
+  provision: PluginProvision,
   dataDirectory: string,
   log: (line: string) => void,
 ): Promise<PluginProvisionReport> => {
   const target = pluginToolsDirectory(dataDirectory, plugin.id);
   try {
-    const provision = await loadProvision(entry);
     const state = await provision.check(target);
     if (state.kind === "ready") return { id: plugin.id, target, outcome: "ready" };
     if (!state.installable) return { id: plugin.id, target, outcome: "missing", reason: state.instruction };
@@ -60,22 +50,36 @@ const provisionPlugin = async (
   }
 };
 
-/** Provisioniert jedes Plugin, das eine provision.ts mitbringt, in seinen Werkzeugordner unterhalb des Datenordners. */
+/** Provisioniert jedes Plugin, dessen Bundle eine Provisionierung exportiert, in seinen Werkzeugordner unterhalb des Datenordners. */
 export const provisionPlugins = async (
   plugins: readonly ResolvedPlugin[],
   dataDirectory: string,
   log: (line: string) => void,
 ): Promise<readonly PluginProvisionReport[]> => {
+  const exported = await importBundles(plugins);
   const reports: PluginProvisionReport[] = [];
   for (const plugin of plugins) {
-    const entry = provisionEntry(plugin.folder);
-    if (!entry) continue;
-    const report = await provisionPlugin(plugin, entry, dataDirectory, log);
+    const provision = provisionOf(plugin, exported.get(plugin.id) ?? {});
+    if (!provision) continue;
+    const report = await provisionPlugin(plugin, provision, dataDirectory, log);
     log(provisionReportLine(report));
     reports.push(report);
   }
   return reports;
 };
 
+/** Die genannten eingebauten Bundles samt allen, deren Exporte sie importieren; ohne diese lädt ein Bundle nicht. */
+const withUsedBundles = (ids: readonly string[]): readonly ResolvedPlugin[] => {
+  const resolved = new Map<string, ResolvedPlugin>();
+  const visit = (id: string): void => {
+    if (resolved.has(id)) return;
+    const [plugin] = resolvePluginEntries([id]);
+    resolved.set(id, plugin!);
+    for (const used of plugin!.manifest.uses) visit(used);
+  };
+  for (const id of ids) visit(id);
+  return [...resolved.values()];
+};
+
 export const provisionWorkspace = (log: (line: string) => void): Promise<readonly PluginProvisionReport[]> =>
-  provisionPlugins(resolvePluginEntries([...WORKSPACE_PROVISION_PLUGINS]), hostDataDirectory(), log);
+  provisionPlugins(withUsedBundles(WORKSPACE_PROVISION_PLUGINS), hostDataDirectory(), log);

package/apps/server/src/profile-target.ts

@@ -44,6 +44,9 @@ export const readProfileTarget = async (profile: string, profileFile: string, en
   const port = Number(environment.PORT || module.config.host.PORT);
   if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`host.PORT des Profils ${profile} ist keine gültige Portnummer.`);
   const configured = module.config.host.DATA_DIR;
+  if (isEnvironmentReference(configured) && environment.DATA_DIR === undefined && environment[configured.name] === undefined) {
+    throw new Error(`host.DATA_DIR des Profils ${profile} verweist auf die nicht gesetzte Umgebungsvariable ${configured.name}.`);
+  }
   const fromFile = isEnvironmentReference(configured) ? environment[configured.name] : typeof configured === "string" ? configured : undefined;
   const dataDirectory = path.resolve(environment.DATA_DIR ?? fromFile ?? defaultDataDirectory(profile));
   return { profile, profileFile, port, dataDirectory, baseUrl: `http://localhost:${port}` };