@schlenkr/ragents 0.1.10 → 0.1.11

package/apps/server/src/plugin-support/zip.ts

@@ -15,16 +15,16 @@ const endOffset = (archive: Buffer): number => {
   for (let offset = archive.byteLength - 22; offset >= first; offset -= 1) {
     if (archive.readUInt32LE(offset) === END_OF_CENTRAL_DIRECTORY) return offset;
   }
-  throw new Error("Das Archiv hat kein Ende des Zentralverzeichnisses; es ist keine ZIP-Datei");
+  throw new Error("The archive has no end of central directory; it is not a ZIP file");
 };
 
 const contentOf = (archive: Buffer, localOffset: number, compression: number, compressedSize: number): Buffer => {
-  if (archive.readUInt32LE(localOffset) !== LOCAL_FILE_HEADER) throw new Error(`Der lokale Eintrag bei ${localOffset} fehlt im Archiv`);
+  if (archive.readUInt32LE(localOffset) !== LOCAL_FILE_HEADER) throw new Error(`The local entry at ${localOffset} is missing from the archive`);
   const start = localOffset + 30 + archive.readUInt16LE(localOffset + 26) + archive.readUInt16LE(localOffset + 28);
   const raw = archive.subarray(start, start + compressedSize);
   if (compression === 0) return Buffer.from(raw);
   if (compression === 8) return inflateRawSync(raw);
-  throw new Error(`Das Archiv verwendet die unbekannte Kompression ${compression}`);
+  throw new Error(`The archive uses the unknown compression ${compression}`);
 };
 
 interface DirectoryEntry {
@@ -34,20 +34,20 @@ interface DirectoryEntry {
   readonly localOffset: number;
 }
 
-/** Liest das Zentralverzeichnis; Zip64 und Verschlüsselung sind harte Fehler. */
+/** Reads the central directory; Zip64 and encryption are hard errors. */
 const readDirectory = (archive: Buffer): readonly DirectoryEntry[] => {
   const end = endOffset(archive);
   const count = archive.readUInt16LE(end + 10);
   const directory = archive.readUInt32LE(end + 16);
-  if (count === 0xffff || directory === 0xffffffff) throw new Error("Das Archiv ist Zip64; diese Form wird nicht gelesen");
+  if (count === 0xffff || directory === 0xffffffff) throw new Error("The archive is Zip64; this form is not read");
   const entries: DirectoryEntry[] = [];
   let offset = directory;
   for (let index = 0; index < count; index += 1) {
-    if (archive.readUInt32LE(offset) !== CENTRAL_FILE_HEADER) throw new Error(`Der Verzeichniseintrag ${index} fehlt im Archiv`);
+    if (archive.readUInt32LE(offset) !== CENTRAL_FILE_HEADER) throw new Error(`The directory entry ${index} is missing from the archive`);
     const flags = archive.readUInt16LE(offset + 8);
     const nameLength = archive.readUInt16LE(offset + 28);
     const name = archive.subarray(offset + 46, offset + 46 + nameLength).toString("utf8");
-    if ((flags & 0x1) !== 0) throw new Error(`Der Archiveintrag ${name} ist verschlüsselt`);
+    if ((flags & 0x1) !== 0) throw new Error(`The archive entry ${name} is encrypted`);
     if (!name.endsWith("/")) {
       entries.push({
         name,

package/apps/server/src/profile/bundle-manifest.ts

@@ -69,9 +69,9 @@ export const isFetchedBundle = (folder: string, dataRoot = ragentsDataRoot()): b
 
 /** How the author, or for a fetched bundle its user, gets a bundle that fits this host again. */
 export const rebuildHint = (folder: string): string => {
-  if (isBuiltInBundle(folder)) return "im Checkout mit pnpm build:plugins neu bauen";
-  if (isFetchedBundle(folder)) return "der Stand kommt von einem Server: mit ragents connect <server-url> neu holen, connect nennt die passende Host-Fassung";
-  return "mit ragents plugin build <quellordner> neu bauen";
+  if (isBuiltInBundle(folder)) return "rebuild in the checkout with pnpm build:plugins";
+  if (isFetchedBundle(folder)) return "this state comes from a server: fetch it again with ragents connect <server-url>, connect names the matching host version";
+  return "rebuild with ragents plugin build <source-folder>";
 };
 
 const SKIPPED_SOURCE_ENTRIES = new Set(["node_modules", ".DS_Store"]);
@@ -116,7 +116,7 @@ export const bundleStand = (folder: string): string => {
 /** A copy of a bundle, from a package or an archive, must carry exactly the files it was built with. */
 export const assertBundleStand = (folder: string, manifest: Pick<BundleManifest, "id" | "stand">): void => {
   if (bundleStand(folder) !== manifest.stand) {
-    throw new Error(`Das Bundle ${manifest.id} in ${folder} hat nicht mehr die Dateien, mit denen es gebaut wurde (stand); ${rebuildHint(folder)}`);
+    throw new Error(`The bundle ${manifest.id} in ${folder} no longer has the files it was built with (stand); ${rebuildHint(folder)}`);
   }
 };
 
@@ -133,8 +133,8 @@ const missingHostNames = (manifest: Pick<BundleManifest, "hostNames">, record: H
 export const assertHostNames = (folder: string, manifest: Pick<BundleManifest, "id" | "hostNames">, record: HostApiRecord): void => {
   const missing = missingHostNames(manifest, record);
   if (missing.length === 0) return;
-  throw new Error(`Das Bundle ${manifest.id} braucht aus der Host-API ${record.version} Namen, die dieser Host nicht anbietet (${missing.join("; ")}); `
-    + `es ist gegen einen neueren Host gebaut: den Host aktualisieren, sonst ${rebuildHint(folder)}`);
+  throw new Error(`The bundle ${manifest.id} needs names from host API ${record.version} that this host does not offer (${missing.join("; ")}); `
+    + `it was built against a newer host: update the host, otherwise ${rebuildHint(folder)}`);
 };
 
 /** Reads and checks the manifest; format and host API must match this host exactly. */
@@ -142,28 +142,28 @@ export const readBundleManifest = (folder: string): BundleManifest => {
   const file = path.join(folder, BUNDLE_MANIFEST_FILE);
   if (!statSync(file, { throwIfNoEntry: false })?.isFile()) {
     if (SOURCE_MARKERS.some((marker) => existsSync(path.join(folder, marker)))) {
-      throw new Error(`${folder} ist ein Quellordner, kein Bundle: mit ragents plugin build ${folder} bauen und im Profil den Bundle-Ordner nennen`);
+      throw new Error(`${folder} is a source folder, not a bundle: build it with ragents plugin build ${folder} and name the bundle folder in the profile`);
     }
-    throw new Error(`${folder} ist kein Bundle: ${BUNDLE_MANIFEST_FILE} fehlt`);
+    throw new Error(`${folder} is not a bundle: ${BUNDLE_MANIFEST_FILE} is missing`);
   }
   const id = pluginIdOf(folder);
   const raw = ((): unknown => {
     try {
       return JSON.parse(readFileSync(file, "utf8"));
     } catch (cause) {
-      throw new Error(`${file} ist kein gültiges JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
+      throw new Error(`${file} is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
     }
   })();
-  if (!isRecord(raw)) throw new Error(`${file} muss ein Objekt enthalten`);
+  if (!isRecord(raw)) throw new Error(`${file} must contain an object`);
   if (raw.format !== BUNDLE_FORMAT) {
-    throw new Error(`Das Bundle ${id} hat das Format ${String(raw.format)}, dieser Host liest Format ${BUNDLE_FORMAT}; ${rebuildHint(folder)}`);
+    throw new Error(`The bundle ${id} has format ${String(raw.format)}, this host reads format ${BUNDLE_FORMAT}; ${rebuildHint(folder)}`);
   }
-  if (raw.id !== id) throw new Error(`Das Bundle in ${folder} meldet die Kennung ${String(raw.id)}; die Kennung ist der Ordnername ${id}`);
+  if (raw.id !== id) throw new Error(`The bundle in ${folder} reports the id ${String(raw.id)}; the id is the folder name ${id}`);
   if (raw.api !== HOST_API_VERSION) {
-    throw new Error(`Das Bundle ${id} ist für Host-API ${String(raw.api)} gebaut, dieser Host bietet ${HOST_API_VERSION}; ${rebuildHint(folder)}`);
+    throw new Error(`The bundle ${id} is built for host API ${String(raw.api)}, this host offers ${HOST_API_VERSION}; ${rebuildHint(folder)}`);
   }
   const unknown = Object.keys(raw).filter((key) => !MANIFEST_KEYS.has(key));
-  if (unknown.length > 0) throw new Error(`${file}: unbekannte Felder ${unknown.join(", ")}; ${rebuildHint(folder)}`);
+  if (unknown.length > 0) throw new Error(`${file}: unknown fields ${unknown.join(", ")}; ${rebuildHint(folder)}`);
   const malformed = [
     ...(isHostNames(raw.hostNames) ? [] : ["hostNames"]),
     ...(typeof raw.stand === "string" ? [] : ["stand"]),
@@ -175,13 +175,13 @@ export const readBundleManifest = (folder: string): BundleManifest => {
     ...(isStringList(raw.uses) ? [] : ["uses"]),
     ...(isStringList(raw.assets) ? [] : ["assets"]),
   ];
-  if (malformed.length > 0) throw new Error(`${file}: ${malformed.join(", ")} fehlt oder hat die falsche Form; ${rebuildHint(folder)}`);
+  if (malformed.length > 0) throw new Error(`${file}: ${malformed.join(", ")} is missing or has the wrong shape; ${rebuildHint(folder)}`);
   const web = raw.web as BundleManifest["web"];
   const webFiles = web === undefined ? [] : [web.entry, web.classes, ...(web.css === undefined ? [] : [web.css])];
   const misplaced = webFiles.filter((entry) => !entry.startsWith("web/") || entry.split("/").includes(".."));
-  if (misplaced.length > 0) throw new Error(`${file}: ${misplaced.join(", ")} liegt nicht unter web/; ${rebuildHint(folder)}`);
+  if (misplaced.length > 0) throw new Error(`${file}: ${misplaced.join(", ")} is not under web/; ${rebuildHint(folder)}`);
   for (const required of [raw.server as string, ...webFiles, ...(raw.executor === undefined ? [] : [EXECUTOR_CONTRIBUTION_FILE])]) {
-    if (!statSync(path.join(folder, required), { throwIfNoEntry: false })?.isFile()) throw new Error(`Dem Bundle ${id} fehlt ${required}; ${rebuildHint(folder)}`);
+    if (!statSync(path.join(folder, required), { throwIfNoEntry: false })?.isFile()) throw new Error(`The bundle ${id} is missing ${required}; ${rebuildHint(folder)}`);
   }
   return raw as unknown as BundleManifest;
 };

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

@@ -2,6 +2,7 @@ import { PluginHost, type PluginWebAddresses } from "@ragents/engine";
 import { pluginToolsDirectory, prepareExecutorContribution, type LoadedExecutorContribution } from "@ragents/workspace-executor";
 import { config, HOST_SECRET_ENV_NAMES } from "../config.js";
 import { SESSION_MODE, SESSIONS_MODE } from "../layout.js";
+import { aliasCompletionModel, aliasCompletionModelToken } from "../plugin-support/model-completion.js";
 import { withFolderAssets } from "../plugin-support/plugin-folder.js";
 import type { PluginModule } from "../plugin-support/plugin-module.js";
 import { runManagementToken } from "../ragents/global-chat.js";
@@ -29,9 +30,9 @@ export interface ProfileComposition {
   readonly modules: ReadonlyMap<string, PluginModule>;
   /** The plugins with a web half and where the browser loads it; the web loads exactly these. */
   readonly web: ReadonlyMap<string, PluginWebAddresses>;
-  /** Die Beiträge der Bundles zum Executor; der Server baut sie mit den Werkzeugordnern seines Datenordners. */
+  /** The bundles' contributions to the executor; the server builds them with the tool folders of its data folder. */
   readonly executor: readonly LoadedExecutorContribution[];
-  /** Die Vorlage aus defaultStartEntry der Profildatei; der Host lehnt eine nicht registrierte beim Versiegeln ab. */
+  /** The template from defaultStartEntry of the profile file; the host rejects an unregistered one when sealing. */
   readonly defaultStartEntry?: string;
 }
 
@@ -50,23 +51,27 @@ export const composeProfile = (options: ProfileComposition, bridges: HostBridges
   host.provideHost(executorContributionsToken, options.executor.map((loaded) =>
     prepareExecutorContribution(loaded, pluginToolsDirectory(config.dataDir, loaded.plugin))));
   host.provideHost(runManagementToken, () => {
-    if (!bridges.sessions) throw new Error("Der Host stellt keine Sitzungsverwaltung bereit");
+    if (!bridges.sessions) throw new Error("The host provides no session management");
     return bridges.sessions();
   });
+  host.provideHost(aliasCompletionModelToken, (alias) => aliasCompletionModel(() => {
+    if (!bridges.modelRuntime) throw new Error("The host provides no model runtime");
+    return bridges.modelRuntime();
+  }, alias));
   host.provideHost(secretEnvNamesToken, () =>
     [...new Set([...HOST_SECRET_ENV_NAMES, ...host.config.secretKeys()])]);
   for (const id of options.pluginIds) {
     const module = options.modules.get(id);
-    if (!module) throw new Error(`Das Plugin ${id} wurde nicht geladen`);
+    if (!module) throw new Error(`The plugin ${id} was not loaded`);
     const plugin = module.create(host);
     if (plugin.manifest.id !== id) {
-      throw new Error(`Der Plugin-Ordner ${id} meldet die abweichende Kennung ${plugin.manifest.id}`);
+      throw new Error(`The plugin folder ${id} reports the different id ${plugin.manifest.id}`);
     }
     if (plugin.manifest.requires !== undefined) {
-      throw new Error(`Plugin ${id} deklariert requires im Manifest; es gehört in den Modulvertrag`);
+      throw new Error(`Plugin ${id} declares requires in the manifest; it belongs in the module contract`);
     }
     if (plugin.manifest.web !== undefined) {
-      throw new Error(`Plugin ${id} deklariert web im Manifest; das ergibt sich aus dem Bundle`);
+      throw new Error(`Plugin ${id} declares web in the manifest; that follows from the bundle`);
     }
     const web = options.web.get(id);
     host.register(withFolderAssets({

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

@@ -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;
 };
 
@@ -84,7 +84,7 @@ 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`);
     }
   }
 }