@schlenkr/ragents 0.1.10 → 0.1.12

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

@@ -14,7 +14,7 @@ import {
   pluginsRoot,
   registerPluginFolder,
 } from "../plugin-support/plugins-root.js";
-import { assertHostNames, BUNDLE_MANIFEST_FILE, isBuiltInBundle, readBundleManifest, sourceStandOf, type BundleManifest } from "./bundle-manifest.js";
+import { assertHostNames, BUNDLE_MANIFEST_FILE, isBuiltInBundle, readBundleManifest, sourceRevisionOf, type BundleManifest } from "./bundle-manifest.js";
 
 /** 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[] => {
@@ -24,7 +24,7 @@ export const discoverPluginIds = (root = bundlesRoot): readonly string[] => {
     .map((entry) => entry.name)
     .sort();
   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`);
+    if (!existsSync(path.join(root, id, BUNDLE_MANIFEST_FILE))) throw new Error(`${path.join(root, id)} is not a bundle: ${BUNDLE_MANIFEST_FILE} is missing`);
   }
   return folders;
 };
@@ -39,9 +39,9 @@ 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(`The built-in plugin ${id} is not built: ${folder} is missing; build it in the checkout with pnpm build:plugins`);
   }
-  throw new Error(`Unbekanntes Plugin ${id}; eingebaut sind: ${discoverPluginIds(root).join(", ")}`);
+  throw new Error(`Unknown plugin ${id}; built in are: ${discoverPluginIds(root).join(", ")}`);
 };
 
 /** Resolves the profile's entries to bundles; ids come from bundles/, paths from anywhere on disk. */
@@ -54,14 +54,14 @@ export const resolvePluginEntries = (
   const resolved = entries.map((entry) => {
     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}`);
+      throw new Error(`The plugin ${entry} has no 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`);
+  if (duplicate) throw new Error(`Plugin ${duplicate.id} appears more than once in the plugin list`);
   return resolved;
 };
 
@@ -77,14 +77,14 @@ export const webAddressesOf = (plugin: ResolvedPlugin): PluginWebAddresses | und
 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)
+    && sourceRevisionOf(path.join(sources, plugin.id)) !== plugin.manifest.sourceRevision)
     .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`);
+    if (missing !== undefined) throw new Error(`Plugin ${plugin.id} needs the missing plugin ${missing}; its bundle imports that plugin's exports`);
   }
 };
 
@@ -100,7 +100,7 @@ export const importBundles = async (plugins: readonly ResolvedPlugin[]): Promise
       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 });
+      throw new Error(`The bundle ${plugin.id} does not load: ${reason}`, { cause });
     }
   }
   return loaded;
@@ -111,8 +111,8 @@ const assertRequires = (ids: readonly string[], modules: ReadonlyMap<string, Plu
   for (const [index, id] of ids.entries()) {
     for (const dependency of modules.get(id)?.requires ?? []) {
       const position = positions.get(dependency);
-      if (position === undefined) throw new Error(`Plugin ${id} benötigt das fehlende Plugin ${dependency}`);
-      if (position >= index) throw new Error(`Plugin ${dependency} muss vor ${id} registriert werden`);
+      if (position === undefined) throw new Error(`Plugin ${id} needs the missing plugin ${dependency}`);
+      if (position >= index) throw new Error(`Plugin ${dependency} must be registered before ${id}`);
     }
   }
 };
@@ -122,7 +122,7 @@ const assertUsesRequired = (plugins: readonly ResolvedPlugin[], modules: Readonl
     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`);
+      throw new Error(`The bundle ${plugin.id} imports exports of ${undeclared.join(", ")}, but does not name it in requires of its module contract`);
     }
   }
 };
@@ -151,8 +151,8 @@ export const loadPlugins = async (
     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");
+        `The bundle ${plugin.id} exports no valid entry point in ${plugin.manifest.server}; expected is `
+        + "\"export const plugin: PluginModule\" with a create function");
     }
     return [plugin.id, module] as const;
   }));

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

@@ -7,7 +7,7 @@ import { discoverPluginIds, importBundles, resolvePluginEntries, type ResolvedPl
 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`);
+    throw new Error(`The bundle ${plugin.id} exports an invalid provisioning; expected is "export const provision: PluginProvision" with check and apply`);
   }
   return exported.provision;
 };
@@ -22,7 +22,7 @@ export interface PluginProvisionReport {
 }
 
 export const provisionReportLine = (report: PluginProvisionReport): string =>
-  `${report.id}: ${report.outcome === "ready" ? "bereit" : report.outcome === "installed" ? "installiert" : `fehlt: ${report.reason ?? "ohne Grund"}`}`;
+  `${report.id}: ${report.outcome === "ready" ? "ready" : report.outcome === "installed" ? "installed" : `missing: ${report.reason ?? "no reason"}`}`;
 
 const reason = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
 
@@ -47,7 +47,7 @@ const provisionPlugin = async (
   }
 };
 
-/** Provisioniert jedes Plugin, dessen Bundle eine Provisionierung exportiert, in seinen Werkzeugordner unterhalb des Datenordners. */
+/** Provisions every plugin whose bundle exports a provisioning into its tool folder below the data folder. */
 export const provisionPlugins = async (
   plugins: readonly ResolvedPlugin[],
   dataDirectory: string,
@@ -65,7 +65,7 @@ export const provisionPlugins = async (
   return reports;
 };
 
-/** Die genannten eingebauten Bundles samt allen, deren Exporte sie importieren; ohne diese lädt ein Bundle nicht. */
+/** The named built-in bundles plus all whose exports they import; without those, a bundle does not load. */
 const withUsedBundles = (ids: readonly string[]): readonly ResolvedPlugin[] => {
   const resolved = new Map<string, ResolvedPlugin>();
   const visit = (id: string): void => {
@@ -78,7 +78,7 @@ const withUsedBundles = (ids: readonly string[]): readonly ResolvedPlugin[] => {
   return [...resolved.values()];
 };
 
-/** Ein Arbeitsplatz hat kein Profil; er provisioniert die eingebauten Plugins seines Hosts, die zum Executor beitragen, denn deren Werkzeuge laufen auf ihm. */
+/** A workstation has no profile; it provisions the built-in plugins of its host that contribute to the executor, because their tools run on it. */
 export const workspaceProvisionPlugins = (): readonly ResolvedPlugin[] => withUsedBundles(
   resolvePluginEntries(discoverPluginIds()).filter((plugin) => plugin.manifest.executor !== undefined).map((plugin) => plugin.id));
 

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

@@ -21,10 +21,10 @@ export interface LocalProfile {
 
 const PROFILE_FILE = /^ragents\.config\.([a-z0-9]+(?:-[a-z0-9]+)*)\.ts$/;
 
-/** pnpm und der bin-Befehl führen die Skripte mit dem Arbeitsverzeichnis apps/server aus; ein relativer Pfad gilt trotzdem ab dem Aufrufer. */
+/** pnpm and the bin command run the scripts with the working directory apps/server; a relative path still applies from the caller. */
 export const callerDirectory = (): string => process.env.RAGENTS_CWD ?? process.env.INIT_CWD ?? process.cwd();
 
-/** Ein Profil ist ein Name neben dem Host (Checkout wie Paket) oder ein Pfad zu einer ragents.config.<profil>.ts an beliebiger Stelle. */
+/** A profile is a name next to the host (checkout as well as package) or a path to a ragents.config.<profile>.ts anywhere. */
 export const localProfile = (selection: string, root = hostRoot(), caller = callerDirectory()): LocalProfile | undefined => {
   if (!selection.includes("/") && !selection.endsWith(".ts")) {
     const file = path.join(root, profileFileName(selection));
@@ -32,29 +32,29 @@ export const localProfile = (selection: string, root = hostRoot(), caller = call
   }
   const profileFile = path.resolve(caller, selection);
   const match = PROFILE_FILE.exec(path.basename(profileFile));
-  if (!match) throw new Error(`Eine Profildatei heißt ragents.config.<profil>.ts, nicht ${path.basename(profileFile)}`);
-  if (!statSync(profileFile, { throwIfNoEntry: false })?.isFile()) throw new Error(`Die Profildatei fehlt: ${profileFile}`);
+  if (!match) throw new Error(`A profile file is named ragents.config.<profile>.ts, not ${path.basename(profileFile)}`);
+  if (!statSync(profileFile, { throwIfNoEntry: false })?.isFile()) throw new Error(`The profile file is missing: ${profileFile}`);
   return { profile: match[1]!, profileFile };
 };
 
-/** Port und Datenordner eines Profils, wie der Server sie später selbst bestimmt: Umgebung vor Profildatei vor Vorgabe. */
+/** Port and data folder of a profile, as the server determines them itself later: environment before profile file before default. */
 export const readProfileTarget = async (profile: string, profileFile: string, environment = process.env): Promise<ProfileTarget> => {
-  if (!statSync(profileFile, { throwIfNoEntry: false })?.isFile()) throw new Error(`Die Profildatei fehlt: ${profileFile}`);
+  if (!statSync(profileFile, { throwIfNoEntry: false })?.isFile()) throw new Error(`The profile file is missing: ${profileFile}`);
   const module = await import(pathToFileURL(profileFile).href) as { config: { host: { PORT?: number; DATA_DIR?: unknown } } };
   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.`);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`host.PORT of profile ${profile} is not a valid port number.`);
   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}.`);
+    throw new Error(`host.DATA_DIR of profile ${profile} refers to the unset environment variable ${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}` };
 };
 
-/** Die eine Auflösung für alle Befehle: Name oder Pfad zum Profil, danach Port und Datenordner wie beim Server. */
+/** The one resolution for all commands: name or path of the profile, then port and data folder as in the server. */
 export const selectProfileTarget = async (selection: string, root = hostRoot(), environment = process.env): Promise<ProfileTarget> => {
   const own = localProfile(selection, root);
-  if (!own) throw new Error(`Die Profildatei fehlt: ${path.join(root, profileFileName(selection))}`);
+  if (!own) throw new Error(`The profile file is missing: ${path.join(root, profileFileName(selection))}`);
   return readProfileTarget(own.profile, own.profileFile, environment);
 };

package/apps/server/src/protocol.ts

@@ -61,7 +61,7 @@ export class Protocol {
     this.written = statSync(this.file, { throwIfNoEntry: false })?.size ?? 0;
     this.stream = createWriteStream(this.file, { flags: "a", mode: 0o640 });
     this.stream.on("error", (error) => {
-      process.stderr.write(`Protokoll ${this.file} nicht schreibbar: ${error.message}\n`);
+      process.stderr.write(`Log ${this.file} not writable: ${error.message}\n`);
       this.stream = undefined;
     });
     return this.stream;
@@ -78,7 +78,7 @@ export class Protocol {
         if (statSync(from, { throwIfNoEntry: false })) renameSync(from, `${this.file}.${generation}`);
       }
     } catch (error) {
-      process.stderr.write(`Protokoll ${this.file} nicht rotierbar: ${(error as Error).message}\n`);
+      process.stderr.write(`Log ${this.file} cannot be rotated: ${(error as Error).message}\n`);
     }
   }
 }