@schlenkr/ragents 0.1.9 → 0.1.11

package/plugins/ragents.processes/contract.ts

@@ -31,29 +31,29 @@ export type RunProcessMessage =
   | { kind: "snapshot"; snapshot: RunProcessSnapshot }
   | { kind: "error"; error: string };
 
-const runId = Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" });
+const runId = Type.String({ minLength: 1, maxLength: 64, description: "Run id" });
 
 export const processesContracts = {
   snapshot: defineOperation({
     id: "ragents.processes.snapshot",
-    description: "Die beobachteten Prozesse eines Runs mit ihren offenen Ports. Rechte: runs.read und ragents.processes.read.",
+    description: "The observed processes of a run with their open ports. Rights: runs.read and ragents.processes.read.",
     rights: ["runs.read", "ragents.processes.read"],
     input: Type.Object({ runId }, { additionalProperties: false }),
     result: openJson<RunProcessSnapshot>("RunProcessSnapshot"),
   }),
   stop: defineOperation({
     id: "ragents.processes.stop",
-    description: "Einen Prozess des Runs beenden. Rechte: runs.read, runs.write und runs.inspect.",
+    description: "End a process of the run. Rights: runs.read, runs.write and runs.inspect.",
     rights: ["runs.read", "runs.write", "runs.inspect"],
     input: Type.Object({
       runId,
-      processId: Type.String({ pattern: "^[1-9][0-9]*-[a-f0-9]{64}$", description: "Kennung des Prozesses aus dem Stand" }),
+      processId: Type.String({ pattern: "^[1-9][0-9]*-[a-f0-9]{64}$", description: "Process id from the snapshot" }),
     }, { additionalProperties: false }),
     result: Type.Null(),
   }),
   live: defineChannel({
     id: "ragents.processes",
-    description: "Der laufende Stand der Prozessüberwachung eines Runs. Rechte: runs.read und ragents.processes.read.",
+    description: "The live state of a run's process monitoring. Rights: runs.read and ragents.processes.read.",
     rights: ["runs.read", "ragents.processes.read"],
     params: Type.Object({ runId }, { additionalProperties: false }),
     message: openJson<RunProcessMessage>("RunProcessMessage"),

package/plugins/ragents.processes/server/methods.ts

@@ -8,9 +8,9 @@ export interface ProcessObservation {
 
 export interface ProcessMethodOptions {
   observer: ProcessObservation;
-  /** Die Prozesse liegen im Arbeitsbereich des Runs; wer ihn nicht sehen darf, sieht auch sie nicht. */
+  /** The processes live in the run's workspace; whoever may not see it does not see them either. */
   ensureWorkspaceAccess: (access: AccessContext, runId: string) => void;
-  /** Beendet beim Executor des Runs; der Abbruch der Anfrage erreicht ihn über `signal`. */
+  /** Ends in the run's executor; cancelling the request reaches it via `signal`. */
   terminate: (runId: string, processId: string, signal: AbortSignal) => Promise<void>;
 }
 
@@ -21,9 +21,9 @@ export const createProcessMethods = (options: ProcessMethodOptions): MethodContr
   }),
   implement(processesContracts.stop, async ({ runId, processId }, { access, signal }) => {
     for (const right of processesContracts.stop.rights) {
-      if (!access.can(right)) throw new DomainError("forbidden", "Das Beenden von Prozessen ist nicht erlaubt", 403);
+      if (!access.can(right)) throw new DomainError("forbidden", "Ending processes is not allowed", 403);
     }
-    if (signal.aborted) throw new Error("Die Prozess-Stopp-Anfrage wurde abgebrochen");
+    if (signal.aborted) throw new Error("The process stop request was cancelled");
     options.ensureWorkspaceAccess(access, runId);
     await options.terminate(runId, processId, signal);
     return null;

package/plugins/ragents.processes/server/observer.ts

@@ -1,7 +1,7 @@
 import type { RunProcessMessage, RunProcessSnapshot } from "../contract.js";
 
 export interface RunProcessObserverOptions {
-  /** Der Stand eines Runs beim Executor, der ihn ausführt; `signal` bricht die Abfrage dort ab. */
+  /** A run's state at the executor running it; `signal` cancels the query there. */
   snapshot: (runId: string, signal: AbortSignal) => Promise<RunProcessSnapshot>;
   pollIntervalMs: number;
 }
@@ -12,17 +12,17 @@ interface RunWatch {
   listeners: Set<RunProcessListener>;
   fresh: Set<RunProcessListener>;
   last: string | undefined;
-  /** Die laufende Abfrage dieses Runs; ein hängender Executor hält nur sie auf. */
+  /** The running query of this run; a hanging executor holds up only this one. */
   polling: Promise<void> | undefined;
   controller: AbortController | undefined;
 }
 
-/** So viele Takte darf eine Abfrage dauern, bevor sie als gescheitert gilt. */
+/** How many ticks a query may take before it counts as failed. */
 const SNAPSHOT_TIMEOUT_TICKS = 5;
 
 const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
 
-/** Fragt je Takt den Stand jedes beobachteten Runs bei seinem Executor ab, jeden für sich und mit Zeitgrenze, und meldet nur Änderungen. */
+/** Queries the state of every observed run from its executor on each tick, each on its own and with a time limit, and reports only changes. */
 export class RunProcessObserver {
   readonly #options: RunProcessObserverOptions;
   readonly #watches = new Map<string, RunWatch>();
@@ -38,7 +38,7 @@ export class RunProcessObserver {
   }
 
   watch(runId: string, listener: RunProcessListener): () => void {
-    if (this.#stopped) throw new Error("Die Prozessüberwachung ist beendet");
+    if (this.#stopped) throw new Error("The process monitoring has ended");
     let watch = this.#watches.get(runId);
     if (!watch) {
       watch = { listeners: new Set(), fresh: new Set(), last: undefined, polling: undefined, controller: undefined };
@@ -104,7 +104,7 @@ export class RunProcessObserver {
     return watch.polling;
   }
 
-  /** Eine Abfrage endet spätestens nach ihrer Zeitgrenze; der Abbruch erreicht dabei auch den Executor. */
+  /** A query ends at the latest after its time limit; the cancellation also reaches the executor. */
   #bounded(runId: string, signal: AbortSignal | undefined): Promise<RunProcessSnapshot> {
     const timeoutMs = this.#options.pollIntervalMs * SNAPSHOT_TIMEOUT_TICKS;
     const controller = new AbortController();
@@ -113,7 +113,7 @@ export class RunProcessObserver {
     let timer: NodeJS.Timeout | undefined;
     const deadline = new Promise<never>((_settle, fail) => {
       timer = setTimeout(() => {
-        const error = new Error(`Der Executor des Runs ${runId} hat die Prozessabfrage nicht innerhalb von ${timeoutMs / 1000} s beantwortet`);
+        const error = new Error(`The executor of run ${runId} did not answer the process query within ${timeoutMs / 1000} s`);
         fail(error);
         controller.abort(error);
       }, timeoutMs);
@@ -130,7 +130,7 @@ export class RunProcessObserver {
       : message);
     const changed = serialized !== watch.last;
     watch.last = serialized;
-    if (changed && message.kind === "error") console.error(`Prozessüberwachung für ${runId}: ${message.error}`);
+    if (changed && message.kind === "error") console.error(`Process monitoring for ${runId}: ${message.error}`);
     for (const listener of watch.listeners) {
       if (changed || watch.fresh.has(listener)) listener(message);
     }

package/plugins/ragents.processes/server/run-processes.ts

@@ -5,11 +5,11 @@ import type { RunProcessSnapshot } from "../contract.js";
 export interface RunProcesses {
   snapshot: (runId: string, signal?: AbortSignal) => Promise<RunProcessSnapshot>;
   terminate: (runId: string, processId: string, signal: AbortSignal) => Promise<void>;
-  /** Ist der Arbeitsplatz nicht erreichbar, holt der Stopp des Runs (`stopRun` seines Executors) das Beenden nach, sobald er wieder da ist. */
+  /** If the workspace is unreachable, the run's stop (`stopRun` of its executor) catches up on ending once it is back. */
   stopAll: (runId: string, signal?: AbortSignal) => Promise<void>;
 }
 
-/** Die Prozesse eines Runs liegen beim Executor, der ihn ausführt; wo das ist, entscheidet allein seine Bindung. */
+/** A run's processes live at the executor running it; where that is is decided solely by its binding. */
 export const runProcessesOf = (sandbox: Pick<SandboxServices, "execute">): RunProcesses => ({
   snapshot: async (runId, signal) => {
     const observed = await sandbox.execute(runId, PROCESS_OPERATIONS.snapshot, {}, signal ? { signal } : {}) as Omit<RunProcessSnapshot, "runId">;

package/plugins/ragents.processes/web/ProcessHeader.tsx

@@ -25,7 +25,7 @@ const useRunProcesses = (runId: string): ProcessWatchState => {
     return rpc.subscribe(processesContracts.live, { runId }, (data) => {
       try {
         const message = messageFrom(data);
-        if (message.kind === "snapshot" && message.snapshot.runId !== runId) throw new Error("Der Prozessstand gehört zu einem anderen Run");
+        if (message.kind === "snapshot" && message.snapshot.runId !== runId) throw new Error("The process snapshot belongs to another run");
         setState((current) => message.kind === "snapshot"
           ? { snapshot: message.snapshot, error: undefined }
           : { snapshot: current.snapshot, error: message.error });
@@ -48,11 +48,11 @@ interface StopState { busy?: boolean; error?: string }
 
 function ProcessPill({ process, state, writable, onStop, toolbar = false }: { process: RunProcess; state?: StopState; writable: boolean; onStop: () => void; toolbar?: boolean }) {
   const stop = <StopButton busy={state?.busy === true} className={stopClass} disabled={!writable || state?.busy}
-    label={state?.busy ? `${process.label} wird beendet` : `${process.label} beenden`}
+    label={state?.busy ? `Stopping ${process.label}` : `Stop ${process.label}`}
     onClick={onStop} size="icon-xs"
-    title={!writable ? "Zum Beenden fehlen Schreib- oder Inspektionsrechte" : state?.busy ? "Wird beendet ..." : `${process.label} beenden`} />;
+    title={!writable ? "Write or inspect rights are missing to stop" : state?.busy ? "Stopping ..." : `Stop ${process.label}`} />;
   const ports = process.ports.map((port) => <a className={portClass} href={serviceUrl(window.location.hostname, port.port)}
-    key={`${port.address}:${port.port}`} rel="noreferrer" target="_blank" title={`${port.address}:${port.port} im neuen Tab öffnen`}>
+    key={`${port.address}:${port.port}`} rel="noreferrer" target="_blank" title={`Open ${port.address}:${port.port} in a new tab`}>
     :{port.port}
   </a>);
   return <div className={cn("flex min-w-0 flex-col", toolbar ? "flex-none self-stretch max-md:not-first:hidden" : "w-full")} data-process-id={process.id}>
@@ -123,12 +123,12 @@ function ProcessHeaderContent({ runId }: { runId: string }) {
   const renderProcess = (process: RunProcess, toolbar = false) => <ProcessPill key={process.id} process={process} state={stops[process.id]} writable={writable} toolbar={toolbar} onStop={() => { void stop(process); }} />;
   if (shown.length === 0 && state.error === undefined && !allOpen) return null;
   return <>
-    <div aria-label="Prozesse und Ports des Runs" className="flex min-w-0 flex-none items-stretch self-stretch" ref={rootRef} onFocusCapture={rememberFocus}>
+    <div aria-label="Processes and ports of the run" className="flex min-w-0 flex-none items-stretch self-stretch" ref={rootRef} onFocusCapture={rememberFocus}>
       {shown.map((process) => renderProcess(process, true))}
-      {(processes.length > 1 || allOpen) && <ToolbarItem as="button" className="md:data-[hidden=false]:hidden" data-hidden={hidden > 0 || allOpen} type="button" onClick={() => setAllOpen(true)} title="Alle Prozesse des Runs anzeigen">
-        <span className="max-md:hidden">{hidden > 0 ? `+${hidden} weitere` : "Prozesse"}</span><span className="hidden max-md:inline">Alle {processes.length}</span>
+      {(processes.length > 1 || allOpen) && <ToolbarItem as="button" className="md:data-[hidden=false]:hidden" data-hidden={hidden > 0 || allOpen} type="button" onClick={() => setAllOpen(true)} title="Show all processes of the run">
+        <span className="max-md:hidden">{hidden > 0 ? `+${hidden} more` : "Processes"}</span><span className="hidden max-md:inline">All {processes.length}</span>
       </ToolbarItem>}
-      {state.error !== undefined && <ToolbarItem className="w-42 text-destructive" role="status" title={state.error}><ToolbarCopy><ToolbarLabel>Prozesse</ToolbarLabel><ToolbarText>Überwachung gestört</ToolbarText></ToolbarCopy></ToolbarItem>}
+      {state.error !== undefined && <ToolbarItem className="w-42 text-destructive" role="status" title={state.error}><ToolbarCopy><ToolbarLabel>Processes</ToolbarLabel><ToolbarText>Monitoring disrupted</ToolbarText></ToolbarCopy></ToolbarItem>}
     </div>
     {allOpen && <Dialog open onOpenChange={(open) => {
       if (open) return;
@@ -136,9 +136,9 @@ function ProcessHeaderContent({ runId }: { runId: string }) {
       if (processes.length === 0) requestAnimationFrame(() => fallback.current?.focus({ preventScroll: true }));
     }}>
       <DialogContent scope="run">
-        <DialogHeader><DialogTitle>Prozesse und Ports</DialogTitle></DialogHeader>
+        <DialogHeader><DialogTitle>Processes and ports</DialogTitle></DialogHeader>
         <DialogBody className="flex flex-col gap-3 outline-none" ref={dialogRef} tabIndex={-1} onFocusCapture={rememberFocus}>
-          {processes.length > 0 ? processes.map((process) => renderProcess(process)) : <p role="status">Keine aktiven Prozesse.</p>}
+          {processes.length > 0 ? processes.map((process) => renderProcess(process)) : <p role="status">No active processes.</p>}
           {state.error !== undefined && <p className="text-destructive" role="alert">{state.error}</p>}
         </DialogBody>
       </DialogContent>

package/plugins/ragents.processes/web/processes.ts

@@ -7,7 +7,7 @@ const ORIGINS = ["tool-call", "background"] as const;
 
 const portFrom = (value: unknown): RunProcessPort => {
   if (!isRecord(value) || typeof value.port !== "number" || typeof value.address !== "string") {
-    throw new Error("Ein Port-Eintrag der Prozessüberwachung ist unlesbar");
+    throw new Error("A port entry of the process monitoring is unreadable");
   }
   return { port: value.port, address: value.address };
 };
@@ -16,7 +16,7 @@ const processFrom = (value: unknown): RunProcess => {
   if (!isRecord(value) || typeof value.id !== "string" || !value.id || typeof value.pid !== "number" || typeof value.label !== "string"
     || typeof value.command !== "string" || typeof value.seenSince !== "string"
     || !ORIGINS.includes(value.origin as RunProcess["origin"]) || !Array.isArray(value.ports)) {
-    throw new Error("Ein Prozess-Eintrag der Prozessüberwachung ist unlesbar");
+    throw new Error("A process entry of the process monitoring is unreadable");
   }
   return {
     id: value.id,
@@ -32,36 +32,36 @@ const processFrom = (value: unknown): RunProcess => {
 const snapshotFrom = (value: unknown): RunProcessSnapshot => {
   if (!isRecord(value) || typeof value.runId !== "string" || typeof value.observedAt !== "string"
     || !Array.isArray(value.processes)) {
-    throw new Error("Der Stand der Prozessüberwachung ist unlesbar");
+    throw new Error("The process monitoring snapshot is unreadable");
   }
   return { runId: value.runId, observedAt: value.observedAt, processes: value.processes.map(processFrom) };
 };
 
 export const messageFrom = (value: unknown): RunProcessMessage => {
-  if (!isRecord(value)) throw new Error("Die Nachricht der Prozessüberwachung ist unlesbar");
+  if (!isRecord(value)) throw new Error("The process monitoring message is unreadable");
   if (value.kind === "error" && typeof value.error === "string") return { kind: "error", error: value.error };
   if (value.kind === "snapshot") return { kind: "snapshot", snapshot: snapshotFrom(value.snapshot) };
-  throw new Error("Die Nachricht der Prozessüberwachung hat eine unbekannte Art");
+  throw new Error("The process monitoring message has an unknown kind");
 };
 
 export const serviceUrl = (hostname: string, port: number): string =>
   `http://${hostname.includes(":") ? `[${hostname}]` : hostname}:${port}/`;
 
-export const kindLabel = (process: RunProcess): string => process.ports.length > 0 ? "Dienst" : "Prozess";
+export const kindLabel = (process: RunProcess): string => process.ports.length > 0 ? "Service" : "Process";
 
 const originText = (origin: RunProcess["origin"]): string =>
-  origin === "background" ? "läuft im Hintergrund weiter" : "läuft in einem Werkzeugaufruf";
+  origin === "background" ? "keeps running in the background" : "runs in a tool call";
 
 const timeText = (iso: string): string => {
   const parsed = new Date(iso);
-  return Number.isNaN(parsed.getTime()) ? iso : parsed.toLocaleTimeString("de-DE");
+  return Number.isNaN(parsed.getTime()) ? iso : parsed.toLocaleTimeString("en-US");
 };
 
 export const titleOf = (process: RunProcess): string => {
   const ports = process.ports.length > 0
-    ? `\nLauscht auf ${process.ports.map((port) => `${port.address}:${port.port}`).join(", ")}`
+    ? `\nListening on ${process.ports.map((port) => `${port.address}:${port.port}`).join(", ")}`
     : "";
-  return `${process.command}\nPID ${process.pid}, ${originText(process.origin)}, beobachtet seit ${timeText(process.seenSince)}${ports}`;
+  return `${process.command}\nPID ${process.pid}, ${originText(process.origin)}, observed since ${timeText(process.seenSince)}${ports}`;
 };
 
 export interface VisibleProcesses {

package/plugins/ragents.product/server/config.ts

@@ -35,7 +35,7 @@ const configuredModel = () => env.required("AGENT_MODEL");
 const configuredCoordinatorModel = () => env.value("AGENT_COORDINATOR_MODEL", "") || configuredModel();
 const provider = env.value("AGENT_PROVIDER", "openrouter");
 
-// Mit AGENT_PROVIDER "relay" kommen Katalog und Modellzugang von einem anderen RAgents-Server.
+// With AGENT_PROVIDER "relay", catalog and model access come from another RAgents server.
 const relay: RelayCatalog | undefined = provider === RELAY_PROVIDER
   ? createRelayCatalog({ url: env.required("RELAY_URL"), token: env.required("RELAY_TOKEN") })
   : undefined;

package/plugins/ragents.product/server/index.ts

@@ -29,21 +29,21 @@ const productProfiles = (): AgentProfile[] => {
     {
       ...base,
       name: "coordinator",
-      description: "Nur für den Koordinator selbst, nicht für Agenten.",
+      description: "Only for the coordinator itself, not for agents.",
       model: coordinatorModel,
       thinking: ragentsProductConfig.coordinatorThinking(),
     },
     {
       ...base,
       name: "relay",
-      description: "Für Vermittlung mit wenigen Werkzeugen.",
+      description: "For relaying with few tools.",
       model: coordinatorModel,
       thinking: ragentsProductConfig.coordinatorThinking(),
     },
     {
       ...base,
       name: "standard",
-      description: "Für alle Agenten.",
+      description: "For all agents.",
       model,
       thinking: ragentsProductConfig.thinking(),
     },
@@ -67,7 +67,7 @@ const ragentsProductPlugin: RAgentsPlugin = {
     host.provide(modelUpstreamsToken, ragentsProductConfig.upstreams);
     host.config(...ragentsProductConfigDescriptors);
     void ragentsProductConfig.modelChoice.options;
-    // Die Modellvorgaben prüfen gegen den Katalog; mit Relay liegt der erst nach dem Abruf beim Start vor.
+    // The model defaults are checked against the catalog; with a relay it is only available after the fetch on start.
     let store: ProductModelSettingsStore | undefined;
     const settings = (): ProductModelSettingsStore =>
       store ??= new ProductModelSettingsStore(host.storage.root("model-settings.json"), ragentsProductConfig.modelChoice, productProfiles());

package/plugins/ragents.product/server/runtime.ts

@@ -2,26 +2,25 @@ import type { ProductRuntimePolicy } from "@ragents/host/ragents/product-runtime
 import { ragentsProductConfig } from "./config.js";
 
 const contract = [
-  "Allgemeine Regeln:",
-  "- Wo du Deutsch schreibst (Chat, Commit-Messages, Dokumente, Kommentare), gilt immer: echte Umlaute (ä/ö/ü/Ä/Ö/Ü) und echtes ß, niemals ae/oe/ue/ss.",
-  "- Nur Zeichen der deutschen Tastatur: als Strich immer der einfache Bindestrich -, keine Gedankenstriche, keine Ellipsen-Zeichen, keine typografischen Anführungszeichen. ... statt Ellipse, -> statt Pfeil.",
+  "General rules:",
+  "- Only characters of the German keyboard: as a dash always the simple hyphen -, no em or en dashes, no ellipsis characters, no typographic quotation marks. ... instead of an ellipsis, -> instead of an arrow.",
 ].join("\n");
 
 const promptComposition = [
-  "Run-Koordinator: Produktprompt und Aufbauanweisung, unabhängig vom gewählten Primary-Actor.",
-  "Weitere Actors behalten ihren eigenen Actor-Prompt; die Primary-Auswahl bestimmt nur Ausgabe und Rollenvertrag.",
-  "ActorInputs und aktueller Run-Zustand kommen getrennt als Turn-Kontext hinzu.",
-  "Actors mit Arbeitsbereichswerkzeugen bekommen die Beschreibung des Arbeitsbereichs als letztes Kapitel; die Agentenlaufzeit ergänzt Skills und Hooks.",
+  "Run coordinator: product prompt and setup instruction, independent of the chosen primary actor.",
+  "Other actors keep their own actor prompt; the primary choice only determines output and role contract.",
+  "ActorInputs and the current run state are added separately as turn context.",
+  "Actors with workspace tools get the workspace description as the last chapter; the agent runtime adds skills and hooks.",
 ].join(" ");
 
 export const ragentsProductRuntime = {
   coordinator: {
     handle: "coordinator",
-    displayName: "Koordinator",
+    displayName: "Coordinator",
     profile: "coordinator",
-    runTitle: "Neuer Run",
+    runTitle: "New run",
     ownerHandle: "user",
-    ownerDisplayName: "Benutzer",
+    ownerDisplayName: "User",
   },
   roleFor: (view, actor) => view.primaryActorId === actor.id ? "primary" : "worker",
   contract: () => contract,

package/plugins/ragents.product/web/index.tsx

@@ -14,7 +14,7 @@ const basePlugin = (descriptor: WebPluginDescriptor): WebPlugin => ({
     title: "RAgents",
   },
   startOptions: productStartOptions,
-  settings: [{ id: "ragents.product.model-settings", label: "Neue Runs und Agenten", category: "models",
+  settings: [{ id: "ragents.product.model-settings", label: "New runs and agents", category: "models",
     order: 20, readRight: "settings.read", Settings: ModelSettings }],
 });
 

package/plugins/ragents.profile-distribution/contract.ts

@@ -4,19 +4,19 @@ import { defineOperation } from "@ragents/engine/src/rpc/contract";
 const pluginEntry = Type.Object({
   id: Type.String({ minLength: 1 }),
   source: Type.Union([Type.Literal("host"), Type.Literal("archive")], {
-    description: "host: der Client nimmt das eingebaute Bundle seines Hosts; archive: das Bundle liegt im Archiv",
+    description: "host: the client takes the built-in bundle of its host; archive: the bundle is in the archive",
   }),
 }, { additionalProperties: false });
 
 const description = Type.Object({
-  profile: Type.String({ minLength: 1, description: "Profilname; die Datei heißt ragents.config.<profil>.ts" }),
-  version: Type.String({ minLength: 64, maxLength: 64, description: "Stand des Archivs als SHA-256" }),
-  hostApi: Type.Integer({ minimum: 1, description: "Nummer der Host-API, gegen die die Bundles im Archiv gebaut sind; der Host des Clients muss genau diese bieten" }),
-  hostVersion: Type.String({ minLength: 40, maxLength: 40, description: "Git-Commit des Hosts dieses Servers; ein Checkout mit anderer Host-API kommt damit zu einer passenden" }),
-  packageVersion: Type.String({ minLength: 1, description: "Fassung des npm-Pakets, die diesen Commit trägt; eine Installation mit anderer Host-API kommt damit zu einer passenden" }),
-  file: Type.String({ minLength: 1, description: "Pfad der Profildatei innerhalb des Archivs" }),
-  size: Type.Integer({ minimum: 0, description: "Archivgröße in Byte" }),
-  archivePath: Type.String({ minLength: 1, description: "HTTP-Pfad des Archivs auf diesem Server" }),
+  profile: Type.String({ minLength: 1, description: "Profile name; the file is called ragents.config.<profile>.ts" }),
+  version: Type.String({ minLength: 64, maxLength: 64, description: "Version of the archive as SHA-256" }),
+  hostApi: Type.Integer({ minimum: 1, description: "Number of the host API the bundles in the archive are built against; the client's host must offer exactly this one" }),
+  hostVersion: Type.String({ minLength: 40, maxLength: 40, description: "Git commit of this server's host; a checkout with a different host API uses it to get a matching one" }),
+  packageVersion: Type.String({ minLength: 1, description: "Version of the npm package that carries this commit; an installation with a different host API uses it to get a matching one" }),
+  file: Type.String({ minLength: 1, description: "Path of the profile file inside the archive" }),
+  size: Type.Integer({ minimum: 0, description: "Archive size in bytes" }),
+  archivePath: Type.String({ minLength: 1, description: "HTTP path of the archive on this server" }),
   plugins: Type.Array(pluginEntry),
 }, { additionalProperties: false });
 
@@ -27,7 +27,7 @@ export const profileArchivePath = (version: string): string => `/profile/${versi
 export const profileDistributionContracts = {
   describe: defineOperation({
     id: "ragents.profile.describe",
-    description: "Das Client-Profil dieses Servers: Name, Stand, verlangte Host-API, Host- und Paketfassung, Plugins und Archiv. Recht: profile.fetch.",
+    description: "The client profile of this server: name, version, required host API, host and package version, plugins and archive. Right: profile.fetch.",
     rights: ["profile.fetch"],
     input: Type.Object({}, { additionalProperties: false }),
     result: description,

package/plugins/ragents.profile-distribution/server/archive.ts

@@ -34,7 +34,7 @@ const commonRoot = (first: string, others: readonly string[]): string => {
   for (const folder of others) {
     while (folder !== root && !folder.startsWith(root + path.sep)) {
       const parent = path.dirname(root);
-      if (parent === root) throw new Error(`Profildatei und Plugin ${folder} haben keinen gemeinsamen Ordner`);
+      if (parent === root) throw new Error(`Profile file and plugin ${folder} have no common folder`);
       root = parent;
     }
   }
@@ -43,45 +43,45 @@ const commonRoot = (first: string, others: readonly string[]): string => {
 
 const posixRelative = (root: string, target: string): string => path.relative(root, target).split(path.sep).join("/");
 
-// Jeder Name ist frei, damit ein Passwort- oder Token-Verweis auch ohne die Client-Umgebung prüfbar ist.
+// Every name is set so a password or token reference can be checked even without the client environment.
 const placeholderEnvironment: Readonly<Record<string, string | undefined>> = new Proxy({}, { get: () => "client-placeholder-value" });
 
 const checkSections = (source: string, raw: Record<string, unknown>, pluginIds: ReadonlySet<string>): void => {
   for (const [section, value] of Object.entries(raw)) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${source}: die Sektion ${section} ist kein Objekt`);
-    if (section !== "host" && !pluginIds.has(section)) throw new Error(`${source}: die Sektion ${section} gehört zu keinem Plugin aus host.PLUGINS`);
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${source}: the section ${section} is not an object`);
+    if (section !== "host" && !pluginIds.has(section)) throw new Error(`${source}: the section ${section} belongs to no plugin from host.PLUGINS`);
     for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
-      if (section === "host" && !hostConfigKeys.includes(key)) throw new Error(`${source}: host.${key} ist kein Host-Schlüssel`);
+      if (section === "host" && !hostConfigKeys.includes(key)) throw new Error(`${source}: host.${key} is not a host key`);
       if (isEnvironmentReference(entry) || isProvisionedReference(entry)) continue;
-      if (SECRET_KEY_PATTERN.test(key)) throw new Error(`${source}: ${section}.${key} ist ein Secret und muss als env("...") stehen`);
+      if (SECRET_KEY_PATTERN.test(key)) throw new Error(`${source}: ${section}.${key} is a secret and must be written as env("...")`);
       const valid = typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean"
         || (Array.isArray(entry) && entry.every((item) => typeof item === "string"))
         || (Array.isArray(entry) && entry.every((item) => !!item && typeof item === "object" && !Array.isArray(item)));
-      if (!valid) throw new Error(`${source}: ${section}.${key} hat keinen gültigen Wert`);
-      if (typeof entry === "string" && /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(entry)) throw new Error(`${source}: ${section}.${key} verweist als Text auf die Umgebung; env("...") verwenden`);
+      if (!valid) throw new Error(`${source}: ${section}.${key} has no valid value`);
+      if (typeof entry === "string" && /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(entry)) throw new Error(`${source}: ${section}.${key} references the environment as text; use env("...")`);
     }
   }
 };
 
-/** Prüft die Client-Profildatei ohne ihre Umgebung und bestimmt, welche Plugins ins Archiv gehören. */
+/** Checks the client profile file without its environment and determines which plugins belong in the archive. */
 export const inspectClientProfile = async (source: string, root = bundlesRoot): Promise<InspectedClientProfile> => {
   const name = PROFILE_FILE.exec(path.basename(source));
-  if (!name) throw new Error(`Die Client-Profildatei muss ragents.config.<profil>.ts heißen: ${source}`);
-  if (!statSync(source, { throwIfNoEntry: false })?.isFile()) throw new Error(`Die Client-Profildatei ${source} fehlt`);
+  if (!name) throw new Error(`The client profile file must be called ragents.config.<profile>.ts: ${source}`);
+  if (!statSync(source, { throwIfNoEntry: false })?.isFile()) throw new Error(`The client profile file ${source} is missing`);
   const profile = name[1]!;
   const module = await import(pathToFileURL(source).href) as Record<string, unknown>;
   const raw = module.config;
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`${source} exportiert keine Konstante config`);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`${source} exports no constant config`);
   const host = (raw as Record<string, unknown>).host as Record<string, unknown> | undefined;
   const entries = host?.PLUGINS;
   if (!Array.isArray(entries) || entries.length === 0 || !entries.every((entry) => typeof entry === "string" && entry)) {
-    throw new Error(`${source}: host.PLUGINS muss eine nicht leere Liste sein`);
+    throw new Error(`${source}: host.PLUGINS must be a non-empty list`);
   }
-  if (host?.PRODUCT_PROFILE !== profile) throw new Error(`${source}: host.PRODUCT_PROFILE muss ${profile} sein`);
+  if (host?.PRODUCT_PROFILE !== profile) throw new Error(`${source}: host.PRODUCT_PROFILE must be ${profile}`);
   const directory = path.dirname(source);
   const unportable = (entries as string[]).filter((entry) => isPluginPath(entry) && !/^\.{1,2}\//.test(entry));
   if (unportable.length > 0) {
-    throw new Error(`${source}: ${unportable.join(", ")} nennt ein Bundle absolut oder mit ~/; der Client löst diesen Pfad auf seinem eigenen Rechner auf und fände dort nicht das gelieferte Bundle. Im Client-Profil jedes Bundle relativ zur Profildatei nennen (./ oder ../)`);
+    throw new Error(`${source}: ${unportable.join(", ")} names a bundle absolutely or with ~/; the client resolves this path on its own machine and would not find the delivered bundle there. In the client profile, name every bundle relative to the profile file (./ or ../)`);
   }
   const plugins = ((): readonly ClientProfilePlugin[] => {
     try {
@@ -94,7 +94,7 @@ export const inspectClientProfile = async (source: string, root = bundlesRoot):
   checkSections(source, raw as Record<string, unknown>, new Set([...discoverPluginIds(root), ...plugins.map((plugin) => plugin.id)]));
   const users = resolveProfileUsers(source, module.users, placeholderEnvironment);
   const anonymous = resolveAnonymousUser(source, module.anonymousUser);
-  if (users && anonymous) throw new Error(`${source}: users und anonymousUser schließen einander aus`);
+  if (users && anonymous) throw new Error(`${source}: users and anonymousUser exclude each other`);
   const archived = plugins.filter((plugin) => plugin.source === "archive").map((plugin) => plugin.folder);
   const commonDirectory = commonRoot(directory, archived);
   return { profile, source, root: commonDirectory, file: posixRelative(commonDirectory, source), plugins };
@@ -104,7 +104,7 @@ const collectFiles = (folder: string, root: string): string[] => {
   const files: string[] = [];
   for (const entry of readdirSync(folder, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name, "en"))) {
     const absolute = path.join(folder, entry.name);
-    if (entry.isSymbolicLink()) throw new Error(`Das Client-Profil enthält einen symbolischen Link, den das Archiv nicht abbildet: ${absolute}`);
+    if (entry.isSymbolicLink()) throw new Error(`The client profile contains a symbolic link that the archive does not represent: ${absolute}`);
     if (entry.isDirectory()) {
       files.push(...collectFiles(absolute, root));
     } else if (entry.isFile()) {
@@ -114,16 +114,16 @@ const collectFiles = (folder: string, root: string): string[] => {
   return files;
 };
 
-/** Die Einträge des Archivs: die Profildatei und die Dateien der Bundles, die sie per Pfad nennt; das Web hat der Client selbst. */
+/** The archive entries: the profile file and the files of the bundles it names by path; the client has the web itself. */
 export const clientProfileEntries = (inspected: InspectedClientProfile): readonly string[] => {
   const entries = [inspected.file, ...inspected.plugins.filter((plugin) => plugin.source === "archive").flatMap((plugin) => collectFiles(plugin.folder, inspected.root))];
   for (const entry of entries) {
-    if (!lstatSync(path.join(inspected.root, entry)).isFile()) throw new Error(`Der Archiveintrag ${entry} ist keine Datei`);
+    if (!lstatSync(path.join(inspected.root, entry)).isFile()) throw new Error(`The archive entry ${entry} is not a file`);
   }
   return entries;
 };
 
-/** Packt die Einträge deterministisch aus ihrem gemeinsamen Ordner; der Stand ist der SHA-256 des Archivs. */
+/** Packs the entries deterministically from their common folder; the version is the SHA-256 of the archive. */
 export const packClientProfile = async (inspected: InspectedClientProfile): Promise<PackedClientProfile> => {
   const entries = clientProfileEntries(inspected);
   const chunks: Buffer[] = [];

package/plugins/ragents.profile-distribution/server/config.ts

@@ -9,7 +9,7 @@ export const profileDistributionConfigDescriptors = [
 
 const env = declaredEnvironment(profileDistributionConfigDescriptors);
 
-/** Der Pfad gilt relativ zur Server-Profildatei, damit beide Dateien nebeneinander liegen können. */
+/** The path is relative to the server profile file so both files can sit next to each other. */
 const resolveClientProfileFile = (): string | undefined => {
   const value = env.optional("CLIENT_PROFILE_FILE");
   if (!value) return undefined;
@@ -21,7 +21,7 @@ export const profileDistributionConfig = Object.freeze({
   clientProfileFile: resolveClientProfileFile,
   hostVersion: () => {
     const value = env.optional("HOST_VERSION");
-    if (value !== undefined && !/^[0-9a-f]{40}$/.test(value)) throw new Error(`HOST_VERSION muss ein vollständiger Git-Commit sein, nicht "${value}"`);
+    if (value !== undefined && !/^[0-9a-f]{40}$/.test(value)) throw new Error(`HOST_VERSION must be a full Git commit, not "${value}"`);
     return value;
   },
 });

package/plugins/ragents.profile-distribution/server/index.ts

@@ -22,7 +22,7 @@ const archiveRoute = (state: () => DistributionState): HttpRouteContribution =>
     const current = state();
     const version = archivePattern.exec(url.pathname)?.[1];
     if (version !== current.description.version) {
-      writeJson(response, 404, { error: `Der Stand ${version} wird nicht mehr angeboten; aktuell ist ${current.description.version}` });
+      writeJson(response, 404, { error: `Version ${version} is no longer offered; the current one is ${current.description.version}` });
       return;
     }
     response.writeHead(200, {
@@ -42,13 +42,13 @@ const profileDistributionPlugin: RAgentsPlugin = {
     if (!file) {
       host.lifecycle({
         id: "ragents.profile-distribution",
-        initialize: () => console.log("Profilverteilung: CLIENT_PROFILE_FILE ist nicht gesetzt, dieser Server bietet kein Client-Profil an"),
+        initialize: () => console.log("Profile distribution: CLIENT_PROFILE_FILE is not set, this server offers no client profile"),
       });
       return;
     }
     let ready: DistributionState | undefined;
     const state = (): DistributionState => {
-      if (!ready) throw new DomainError("profile-not-ready", "Das Client-Profil ist noch nicht gepackt.", 503);
+      if (!ready) throw new DomainError("profile-not-ready", "The client profile is not packed yet.", 503);
       return ready;
     };
     host.lifecycle({
@@ -73,7 +73,7 @@ const profileDistributionPlugin: RAgentsPlugin = {
             plugins: inspected.plugins.map((plugin) => ({ id: plugin.id, source: plugin.source })),
           },
         };
-        console.log(`Profilverteilung: ${inspected.profile} Stand ${packed.version.slice(0, 12)} (${packed.entries.length} Dateien, ${packed.archive.byteLength} Byte, Host-API ${hostApi}, Host ${hostVersion.slice(0, 12)}, Paket ${packageVersion})`);
+        console.log(`Profile distribution: ${inspected.profile} version ${packed.version.slice(0, 12)} (${packed.entries.length} files, ${packed.archive.byteLength} bytes, host API ${hostApi}, host ${hostVersion.slice(0, 12)}, package ${packageVersion})`);
       },
     });
     host.methods(implement(profileDistributionContracts.describe, () => state().description));