@schlenkr/ragents 0.1.9 → 0.1.11

package/packages/workspace-executor/src/language-server/session.ts

@@ -55,7 +55,7 @@ const NEW_FILE_AGE_MS = 10_000;
 const uriOf = (absolutePath: string): string => pathToFileURL(absolutePath).href;
 
 const timeoutError = (label: string, what: string, timeoutMs: number): Error =>
-  new Error(`${label}: ${what} nicht innerhalb von ${Math.round(timeoutMs / 1000)} s`);
+  new Error(`${label}: ${what} not within ${Math.round(timeoutMs / 1000)} s`);
 
 export const withTimeout = <T>(promise: Promise<T>, timeoutMs: number, error: () => Error): Promise<T> =>
   new Promise((resolve, reject) => {
@@ -108,14 +108,14 @@ export class LanguageServerSession {
       onStderr: (chunk) => {
         this.#stderr = (this.#stderr + chunk.toString("utf8")).slice(-STDERR_TAIL);
       },
-      onExit: (code) => this.#ended(`Code ${code ?? "Signal"}`),
+      onExit: (code) => this.#ended(`code ${code ?? "signal"}`),
       onError: (error) => {
         this.#service.kill("SIGKILL");
-        this.#ended(`Fehler: ${error.message}`);
+        this.#ended(`error: ${error.message}`);
       },
     });
     const output = this.#service.stdin;
-    if (!output) throw new Error(`${launch.label}: Standardeingabe fehlt`);
+    if (!output) throw new Error(`${launch.label}: standard input is missing`);
     this.#connection = new JsonRpcConnection({
       label: launch.label,
       input: this.#input,
@@ -161,7 +161,7 @@ export class LanguageServerSession {
           },
         }),
         timeoutMs,
-        () => timeoutError(launch.label, "initialisiert", timeoutMs),
+        () => timeoutError(launch.label, "initialized", timeoutMs),
       ) as { capabilities?: Record<string, unknown> };
       session.#serverCapabilities = result.capabilities ?? {};
       session.#connection.notify("initialized", {});
@@ -201,7 +201,7 @@ export class LanguageServerSession {
     return withTimeout(
       new Promise<unknown>((resolve, reject) => {
         if (this.#exitReason !== undefined) {
-          reject(new Error(`${this.label} läuft nicht mehr (${this.#exitReason})${this.#stderrHint()}`));
+          reject(new Error(`${this.label} is no longer running (${this.#exitReason})${this.#stderrHint()}`));
           return;
         }
         const onExit = (error: Error) => {
@@ -226,7 +226,7 @@ export class LanguageServerSession {
       this.#assertRunning();
       const extension = path.extname(absolutePath).toLowerCase();
       const languageId = this.#launch.languages[extension];
-      if (!languageId) throw new Error(`${this.label} kennt die Endung ${extension || "(keine)"} nicht`);
+      if (!languageId) throw new Error(`${this.label} does not know the extension ${extension || "(none)"}`);
       const uri = uriOf(absolutePath);
       const text = await readFile(absolutePath, "utf8");
       const settleMs = this.#launch.newFileSettleMs;
@@ -257,16 +257,16 @@ export class LanguageServerSession {
       await withTimeout(
         this.#connection.request("shutdown", null),
         SHUTDOWN_TIMEOUT_MS,
-        () => timeoutError(this.label, "shutdown beantwortet", SHUTDOWN_TIMEOUT_MS),
+        () => timeoutError(this.label, "shutdown answered", SHUTDOWN_TIMEOUT_MS),
       );
       this.#connection.notify("exit", null);
     } catch {
     }
-    await withTimeout(this.#service.finished, SHUTDOWN_TIMEOUT_MS, () => new Error("weiter")).catch(() => {
+    await withTimeout(this.#service.finished, SHUTDOWN_TIMEOUT_MS, () => new Error("continue")).catch(() => {
       this.#service.kill("SIGKILL");
     });
     await this.#service.finished.catch(() => undefined);
-    this.#connection.close(new Error(`${this.label} wurde beendet`));
+    this.#connection.close(new Error(`${this.label} was ended`));
   }
 
   async #isYoung(absolutePath: string): Promise<boolean> {
@@ -277,7 +277,7 @@ export class LanguageServerSession {
   #ended(reason: string): void {
     if (this.#exitReason !== undefined) return;
     this.#exitReason = reason;
-    const error = new Error(`${this.label} wurde beendet (${reason})${this.#stderrHint()}`);
+    const error = new Error(`${this.label} was ended (${reason})${this.#stderrHint()}`);
     this.#connection.close(error);
     this.#input.destroy();
     for (const listener of [...this.#exitListeners]) listener(error);
@@ -296,7 +296,7 @@ export class LanguageServerSession {
 
   #assertRunning(): void {
     if (this.#exitReason !== undefined) {
-      throw new Error(`${this.label} läuft nicht mehr (${this.#exitReason})${this.#stderrHint()}`);
+      throw new Error(`${this.label} is no longer running (${this.#exitReason})${this.#stderrHint()}`);
     }
   }
 
@@ -345,7 +345,7 @@ export class LanguageServerSession {
             ...(identifier === undefined ? {} : { identifier }),
           }),
           Math.max(1, deadline - Date.now()),
-          () => timeoutError(this.label, "Diagnostik geliefert", timeoutMs),
+          () => timeoutError(this.label, "diagnostics delivered", timeoutMs),
         ) as { kind?: string; items?: Diagnostic[] } | null;
         return result?.items ?? [];
       } catch (error) {
@@ -370,7 +370,7 @@ export class LanguageServerSession {
       entry !== undefined && entry.receivedAt >= closedAt;
     if (!confirmed(this.#published.get(uri)) && !await this.#waitForPublish(uri, confirmed, CLOSE_PUBLISH_TIMEOUT_MS)) {
       this.#assertRunning();
-      throw timeoutError(this.label, "didClose bestätigt", CLOSE_PUBLISH_TIMEOUT_MS);
+      throw timeoutError(this.label, "didClose confirmed", CLOSE_PUBLISH_TIMEOUT_MS);
     }
   }
 
@@ -401,7 +401,7 @@ export class LanguageServerSession {
       entry !== undefined && entry.receivedAt >= sentAt && (entry.version === undefined || entry.version >= version);
     if (!matches(this.#published.get(uri)) && !await this.#waitForPublish(uri, matches, timeoutMs)) {
       this.#assertRunning();
-      throw timeoutError(this.label, "Diagnostik geliefert", timeoutMs);
+      throw timeoutError(this.label, "diagnostics delivered", timeoutMs);
     }
     const settleDeadline = Date.now() + SETTLE_LIMIT_MS;
     while (Date.now() < settleDeadline && await this.#waitForPublish(uri, matches, SETTLE_MS)) continue;

package/packages/workspace-executor/src/language-server/workspace-solutions.ts

@@ -52,7 +52,7 @@ const gitSolutions = async (context: WorkspaceProcessContext, extensions: readon
     "ls-files", "-z", "--cached", "--others", "--exclude-standard", "--",
     ...extensions.map((extension) => `:(icase)*${extension}`),
   ]);
-  if (listed.code !== 0) throw new Error(`git ls-files ist mit Code ${listed.code} gescheitert`);
+  if (listed.code !== 0) throw new Error(`git ls-files failed with code ${listed.code}`);
   return listed.output.split("\0").filter(Boolean);
 };
 
@@ -70,7 +70,7 @@ const directorySolutions = async (root: string, extensions: readonly string[], r
   return nested.flat();
 };
 
-/** Ohne Git-Arbeitsverzeichnis durchsucht es den Ordner selbst, sechs Ebenen tief und ohne versteckte Ordner. */
+/** Without a Git working directory it searches the folder itself, six levels deep and without hidden folders. */
 export const workspaceSolutions = async (
   context: WorkspaceProcessContext,
   extensions: readonly string[],

package/packages/workspace-executor/src/managed-process.ts

@@ -2,6 +2,7 @@ import { execFile, spawn, type ChildProcess } from "node:child_process";
 import { readdir, readFile } from "node:fs/promises";
 import type { Writable } from "node:stream";
 import { killProcessTree } from "@ragents/agent";
+import { bashLaunch } from "./bash-launch.js";
 
 const PROCESS_GROUP_JOIN_TIMEOUT_MS = 5_000;
 const PROCESS_GROUP_POLL_MS = 25;
@@ -72,11 +73,38 @@ export const processExists = (pid: number): boolean => {
   }
 };
 
-/** Windows kennt keine Prozessgruppe und kein SIGKILL: der Baum geht über taskkill /T /F, und zwar ohne Wartezusage. */
+/** Windows knows no process group and no SIGKILL: the tree goes through taskkill /T /F, and without a promise to wait. */
 export const stopProcessTree = (pid: number): void => {
   if (processExists(pid)) killProcessTree(pid);
 };
 
+/** Marks the processes of a bash call on Windows: MSYS does not attach the children of the bash to its Windows process tree, so taskkill /T does not reach them. */
+export const MSYS_CALL_ENV = "RAGENTS_BASH_CALL";
+
+/** The Windows ids of all MSYS processes in the process groups in which a process carries the marker, even after the bash itself has ended. */
+const msysGroupScript = (marker: string): string => [
+  "groups=' '",
+  `for d in /proc/[0-9]*; do tr '\\0' '\\n' < "$d/environ" 2>/dev/null | grep -qxF '${MSYS_CALL_ENV}=${marker}' && groups="$groups$(cat "$d/pgid") "; done`,
+  `for d in /proc/[0-9]*; do case "$groups" in *" $(cat "$d/pgid" 2>/dev/null) "*) cat "$d/winpid" 2>/dev/null;; esac; done`,
+].join("\n");
+
+const execFileText = (file: string, args: readonly string[], env?: NodeJS.ProcessEnv): Promise<{ stdout: string; error: Error | null }> =>
+  new Promise((resolve) => {
+    execFile(file, [...args], { env, windowsHide: true, timeout: 15_000 }, (error, stdout) => resolve({ stdout, error }));
+  });
+
+/** Ends on Windows everything that a bash call with this marker started, including the native trees below it. */
+export const stopMsysCall = async (bash: string, env: NodeJS.ProcessEnv, marker: string): Promise<void> => {
+  const launch = bashLaunch({ bash, rg: undefined }, msysGroupScript(marker), env, "win32");
+  const listing = await execFileText(launch.command, launch.args, launch.env);
+  if (listing.error) throw new Error(`The processes of the bash call could not be determined: ${listing.error.message}`);
+  const winpids = [...new Set(listing.stdout.split(/\s+/).filter((pid) => /^\d+$/.test(pid)))];
+  if (winpids.length === 0) return;
+  await execFileText("taskkill", ["/F", "/T", ...winpids.flatMap((pid) => ["/PID", pid])]);
+  const alive = winpids.filter((pid) => processExists(Number(pid)));
+  if (alive.length > 0) throw new Error(`The processes ${alive.join(", ")} of the bash call keep running after taskkill`);
+};
+
 const darwinProcessGroupExists = (pid: number): Promise<boolean> =>
   new Promise((resolve, reject) => {
     execFile("/bin/ps", ["-axo", "pgid=,stat="], { timeout: 5_000, maxBuffer: 4 * 1024 * 1024 }, (error, stdout) => {
@@ -86,7 +114,7 @@ const darwinProcessGroupExists = (pid: number): Promise<boolean> =>
       }
       const rows = stdout.split("\n").map((line) => /^\s*(\d+)\s*(\S*)\s*$/.exec(line)).filter((row) => row !== null);
       if (rows.length === 0) {
-        reject(new Error(`macOS-Prozessgruppe ${pid}: ungültige Prozessliste: ${stdout.slice(0, 200)}`));
+        reject(new Error(`macOS process group ${pid}: invalid process list: ${stdout.slice(0, 200)}`));
         return;
       }
       resolve(rows.some((row) => Number(row[1]) === pid && !row[2].startsWith("Z")));
@@ -164,7 +192,7 @@ const joinProcessGroup = async (
     while (await processGroupExists(pid)) {
       if (Date.now() >= deadline) {
         throw new ProcessGroupJoinError(
-          `${label}: Prozessgruppe ${pid} konnte nicht beendet werden`,
+          `${label}: process group ${pid} could not be ended`,
         );
       }
       await new Promise<void>((finish) => setTimeout(finish, PROCESS_GROUP_POLL_MS));
@@ -173,7 +201,7 @@ const joinProcessGroup = async (
     if (error instanceof ProcessGroupJoinError) throw error;
     const detail = error instanceof Error ? error.message : String(error);
     throw new ProcessGroupJoinError(
-      `${label}: Prozessgruppe ${pid} konnte nicht geprüft werden: ${detail}`,
+      `${label}: process group ${pid} could not be checked: ${detail}`,
     );
   }
 };
@@ -184,7 +212,7 @@ export const runManagedProcess = (options: ManagedProcessOptions): Promise<Manag
       const reason = options.signal?.reason;
       return reason instanceof Error
         ? reason
-        : new Error(`${options.label} wurde abgebrochen`);
+        : new Error(`${options.label} was cancelled`);
     };
     if (options.signal?.aborted) {
       reject(abortError());
@@ -219,7 +247,7 @@ export const runManagedProcess = (options: ManagedProcessOptions): Promise<Manag
       terminationTimer = setTimeout(() => {
         sendSignal("SIGKILL");
         processError ??= new ProcessGroupJoinError(
-          `${options.label}: Prozessgruppe ${pid ?? "unbekannt"} hat die Beendigungsfrist überschritten`,
+          `${options.label}: process group ${pid ?? "unknown"} exceeded the termination grace period`,
         );
         child.stdout?.destroy();
         child.stderr?.destroy();
@@ -322,7 +350,7 @@ export const startManagedService = (options: ManagedServiceOptions): ManagedServ
     finished,
     exited: () => exited,
     send: (message) => new Promise<void>((resolve, reject) => {
-      if (!child.connected) return reject(new Error(`${options.label}: IPC-Verbindung ist geschlossen`));
+      if (!child.connected) return reject(new Error(`${options.label}: IPC connection is closed`));
       child.send(message as import("node:child_process").Serializable, (error) => error ? reject(error) : resolve());
     }),
   };

package/packages/workspace-executor/src/module.ts

@@ -1,32 +1,32 @@
 import type { WorkspaceProcessContext } from "./context.js";
 import type { OperationFootprint } from "./paths.js";
 
-/** Ein Aufruf einer Operation: der Run, die Eingabe und was der Aufrufer mitgibt. */
+/** A call of an operation: the run, the input and what the caller passes along. */
 export interface WorkspaceOperationCall {
   readonly runId: string;
   readonly input: unknown;
   readonly toolCallId: string | undefined;
   readonly signal: AbortSignal | undefined;
-  /** Meldet einen JSON-Wert als Fortschritt; fehlt, wenn der Aufrufer keinen Fortschritt will. */
+  /** Reports a JSON value as progress; missing if the caller wants no progress. */
   readonly progress: ((value: unknown) => void) | undefined;
 }
 
 export type WorkspaceOperation = (call: WorkspaceOperationCall) => Promise<unknown>;
 
-/** Ein Baustein des Executors: benannte Operationen und sein Anteil am Aufräumen. */
+/** A building block of the executor: named operations and its share of the cleanup. */
 export interface WorkspaceExecutorModule {
   readonly operations: Readonly<Record<string, WorkspaceOperation>>;
-  /** Der Fußabdruck einer Eingabe je Operation; ohne Eintrag spricht sie keine bestimmte Wurzel an. Wirft nie, auch nicht bei ungültiger Eingabe. */
+  /** The footprint of an input per operation; without an entry it addresses no specific root. Never throws, not even for invalid input. */
   readonly footprints?: Readonly<Record<string, (input: unknown) => OperationFootprint>>;
-  /** Eine Anmerkung zu einer gerade geschriebenen Datei, etwa die Diagnostik eines Sprachservers. */
+  /** An annotation for a file just written, such as the diagnostics of a language server. */
   readonly annotate?: (runId: string, absolutePath: string) => Promise<string | undefined>;
-  /** Gibt frei, was das Modul für einen Run hält. */
+  /** Releases what the module holds for a run. */
   readonly stopRun?: (runId: string) => Promise<void>;
-  /** Gibt alles frei; danach ruft niemand das Modul mehr auf, es darf spätere Aufrufe mit Ursache ablehnen. */
+  /** Releases everything; afterwards nobody calls the module anymore, it may reject later calls with a cause. */
   readonly shutdown?: () => Promise<void>;
 }
 
-/** Was ein Modul vom Executor bekommt: den Kontext eines Runs auf dieser Maschine und die Anmerkungen aller Module. */
+/** What a module gets from the executor: the context of a run on this machine and the annotations of all modules. */
 export interface WorkspaceModuleHost {
   readonly contextFor: (runId: string) => Promise<WorkspaceProcessContext>;
   readonly annotate: (runId: string, absolutePath: string) => Promise<string | undefined>;

package/packages/workspace-executor/src/modules.ts

@@ -8,13 +8,13 @@ import { runFolderModule } from "./run-folders.js";
 import { sandboxToolsModule } from "./sandbox-tools.js";
 
 export interface WorkspaceExecutorModuleOptions {
-  /** Der neue Ordner eines Runs auf dieser Maschine; nur ein Arbeitsplatz kennt ihn, auf dem Server legt ihn der Host an. */
+  /** The new folder of a run on this machine; only a workspace knows it, on the server the host creates it. */
   runFolder?: (runId: string) => string;
-  /** Die Beiträge der Plugins, gebaut für diese Maschine; Server und Arbeitsplatz bekommen dieselben. */
+  /** The contributions of the plugins, built for this machine; server and workspace get the same ones. */
   contributions: readonly WorkspaceExecutorParts[];
 }
 
-/** Die Module eines Executors: die eigenen und was die Beiträge der Plugins hinzufügen. */
+/** The modules of an executor: its own and what the contributions of the plugins add. */
 export const workspaceExecutorModules = (options: WorkspaceExecutorModuleOptions): readonly WorkspaceModuleFactory[] => [
   sandboxToolsModule,
   languageServerModule(options.contributions.flatMap((parts) => parts.languageServers ?? [])),

package/packages/workspace-executor/src/paths.ts

@@ -4,12 +4,12 @@ import { WorkspaceOperationError } from "./errors.js";
 
 export interface ResolvedWorkspaceRoot {
   directory: string;
-  /** `@name`, bei einer Wurzel unter einem gemeinsamen Alias `@name/<ordner>`. */
+  /** `@name`, for a root under a shared alias `@name/<folder>`. */
   alias?: string;
   environmentVariable?: string;
 }
 
-/** Welche Wurzeln die Eingabe einer Operation anspricht: die Aliasse zusätzlicher Wurzeln und ob ein Pfad ohne Alias die Wurzel des Runs nennt. */
+/** Which roots the input of an operation addresses: the aliases of additional roots and whether a path without an alias names the root of the run. */
 export interface AddressedRoots {
   readonly aliases: readonly string[];
   readonly runRoot: boolean;
@@ -17,17 +17,17 @@ export interface AddressedRoots {
 
 export const NO_ROOTS: AddressedRoots = { aliases: [], runRoot: false };
 
-/** Was ein Aufrufer über eine Eingabe wissen muss, ohne ihre Form zu kennen: die Wurzeln, die sie anspricht, und die Laufzeit, die sie selbst verlangt. */
+/** What a caller must know about an input without knowing its shape: the roots it addresses and the running time it requires itself. */
 export interface OperationFootprint {
   readonly roots: AddressedRoots;
   readonly durationMs?: number;
 }
 
-/** Der Alias, mit dem ein Pfad beginnt, ist sein erster Abschnitt, wenn der mit @ beginnt. */
+/** The alias a path starts with is its first segment, if that starts with @. */
 export const aliasOf = (location: string): string | undefined =>
   location.startsWith("@") ? location.split("/")[0] : undefined;
 
-/** Die Wurzeln, die Felder einer Eingabe als Pfade nennen, eine Liste mit jedem Eintrag: ein Pfad mit Alias dessen Wurzel, jeder andere die des Runs. */
+/** The roots that fields of an input name as paths, a list with every entry: a path with an alias its root, every other one the root of the run. */
 export const rootsOfFields = (input: unknown, ...keys: readonly string[]): AddressedRoots => {
   const fields: Readonly<Record<string, unknown>> = typeof input === "object" && input !== null ? input as Record<string, unknown> : {};
   const named = keys.flatMap((key) => [fields[key]].flat()).filter((entry): entry is string => typeof entry === "string");
@@ -35,7 +35,7 @@ export const rootsOfFields = (input: unknown, ...keys: readonly string[]): Addre
   return { aliases: [...new Set(aliases)], runRoot: named.some((entry) => aliasOf(entry) === undefined) };
 };
 
-/** Die Wurzel, die ein Pfad mit Alias nennt, und der Rest darunter; ohne passenden Alias keine. */
+/** The root that a path with an alias names, and the rest below it; without a matching alias none. */
 export const aliasedRoot = (
   requested: string,
   aliases: Readonly<Record<string, string>>,
@@ -44,14 +44,14 @@ export const aliasedRoot = (
   return found && { directory: found[1], rest: requested.slice(found[0].length + 1) };
 };
 
-/** Nennt bei einem gemeinsamen Alias wie `@skills` auch den Ordner darunter, weil erst beide eine Wurzel bestimmen. */
+/** For a shared alias like `@skills` also names the folder below it, because only both together determine a root. */
 export const unknownAliasError = (requested: string, aliases: Readonly<Record<string, string>>): WorkspaceOperationError => {
   const [first, second] = requested.split("/");
   const known = Object.keys(aliases);
   const named = second !== undefined && known.some((alias) => alias.startsWith(`${first}/`)) ? `${first}/${second}` : first;
   return new WorkspaceOperationError(
     "workspace-alias-unknown",
-    `Unbekannter Arbeitsverzeichnis-Alias: ${named} (bekannt: ${known.length > 0 ? known.join(", ") : "keine"})`,
+    `Unknown working directory alias: ${named} (known: ${known.length > 0 ? known.join(", ") : "none"})`,
     400,
   );
 };
@@ -72,7 +72,7 @@ export const resolvedWorkspacePath = async (filename: string): Promise<string> =
       const code = (error as NodeJS.ErrnoException).code;
       if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
       const info = await lstat(candidate).catch(() => undefined);
-      if (info?.isSymbolicLink()) throw new Error(`Pfad außerhalb des Arbeitsverzeichnisses: ${filename}`);
+      if (info?.isSymbolicLink()) throw new Error(`Path outside the working directory: ${filename}`);
       const parent = path.dirname(candidate);
       if (parent === candidate) throw error;
       rest.unshift(path.basename(candidate));
@@ -81,7 +81,7 @@ export const resolvedWorkspacePath = async (filename: string): Promise<string> =
   }
 };
 
-/** Liegt der Pfad in der Wurzel oder ist er sie selbst; auch für eine Laufwerkswurzel wie `/` oder `C:\`. */
+/** Whether the path lies in the root or is the root itself; also for a drive root like `/` or `C:\`. */
 export const containsWorkspacePath = (root: string, filename: string): boolean => {
   const relative = path.relative(root, filename);
   return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
@@ -90,6 +90,6 @@ export const containsWorkspacePath = (root: string, filename: string): boolean =
 export const allowedWorkspacePath = async (filename: string, roots: readonly string[]): Promise<string> => {
   const absolute = await resolvedWorkspacePath(filename);
   const canonicalRoots = await Promise.all(roots.map(resolvedWorkspacePath));
-  if (!canonicalRoots.some((root) => containsWorkspacePath(root, absolute))) throw new Error(`Pfad außerhalb des Arbeitsverzeichnisses: ${filename}`);
+  if (!canonicalRoots.some((root) => containsWorkspacePath(root, absolute))) throw new Error(`Path outside the working directory: ${filename}`);
   return absolute;
 };

package/packages/workspace-executor/src/process-sandbox.ts

@@ -1,16 +1,16 @@
 import type { WorkspaceProcessContext } from "./context.js";
 
-/** Ein Programm mit seinen Argumenten, so wie es gestartet wird. */
+/** A program with its arguments, as it is started. */
 export interface ProcessLaunch {
   readonly command: string;
   readonly args: readonly string[];
 }
 
-/** Wie ein Executor die Prozesse eines Runs in seine Sandbox steckt; der Kontext trägt sie, jeder Start fragt sie. */
+/** How an executor puts the processes of a run into its sandbox; the context carries it, every start asks it. */
 export interface ProcessSandbox {
   readonly wrap: (launch: ProcessLaunch) => Promise<ProcessLaunch>;
 }
 
-/** Der Start eines Prozesses im Kontext eines Runs: mit Sandbox eingepackt, ohne unverändert. */
+/** The start of a process in the context of a run: wrapped with a sandbox, unchanged without one. */
 export const sandboxedLaunch = (context: WorkspaceProcessContext, launch: ProcessLaunch): Promise<ProcessLaunch> =>
   context.sandbox ? context.sandbox.wrap(launch) : Promise.resolve(launch);

package/packages/workspace-executor/src/processes/module.ts

@@ -11,17 +11,17 @@ export const PROCESS_OPERATIONS = {
 } as const;
 
 export interface ProcessModuleOptions {
-  /** Die Prozesstabelle dieser Maschine; ohne Angabe die der Plattform, aufgelöst erst im Aufruf. */
+  /** The process table of this machine; without a value the one of the platform, resolved only at the call. */
   table?: () => ProcessTable;
 }
 
 const processIdOf = (input: unknown): string => {
   const value = (input as { processId?: unknown } | null)?.processId;
-  if (typeof value !== "string") throw new WorkspaceOperationError("invalid-process", "Ungültige Prozessreferenz", 400);
+  if (typeof value !== "string") throw new WorkspaceOperationError("invalid-process", "Invalid process reference", 400);
   return value;
 };
 
-/** Die markierten Prozesse eines Runs auf dieser Maschine; ohne Prozesstabelle (Windows) räumt der Stopp nur die Bash-Bäume ab. */
+/** The marked processes of a run on this machine; without a process table (Windows) the stop only clears the bash trees. */
 export const processModule = (options: ProcessModuleOptions = {}): WorkspaceModuleFactory => () => {
   const table = options.table ?? (() => processTableForPlatform());
   const cleansUp = options.table !== undefined || hasProcessTable();

package/packages/workspace-executor/src/processes/process-table.ts

@@ -45,8 +45,8 @@ const runCommand = async (file: string, args: string[], toleratedExitCodes: read
   } catch (error) {
     const failure = error as Error & { code?: number | string; stdout?: string; stderr?: string };
     if (typeof failure.code === "number" && toleratedExitCodes.includes(failure.code)) return failure.stdout ?? "";
-    if (failure.code === "ENOENT") throw new Error(`${file} ist nicht installiert; die Prozessüberwachung braucht es`);
-    throw new Error(`${file} ${args[0]} ist fehlgeschlagen: ${(failure.stderr || failure.message).trim()}`);
+    if (failure.code === "ENOENT") throw new Error(`${file} is not installed; the process monitor needs it`);
+    throw new Error(`${file} ${args[0]} failed: ${(failure.stderr || failure.message).trim()}`);
   }
 };
 
@@ -59,7 +59,7 @@ const MARKER_TOKEN = new RegExp(`(?:^|\\s)${RUN_MARKER_ENV}=(\\S+)`);
 
 export class ProcessChangedError extends Error {
   constructor(readonly pid: number) {
-    super(`Prozess ${pid} hat sich während der Umgebungsabfrage geändert`);
+    super(`Process ${pid} changed during the environment query`);
     this.name = "ProcessChangedError";
   }
 }
@@ -67,7 +67,7 @@ export class ProcessChangedError extends Error {
 export const parseDarwinProcessTable = (text: string): ProcessRecord[] =>
   text.split("\n").filter((line) => line.trim() !== "").map((line) => {
     const match = DARWIN_TABLE_LINE.exec(line);
-    if (!match) throw new Error(`Unlesbare Prozesszeile von ps: ${line}`);
+    if (!match) throw new Error(`Unreadable process line from ps: ${line}`);
     return {
       pid: Number(match[1]),
       ppid: Number(match[2]),
@@ -126,7 +126,7 @@ export const parseLsofListeners = (text: string): Map<number, WorkspaceProcessPo
 const darwinCommands = (text: string): Map<number, string> => new Map(text.split("\n")
   .filter((line) => line.trim() !== "").map((line) => {
     const match = /^\s*(\d+)\s+(.*)$/.exec(line);
-    if (!match) throw new Error("Unlesbare Befehlszeile von ps");
+    if (!match) throw new Error("Unreadable command line from ps");
     return [Number(match[1]), match[2]];
   }));
 
@@ -191,7 +191,7 @@ const explainAccess = (error: unknown, pid: number, what: string): Error => {
   const code = (error as NodeJS.ErrnoException).code;
   if (code === "EACCES" || code === "EPERM") {
     return new Error(
-      `${what} von Prozess ${pid} ist nicht lesbar (${code}); als root braucht die Prozessüberwachung CAP_SYS_PTRACE`,
+      `${what} of process ${pid} is not readable (${code}); as root the process monitor needs CAP_SYS_PTRACE`,
     );
   }
   return error instanceof Error ? error : new Error(String(error));
@@ -209,7 +209,7 @@ export const parseLinuxStat = (text: string): LinuxStat => {
   const open = text.indexOf("(");
   const close = text.lastIndexOf(")");
   const fields = open >= 0 && close > open ? text.slice(close + 2).trim().split(" ") : [];
-  if (fields.length < 20) throw new Error(`Unlesbare stat-Zeile: ${text.trim()}`);
+  if (fields.length < 20) throw new Error(`Unreadable stat line: ${text.trim()}`);
   return {
     comm: text.slice(open + 1, close),
     state: fields[0],
@@ -260,7 +260,7 @@ export const addressFromHex = (hex: string): string => {
     if (groups.every((group) => group === 0)) return WILDCARD;
     return formatIpv6(groups);
   }
-  throw new Error(`Unbekannte Adressform in /proc/net/tcp: ${hex}`);
+  throw new Error(`Unknown address form in /proc/net/tcp: ${hex}`);
 };
 
 export interface LinuxListener {
@@ -271,7 +271,7 @@ export interface LinuxListener {
 export const parseLinuxTcpTable = (text: string): LinuxListener[] =>
   text.split("\n").slice(1).filter((line) => line.trim() !== "").flatMap((line) => {
     const fields = line.trim().split(/\s+/);
-    if (fields.length < 10) throw new Error(`Unlesbare Zeile in /proc/net/tcp: ${line.trim()}`);
+    if (fields.length < 10) throw new Error(`Unreadable line in /proc/net/tcp: ${line.trim()}`);
     if (fields[3] !== "0A") return [];
     const [hexAddress, hexPort] = fields[1].split(":");
     return [{ inode: fields[9], port: { port: parseInt(hexPort, 16), address: addressFromHex(hexAddress) } }];
@@ -297,7 +297,7 @@ const readLinuxRecord = async (proc: string, pid: number): Promise<ProcessRecord
   const parsed = parseLinuxStat(stat);
   if (parsed.state === "Z") return undefined;
   const uid = Number(/^Uid:\s+(\d+)/m.exec(status)?.[1]);
-  if (!Number.isInteger(uid)) throw new Error(`${proc}/${pid}/status nennt keine Uid`);
+  if (!Number.isInteger(uid)) throw new Error(`${proc}/${pid}/status names no Uid`);
   const args = cmdline.toString("utf8").split("\0").filter((argument) => argument !== "");
   return {
     pid,
@@ -315,7 +315,7 @@ const readLinuxMarker = async (proc: string, pid: number, asRoot: boolean): Prom
     environ = await readFile(`${proc}/${pid}/environ`);
   } catch (error) {
     if (isGone(error) || (isDenied(error) && !asRoot)) return undefined;
-    throw explainAccess(error, pid, "Die Umgebung");
+    throw explainAccess(error, pid, "The environment");
   }
   const prefix = `${RUN_MARKER_ENV}=`;
   const entry = environ.toString("utf8").split("\0").find((candidate) => candidate.startsWith(prefix));
@@ -344,7 +344,7 @@ const linuxSocketInodes = async (proc: string, pid: number, asRoot: boolean): Pr
     names = await readdir(directory);
   } catch (error) {
     if (isGone(error) || (isDenied(error) && !asRoot)) return [];
-    throw explainAccess(error, pid, "Die Dateideskriptoren");
+    throw explainAccess(error, pid, "The file descriptors");
   }
   const inodes: string[] = [];
   for (const name of names) {
@@ -353,7 +353,7 @@ const linuxSocketInodes = async (proc: string, pid: number, asRoot: boolean): Pr
       target = await readlink(`${directory}/${name}`);
     } catch (error) {
       if (isGone(error) || (isDenied(error) && !asRoot)) continue;
-      throw explainAccess(error, pid, "Die Dateideskriptoren");
+      throw explainAccess(error, pid, "The file descriptors");
     }
     const match = /^socket:\[(\d+)\]$/.exec(target);
     if (match) inodes.push(match[1]);
@@ -362,13 +362,13 @@ const linuxSocketInodes = async (proc: string, pid: number, asRoot: boolean): Pr
 };
 
 export interface LinuxProcessTableOptions {
-  /** Der Ordner der Prozessdateien; Tests nennen einen eigenen. */
+  /** The folder of the process files; tests name their own. */
   readonly proc?: string;
-  /** Als root ist eine gesperrte Umgebung ein fehlendes Recht; sonst hat sich ein eigener Prozess unlesbar gemacht. */
+  /** As root a locked environment is a missing right; otherwise one of our own processes made itself unreadable. */
   readonly asRoot?: boolean;
 }
 
-/** Ohne root liest die Tabelle nur eigene Prozesse; einer, der sich unlesbar gemacht hat (PR_SET_DUMPABLE, etwa ein Chrome-Helfer oder ssh-agent), trägt keinen erkennbaren Marker. */
+/** Without root the table reads only our own processes; one that made itself unreadable (PR_SET_DUMPABLE, such as a Chrome helper or ssh-agent) carries no recognizable marker. */
 export const linuxProcessTable = (options: LinuxProcessTableOptions = {}): ProcessTable => {
   const proc = options.proc ?? "/proc";
   const asRoot = options.asRoot ?? process.getuid?.() === 0;
@@ -403,7 +403,7 @@ export const linuxProcessTable = (options: LinuxProcessTableOptions = {}): Proce
   };
 };
 
-/** Nur macOS und Linux haben eine Prozesstabelle, aus der sich Run-Marker lesen lassen. */
+/** Only macOS and Linux have a process table from which run markers can be read. */
 export const hasProcessTable = (platform: NodeJS.Platform = process.platform): boolean =>
   platform === "darwin" || platform === "linux";
 
@@ -411,8 +411,8 @@ export const processTableForPlatform = (platform: NodeJS.Platform = process.plat
   if (platform === "darwin") return darwinProcessTable();
   if (platform === "linux") return linuxProcessTable();
   if (platform === "win32") {
-    throw new Error("Unter Windows gibt es keine Prozesstabelle: für Runs, die auf diesem Rechner arbeiten, zeigt und beendet "
-      + "die Prozessüberwachung nichts. Die Werkzeuge des Arbeitsbereichs brauchen sie nicht.");
+    throw new Error("There is no process table on Windows: for runs working on this machine the process monitor "
+      + "shows and ends nothing. The tools of the workspace do not need it.");
   }
-  throw new Error(`Die Prozessüberwachung kennt die Plattform ${platform} nicht (nur darwin und linux)`);
+  throw new Error(`The process monitor does not know the platform ${platform} (only darwin and linux)`);
 };

package/packages/workspace-executor/src/processes/scanner.ts

@@ -22,7 +22,7 @@ interface Scan {
 
 const keyOf = (record: ProcessRecord): string => `${record.pid}:${record.startKey}`;
 
-/** Liest die markierten Prozesse dieser Maschine; gleichzeitige Abfragen mehrerer Runs teilen sich einen Tabellenscan. */
+/** Reads the marked processes of this machine; concurrent queries of several runs share one table scan. */
 export class ProcessScanner {
   readonly #options: ProcessScannerOptions;
   readonly #now: () => Date;
@@ -52,7 +52,7 @@ export class ProcessScanner {
         ports,
         firstSeen: (record) => {
           const seen = scan.firstSeen.get(record.pid);
-          if (!seen) throw new Error(`Prozess ${record.pid} ohne Erstsichtung`);
+          if (!seen) throw new Error(`Process ${record.pid} without a first sighting`);
           return seen;
         },
       }),
@@ -71,7 +71,7 @@ export class ProcessScanner {
     return uid === undefined || uid === 0 || record.uid === uid;
   }
 
-  /** Die Umgebung eines Prozesses wird nur einmal gelesen; ein Fehler dabei merkt sich nichts. */
+  /** The environment of a process is read only once; an error while doing so is not remembered. */
   async #scan(): Promise<Scan> {
     const table = this.#options.table();
     const records = await table.list();