@schlenkr/ragents 0.1.5 → 0.1.7

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

@@ -2,34 +2,90 @@ export {
   sandboxEnvironment,
   sandboxRunEnvironment,
   workspaceProcessContext,
+  type BaseEnvironment,
   type SandboxHomeEnvironment,
   type WorkspaceProcessContext,
 } from "./context.js";
+export { WorkspaceOperationError } from "./errors.js";
 export {
-  SandboxWorkspaceExecutor,
   WORKSPACE_EXECUTOR_VERSION,
-  WORKSPACE_STOP_OPERATION,
-  languageServerCloseTool,
-  languageServerDiagnosticsTool,
-  languageServerOpenTool,
-  languageServerSnapshotTool,
+  WorkspaceOperationExecutor,
   type WorkspaceExecuteOptions,
   type WorkspaceExecutor,
 } from "./executor.js";
+export {
+  type WorkspaceExecutorModule,
+  type WorkspaceModuleFactory,
+} from "./module.js";
+export { workspaceExecutorModules, type WorkspaceExecutorModuleOptions } from "./modules.js";
+export { RUN_FOLDER_OPERATIONS, runFolderModule, type RunFolderCreated } from "./run-folders.js";
+export {
+  FILE_OPERATIONS,
+  FILE_READ_LIMIT,
+  fileModule,
+  listDirectory,
+  readTextFile,
+  watchDirectory,
+  type FileListing,
+  type FileText,
+  type FileWatchProgress,
+} from "./files.js";
+export {
+  COMMAND_OPERATIONS,
+  COMMAND_OUTPUT_LIMIT,
+  commandModule,
+  type CommandResult,
+  type CommandRunInput,
+} from "./commands.js";
+export {
+  BROWSER_EXECUTABLE_VARIABLE,
+  BROWSER_OPERATIONS,
+  type BrowserCheck,
+  type BrowserCheckResult,
+  type BrowserPageState,
+  type BrowserSnapshot,
+  type BrowserStep,
+  type BrowserTarget,
+  type BrowserViewport,
+} from "./browser/contract.js";
+export { browserModule, type BrowserModuleOptions } from "./browser/module.js";
 export { processGroupExists, runManagedProcess, startManagedService, type ManagedService } from "./managed-process.js";
 export {
-  allowedWorkspacePath,
   containsWorkspacePath,
-  expandWorkspaceAlias,
   resolvedWorkspacePath,
+  rootsOfFields,
+  type AddressedRoots,
+  type OperationFootprint,
   type ResolvedWorkspaceRoot,
 } from "./paths.js";
-export { RUN_MARKER_ENV, runMarkerOf } from "./run-marker.js";
-export { safeProcessEnvironment } from "./safe-environment.js";
-export { createSandboxTools, withAnnotation } from "./sandbox-tools.js";
+export { PROCESS_OPERATIONS, processModule } from "./processes/module.js";
+export { sandboxedLaunch, type ProcessLaunch, type ProcessSandbox } from "./process-sandbox.js";
+export {
+  ProcessChangedError,
+  addressFromHex,
+  darwinProcessTable,
+  hasProcessTable,
+  linuxProcessTable,
+  parseDarwinMarkers,
+  parseDarwinProcessTable,
+  parseLinuxStat,
+  parseLinuxTcpTable,
+  parseLsofListeners,
+  processIdOf,
+  processTableForPlatform,
+  type ProcessRecord,
+  type ProcessTable,
+} from "./processes/process-table.js";
+export { ProcessScanner, type WorkspaceProcessSnapshot } from "./processes/scanner.js";
+export { labelOf, runProcessesFrom } from "./processes/snapshot.js";
+export { RunProcessTerminator } from "./processes/terminator.js";
+export { RUN_MARKER_ENV } from "./run-marker.js";
+export { editorFreeEnvironment, inheritedProcessEnvironment, safeProcessEnvironment } from "./safe-environment.js";
+export { bashLaunch, type BashLaunch } from "./bash-launch.js";
+export { createSandboxTools, sandboxToolsModule, withAnnotation, type SeenFile } from "./sandbox-tools.js";
 export { type SessionIdent } from "./session-ident.js";
 export { shellPlatformText } from "./shell-platform.js";
-export { hostDataDirectory, hostToolFile, pluginToolsDirectory, ragentsDataRoot, workspaceDataDirectory } from "./tools.js";
+export { ragentsDataRoot, workspaceDataDirectory } from "./tools.js";
 export {
   LanguageServerHost,
   changedWorkspaceFiles,
@@ -37,18 +93,26 @@ export {
   type LanguageServerHostOptions,
 } from "./language-server/host.js";
 export {
-  type LanguageServerDiagnostic,
-  type LanguageServerFileDiagnostics,
   type LanguageServerInstanceSnapshot,
   type LanguageServerSeverity,
   type LanguageServerSnapshot,
+  type LanguageServerSolution,
+  type LanguageServerSolutions,
   type LanguageServerState,
 } from "./language-server/contract.js";
 export { diagnosticEntries, formatDiagnostics } from "./language-server/diagnostics.js";
+export {
+  languageServerCloseOperation,
+  languageServerDiagnosticsOperation,
+  languageServerModule,
+  languageServerOpenOperation,
+  languageServerSnapshotOperation,
+  languageServerSolutionsOperation,
+  languageServerSwitchOperation,
+} from "./language-server/module.js";
 export { resolveRootDirectory } from "./language-server/roots.js";
-export { LanguageServerSession, withTimeout, type Diagnostic } from "./language-server/session.js";
+export { LanguageServerSession, withTimeout } from "./language-server/session.js";
 export { solutionProjects } from "./language-server/solution.js";
-export { fsharpAdapter, FSHARP_PLUGIN_ID, FSHARP_SERVER_FILE, FSHARP_SERVER_VARIABLE } from "./language-server/adapters/fsharp.js";
-export { roslynAdapter, ROSLYN_PLUGIN_ID, ROSLYN_SERVER_FILE, ROSLYN_SERVER_VARIABLE } from "./language-server/adapters/roslyn.js";
+export { fsharpAdapter, FSHARP_SERVER_FILE, FSHARP_SERVER_VARIABLE } from "./language-server/adapters/fsharp.js";
+export { roslynAdapter, ROSLYN_SERVER_FILE, ROSLYN_SERVER_VARIABLE } from "./language-server/adapters/roslyn.js";
 export { typescriptAdapter } from "./language-server/adapters/typescript.js";
-export { workspaceLanguageServers } from "./language-server/adapters/index.js";

package/packages/workspace-executor/src/language-server/adapters/roslyn.ts

@@ -26,6 +26,7 @@ export const roslynAdapter: LanguageServerAdapter = {
   label: "Roslyn",
   languages,
   rootDescription: "the .sln file (or a single .csproj)",
+  solutionExtensions: [".sln", ".slnx"],
   resolveRoot: (workspaceRoot, root) => resolveRootFile(workspaceRoot, root, [".sln", ".slnx", ".csproj"]),
   rootDirectory: (root) => path.dirname(root),
   launch: async (context, root) => ({

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

@@ -25,3 +25,17 @@ export interface LanguageServerInstanceSnapshot {
 export interface LanguageServerSnapshot {
   instances: readonly LanguageServerInstanceSnapshot[];
 }
+
+export interface LanguageServerSolution {
+  /** Relativ zur Wurzel des Arbeitsbereichs, mit Schrägstrichen. */
+  path: string;
+  root: string;
+  state: LanguageServerState | null;
+}
+
+export interface LanguageServerSolutions {
+  source: "git" | "directory";
+  solutions: readonly LanguageServerSolution[];
+  /** Ob im Run schon eine Instanz dieser Sprache offen ist oder gerade geöffnet wird. */
+  opened: boolean;
+}

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

@@ -1,10 +1,17 @@
 import { realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import type { WorkspaceProcessContext } from "../context.js";
-import { runManagedProcess } from "../managed-process.js";
-import type { LanguageServerDiagnostic, LanguageServerInstanceSnapshot, LanguageServerSnapshot } from "./contract.js";
+import { sandboxedLaunch } from "../process-sandbox.js";
+import type {
+  LanguageServerDiagnostic,
+  LanguageServerInstanceSnapshot,
+  LanguageServerSnapshot,
+  LanguageServerSolutions,
+  LanguageServerState,
+} from "./contract.js";
 import { diagnosticEntries, formatDiagnostics } from "./diagnostics.js";
 import { LanguageServerSession, withTimeout, type LanguageServerLaunch } from "./session.js";
+import { runGit, workspaceSolutions } from "./workspace-solutions.js";
 import { allowedWorkspacePath, containsWorkspacePath, expandWorkspaceAlias, resolvedWorkspacePath } from "../paths.js";
 
 export interface LanguageServerAdapter {
@@ -12,6 +19,8 @@ export interface LanguageServerAdapter {
   label: string;
   languages: Readonly<Record<string, string>>;
   rootDescription: string;
+  /** Die Endungen der Solutions, die `<id>_solutions` im Arbeitsbereich sucht; ohne sie gibt es weder Suche noch Umschalten. */
+  solutionExtensions?: readonly string[];
   resolveRoot: (workspaceRoot: string, root: string) => Promise<string>;
   rootDirectory: (root: string) => string;
   launch: (context: WorkspaceProcessContext, root: string) => Promise<LanguageServerLaunch>;
@@ -45,7 +54,6 @@ interface ServerEntry {
 const DEFAULT_IDLE_MS = 20 * 60 * 1000;
 const DEFAULT_OPEN_TIMEOUT_MS = 5 * 60 * 1000;
 const DEFAULT_DIAGNOSTICS_TIMEOUT_MS = 60 * 1000;
-const GIT_TIMEOUT_MS = 30 * 1000;
 
 const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
 
@@ -61,22 +69,11 @@ const git = async (
   tool: string,
   args: readonly string[],
 ): Promise<string> => {
-  let output = "";
-  const result = await runManagedProcess({
-    command: "git",
-    args: [...args],
-    cwd: directory,
-    env: context.env,
-    uid: context.uid,
-    gid: context.gid,
-    label: `git ${args[0]}`,
-    timeoutMs: GIT_TIMEOUT_MS,
-    onStdout: (chunk) => { output += chunk.toString("utf8"); },
-  }).catch((error: unknown) => {
+  const result = await runGit(context, directory, args).catch((error: unknown) => {
     throw new Error(`Ohne paths braucht ${tool} ein Git-Arbeitsverzeichnis: ${messageOf(error)}`);
   });
   if (result.code !== 0) throw new Error(`Ohne paths braucht ${tool} ein Git-Arbeitsverzeichnis (git ${args[0]}: Code ${result.code})`);
-  return output;
+  return result.output;
 };
 
 /** Git nennt seine Pfade relativ zur Repo-Wurzel; `-- .` grenzt sie auf die Wurzel der Instanz ein. */
@@ -107,6 +104,7 @@ export class LanguageServerHost {
   readonly #diagnosticsTimeoutMs: number;
   readonly #servers = new Map<string, ServerEntry>();
   readonly #roots = new Map<string, Set<string>>();
+  readonly #requests = new Map<string, number>();
   readonly #lifetimes = new Map<string, object>();
   readonly #closing = new Map<string, Set<Promise<void>>>();
   readonly #idleTimers = new Map<string, NodeJS.Timeout>();
@@ -129,8 +127,51 @@ export class LanguageServerHost {
     return this.adapter.languages[path.extname(filePath).toLowerCase()] !== undefined;
   }
 
-  async open(runId: string, root: string): Promise<string> {
+  /** Mit `ifNoneOpen` prüft und belegt der Aufruf den Run ohne Unterbrechung: läuft schon ein Öffnen oder ist eine Instanz da, lädt er nichts. */
+  async open(runId: string, root: string, ifNoneOpen = false): Promise<string> {
+    const lifetime = this.#lifetime(runId);
+    if (ifNoneOpen && !this.#idle(runId)) {
+      return `${this.adapter.label} lädt ${root} nicht: in diesem Run ist schon eine Instanz offen oder im Aufbau`;
+    }
+    this.#requests.set(runId, (this.#requests.get(runId) ?? 0) + 1);
+    try {
+      return await this.#open(runId, lifetime, root);
+    } finally {
+      const remaining = (this.#requests.get(runId) ?? 1) - 1;
+      if (remaining > 0) this.#requests.set(runId, remaining);
+      else this.#requests.delete(runId);
+    }
+  }
+
+  async solutions(runId: string): Promise<LanguageServerSolutions> {
+    const extensions = this.adapter.solutionExtensions;
+    if (!extensions) throw new Error(`${this.adapter.label} sucht keine Solutions`);
+    if (this.#closed) throw this.#stopped();
+    const found = await workspaceSolutions(await this.#contextFor(runId), extensions);
+    return {
+      source: found.source,
+      solutions: found.solutions.map((solution) => ({ ...solution, state: this.#stateOf(runId, solution.root) })),
+      opened: !this.#idle(runId),
+    };
+  }
+
+  /** Lädt die Wurzel und beendet jede andere Instanz des Runs; wartet nicht auf das Laden, `null` beendet alle. */
+  async switchTo(runId: string, root: string | null): Promise<string> {
+    if (root === null) return this.close(runId);
     const lifetime = this.#lifetime(runId);
+    const { context, absoluteRoot } = await this.#prepare(runId, lifetime, root);
+    const others = this.#openRoots(runId).filter((entry) => entry !== absoluteRoot);
+    await Promise.all(others.map((entry) => this.#closeInstance(runId, entry)));
+    this.#assertLifetime(runId, lifetime);
+    const current = this.#current(runId, absoluteRoot);
+    const kept = current !== undefined && current.state !== "failed";
+    // Ein Fehlschlag steht mit seiner Ursache im Stand der Instanz.
+    if (!kept) void this.#start(runId, context, absoluteRoot).catch(() => undefined);
+    const closed = others.length === 0 ? "" : `; ${others.length === 1 ? "eine andere Instanz" : `${others.length} andere Instanzen`} beendet`;
+    return `${this.adapter.label} ${kept ? "behält" : "lädt"} ${absoluteRoot}${closed}`;
+  }
+
+  async #open(runId: string, lifetime: object, root: string): Promise<string> {
     const { context, absoluteRoot } = await this.#prepare(runId, lifetime, root);
     const current = this.#current(runId, absoluteRoot);
     if (current && current.state !== "failed") {
@@ -182,11 +223,14 @@ export class LanguageServerHost {
     this.#assertLifetime(runId, lifetime);
     const roots = root === undefined ? this.#openRoots(runId) : [await this.#known(runId, context, root)];
     if (roots.length === 0) throw new Error(`Kein ${this.adapter.label}-Server geöffnet; zuerst ${this.adapter.id}_open aufrufen`);
-    const results = paths === undefined || paths.length === 0
-      ? await this.#changed(runId, context, roots, includeWarnings)
-      : await this.#requested(runId, context, roots, paths, includeWarnings);
-    if (results.length === 0) return `Keine geänderten ${this.adapter.label}-Dateien in den geöffneten Wurzeln`;
-    return results.join("\n\n");
+    if (paths !== undefined && paths.length > 0) return (await this.#requested(runId, context, roots, paths, includeWarnings)).join("\n\n");
+    const failed = root === undefined ? roots.filter((entry) => this.#current(runId, entry)?.state === "failed") : [];
+    const failures = failed.map((entry) =>
+      `${this.adapter.label} für ${entry} nicht geöffnet: ${this.#current(runId, entry)!.summary}; ${this.adapter.id}_open öffnet die Wurzel erneut`);
+    if (failed.length === roots.length) throw new Error(failures.join("\n"));
+    const results = await this.#changed(runId, context, roots.filter((entry) => !failed.includes(entry)), includeWarnings);
+    const text = results.length === 0 ? `Keine geänderten ${this.adapter.label}-Dateien in den geöffneten Wurzeln` : results.join("\n\n");
+    return [text, ...failures].join("\n\n");
   }
 
   async annotate(runId: string, absolutePath: string): Promise<string | undefined> {
@@ -241,8 +285,9 @@ export class LanguageServerHost {
     try {
       const context = await this.#contextFor(runId);
       this.#assertLifetime(runId, lifetime);
+      absoluteRoot = path.resolve(context.root, expandWorkspaceAlias(root, context.workspaceAliases ?? {}));
       const allowed = await Promise.all([context.root, ...context.additionalRoots ?? []].map(resolvedWorkspacePath));
-      const requested = await allowedWorkspacePath(path.resolve(context.root, expandWorkspaceAlias(root, context.workspaceAliases ?? {})), allowed);
+      const requested = await allowedWorkspacePath(absoluteRoot, allowed);
       absoluteRoot = requested;
       const workspaceRoot = allowed.find((directory) => containsWorkspacePath(directory, requested))!;
       absoluteRoot = await this.adapter.resolveRoot(workspaceRoot, requested);
@@ -357,8 +402,9 @@ export class LanguageServerHost {
   async #known(runId: string, context: WorkspaceProcessContext, root: string): Promise<string> {
     const roots = this.#openRoots(runId);
     if (roots.length === 0) throw new Error(`Kein ${this.adapter.label}-Server geöffnet; zuerst ${this.adapter.id}_open aufrufen`);
-    const requested = await resolvedWorkspacePath(path.resolve(context.root, expandWorkspaceAlias(root, context.workspaceAliases ?? {})));
-    const found = roots.find((open) => open === requested);
+    const lexical = path.resolve(context.root, expandWorkspaceAlias(root, context.workspaceAliases ?? {}));
+    const requested = await resolvedWorkspacePath(lexical);
+    const found = roots.find((open) => open === requested || open === lexical);
     if (!found) throw new Error(`Für ${root} ist kein ${this.adapter.label}-Server geöffnet; offen: ${roots.join(", ")}`);
     return found;
   }
@@ -387,6 +433,15 @@ export class LanguageServerHost {
     return [...this.#roots.get(runId) ?? []];
   }
 
+  #idle(runId: string): boolean {
+    return this.#openRoots(runId).length === 0 && !this.#requests.has(runId);
+  }
+
+  #stateOf(runId: string, root: string): LanguageServerState | null {
+    if (!this.#roots.get(runId)?.has(root)) return null;
+    return this.#current(runId, root)?.state ?? "suspended";
+  }
+
   #remember(runId: string, root: string): void {
     const roots = this.#roots.get(runId) ?? new Set<string>();
     roots.add(root);
@@ -440,8 +495,9 @@ export class LanguageServerHost {
         await closing;
         this.#assertCurrent(entry);
         const launch = await this.adapter.launch(context, root);
+        const { command, args } = await sandboxedLaunch(context, launch);
         this.#assertCurrent(entry);
-        entry.initializing = LanguageServerSession.start(launch, this.#openTimeoutMs);
+        entry.initializing = LanguageServerSession.start({ ...launch, command, args: [...args] }, this.#openTimeoutMs);
         const session = await entry.initializing;
         this.#assertCurrent(entry);
         let aborted!: () => void;

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

@@ -0,0 +1,107 @@
+import { WorkspaceOperationError } from "../errors.js";
+import type { WorkspaceModuleFactory, WorkspaceOperation } from "../module.js";
+import { rootsOfFields, type OperationFootprint } from "../paths.js";
+import { LanguageServerHost, type LanguageServerAdapter, type LanguageServerHostOptions } from "./host.js";
+
+export const languageServerOpenOperation = (adapterId: string): string => `${adapterId}_open`;
+
+export const languageServerDiagnosticsOperation = (adapterId: string): string => `${adapterId}_diagnostics`;
+
+export const languageServerCloseOperation = (adapterId: string): string => `${adapterId}_close`;
+
+export const languageServerSnapshotOperation = (adapterId: string): string => `${adapterId}_snapshot`;
+
+export const languageServerSolutionsOperation = (adapterId: string): string => `${adapterId}_solutions`;
+
+export const languageServerSwitchOperation = (adapterId: string): string => `${adapterId}_switch`;
+
+const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
+
+const settledAll = async (operations: readonly Promise<void>[]): Promise<void> => {
+  const results = await Promise.allSettled(operations);
+  const failed = results.find((result): result is PromiseRejectedResult => result.status === "rejected");
+  if (failed) throw failed.reason;
+};
+
+const invalid = (operation: string, message: string): WorkspaceOperationError =>
+  new WorkspaceOperationError("language-server-input-invalid", `${operation}: ${message}`, 400);
+
+const fieldsOf = (operation: string, input: unknown): Readonly<Record<string, unknown>> => {
+  const fields = input ?? {};
+  if (typeof fields !== "object" || Array.isArray(fields)) throw invalid(operation, "Die Eingabe muss ein Objekt sein");
+  return fields as Readonly<Record<string, unknown>>;
+};
+
+const optionalRoot = (operation: string, value: unknown): string | undefined => {
+  if (value === undefined) return undefined;
+  if (typeof value !== "string") throw invalid(operation, "root muss ein Text sein");
+  return value;
+};
+
+const solutionOperationsOf = (server: LanguageServerHost): Array<readonly [string, WorkspaceOperation]> => {
+  const change = languageServerSwitchOperation(server.adapter.id);
+  return [
+    [languageServerSolutionsOperation(server.adapter.id), ({ runId }) => server.solutions(runId)],
+    [change, ({ runId, input }) => {
+      const { root } = fieldsOf(change, input);
+      if (root !== null && typeof root !== "string") throw invalid(change, "root muss ein Text oder null sein");
+      return server.switchTo(runId, root);
+    }],
+  ];
+};
+
+const operationsOf = (server: LanguageServerHost): Array<readonly [string, WorkspaceOperation]> => {
+  const { id } = server.adapter;
+  const open = languageServerOpenOperation(id);
+  const close = languageServerCloseOperation(id);
+  const diagnostics = languageServerDiagnosticsOperation(id);
+  return [
+    [open, ({ runId, input }) => {
+      const { root, ifNoneOpen } = fieldsOf(open, input);
+      const checked = optionalRoot(open, root);
+      if (checked === undefined) throw invalid(open, "root fehlt");
+      if (ifNoneOpen !== undefined && typeof ifNoneOpen !== "boolean") throw invalid(open, "ifNoneOpen muss true oder false sein");
+      return server.open(runId, checked, ifNoneOpen ?? false);
+    }],
+    [close, ({ runId, input }) => server.close(runId, optionalRoot(close, fieldsOf(close, input).root))],
+    [diagnostics, ({ runId, input }) => {
+      const { paths, warnings, root } = fieldsOf(diagnostics, input);
+      if (paths !== undefined && (!Array.isArray(paths) || !paths.every((entry) => typeof entry === "string"))) throw invalid(diagnostics, "paths muss eine Liste von Texten sein");
+      if (warnings !== undefined && typeof warnings !== "boolean") throw invalid(diagnostics, "warnings muss true oder false sein");
+      return server.diagnostics(runId, paths as readonly string[] | undefined, warnings ?? false, optionalRoot(diagnostics, root));
+    }],
+    [languageServerSnapshotOperation(id), ({ runId }) => server.snapshot(runId)],
+    ...server.adapter.solutionExtensions ? solutionOperationsOf(server) : [],
+  ];
+};
+
+/** Öffnen und Schließen sprechen die Wurzel ihrer Instanz an, die Diagnostik dazu die ihrer Dateien; ohne Wurzel und Dateien keine bestimmte. */
+const footprintsOf = (server: LanguageServerHost): Array<readonly [string, (input: unknown) => OperationFootprint]> => {
+  const { id } = server.adapter;
+  return [
+    [languageServerOpenOperation(id), (input) => ({ roots: rootsOfFields(input, "root") })],
+    [languageServerCloseOperation(id), (input) => ({ roots: rootsOfFields(input, "root") })],
+    [languageServerDiagnosticsOperation(id), (input) => ({ roots: rootsOfFields(input, "root", "paths") })],
+  ];
+};
+
+/** Die Sprachserver dieser Maschine: je Adapter Öffnen, Diagnostik, Schließen und Stand, mit Solutions auch Suche und Umschalten, dazu die Diagnostik geschriebener Dateien. */
+export const languageServerModule = (
+  adapters: readonly LanguageServerAdapter[],
+  options: LanguageServerHostOptions = {},
+): WorkspaceModuleFactory => (host) => {
+  const servers = adapters.map((adapter) => new LanguageServerHost(adapter, host.contextFor, options));
+  return {
+    operations: Object.fromEntries(servers.flatMap(operationsOf)),
+    footprints: Object.fromEntries(servers.flatMap(footprintsOf)),
+    annotate: async (runId, absolutePath) => {
+      const notes = await Promise.all(servers.map((server) =>
+        server.annotate(runId, absolutePath).catch((error: unknown) =>
+          `Diagnostik (${server.adapter.label}) fehlgeschlagen: ${messageOf(error)}`)));
+      const text = notes.filter((note): note is string => Boolean(note)).join("\n");
+      return text || undefined;
+    },
+    stopRun: (runId) => settledAll(servers.map((server) => server.stopSession(runId))),
+    shutdown: () => settledAll(servers.map((server) => server.shutdown())),
+  };
+};

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

@@ -0,0 +1,90 @@
+import { readdir, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import type { WorkspaceProcessContext } from "../context.js";
+import { runManagedProcess } from "../managed-process.js";
+import { containsWorkspacePath } from "../paths.js";
+import { sandboxedLaunch } from "../process-sandbox.js";
+
+const GIT_TIMEOUT_MS = 30 * 1000;
+const DIRECTORY_DEPTH = 6;
+const SKIPPED_DIRECTORIES = new Set(["node_modules", "bin", "obj"]);
+
+interface GitResult {
+  code: number | null;
+  output: string;
+}
+
+interface FoundSolution {
+  path: string;
+  root: string;
+}
+
+export const runGit = async (
+  context: WorkspaceProcessContext,
+  directory: string,
+  args: readonly string[],
+): Promise<GitResult> => {
+  const chunks: Buffer[] = [];
+  const launch = await sandboxedLaunch(context, { command: "git", args });
+  const result = await runManagedProcess({
+    command: launch.command,
+    args: [...launch.args],
+    cwd: directory,
+    env: context.env,
+    uid: context.uid,
+    gid: context.gid,
+    label: `git ${args[0]}`,
+    timeoutMs: GIT_TIMEOUT_MS,
+    onStdout: (chunk) => { chunks.push(chunk); },
+  });
+  return { code: result.code, output: Buffer.concat(chunks).toString("utf8") };
+};
+
+const skipped = (name: string): boolean => SKIPPED_DIRECTORIES.has(name.toLowerCase());
+
+const matches = (relative: string, extensions: readonly string[]): boolean =>
+  extensions.includes(path.extname(relative).toLowerCase())
+  && !relative.split("/").slice(0, -1).some(skipped);
+
+const gitSolutions = async (context: WorkspaceProcessContext, extensions: readonly string[]): Promise<string[] | undefined> => {
+  if ((await runGit(context, context.root, ["rev-parse", "--is-inside-work-tree"])).code !== 0) return undefined;
+  const listed = await runGit(context, context.root, [
+    "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`);
+  return listed.output.split("\0").filter(Boolean);
+};
+
+const directorySolutions = async (root: string, extensions: readonly string[], relative = "", depth = 0): Promise<string[]> => {
+  const entries = await readdir(path.join(root, relative), { withFileTypes: true });
+  const nested = await Promise.all(entries.map(async (entry) => {
+    const child = relative ? `${relative}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      return depth < DIRECTORY_DEPTH && !entry.name.startsWith(".") && !skipped(entry.name)
+        ? directorySolutions(root, extensions, child, depth + 1)
+        : [];
+    }
+    return entry.isFile() ? [child] : [];
+  }));
+  return nested.flat();
+};
+
+/** Ohne Git-Arbeitsverzeichnis durchsucht es den Ordner selbst, sechs Ebenen tief und ohne versteckte Ordner. */
+export const workspaceSolutions = async (
+  context: WorkspaceProcessContext,
+  extensions: readonly string[],
+): Promise<{ source: "git" | "directory"; solutions: FoundSolution[] }> => {
+  const tracked = await gitSolutions(context, extensions);
+  const candidates = [...new Set(tracked ?? await directorySolutions(context.root, extensions))]
+    .filter((relative) => matches(relative, extensions))
+    .sort((left, right) => left.localeCompare(right, "de"));
+  const workspaceRoot = await realpath(context.root);
+  const found = await Promise.all(candidates.map(async (relative): Promise<FoundSolution | undefined> => {
+    const absolute = path.join(context.root, relative);
+    if (!await stat(absolute).then((info) => info.isFile(), () => false)) return undefined;
+    const root = await realpath(absolute);
+    return containsWorkspacePath(workspaceRoot, root) ? { path: relative, root } : undefined;
+  }));
+  return { source: tracked ? "git" : "directory", solutions: found.filter((entry) => entry !== undefined) };
+};

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

@@ -1,7 +1,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 "@aicontainer/agent";
+import { killProcessTree } from "@ragents/agent";
 
 const PROCESS_GROUP_JOIN_TIMEOUT_MS = 5_000;
 const PROCESS_GROUP_POLL_MS = 25;

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

@@ -0,0 +1,35 @@
+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. */
+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. */
+  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. */
+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. */
+  readonly footprints?: Readonly<Record<string, (input: unknown) => OperationFootprint>>;
+  /** Eine Anmerkung zu einer gerade geschriebenen Datei, etwa die Diagnostik eines Sprachservers. */
+  readonly annotate?: (runId: string, absolutePath: string) => Promise<string | undefined>;
+  /** Gibt frei, was das Modul für einen Run hält. */
+  readonly stopRun?: (runId: string) => Promise<void>;
+  /** Gibt alles frei; danach ruft niemand das Modul mehr auf, es darf spätere Aufrufe mit Ursache ablehnen. */
+  readonly shutdown?: () => Promise<void>;
+}
+
+/** Was ein Modul vom Executor bekommt: den Kontext eines Runs auf dieser Maschine und die Anmerkungen aller Module. */
+export interface WorkspaceModuleHost {
+  readonly contextFor: (runId: string) => Promise<WorkspaceProcessContext>;
+  readonly annotate: (runId: string, absolutePath: string) => Promise<string | undefined>;
+}
+
+export type WorkspaceModuleFactory = (host: WorkspaceModuleHost) => WorkspaceExecutorModule;

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

@@ -0,0 +1,25 @@
+import { browserModule } from "./browser/module.js";
+import { commandModule } from "./commands.js";
+import { fileModule } from "./files.js";
+import { workspaceLanguageServers } from "./language-server/adapters/index.js";
+import { languageServerModule } from "./language-server/module.js";
+import type { WorkspaceModuleFactory } from "./module.js";
+import { processModule } from "./processes/module.js";
+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. */
+  runFolder?: (runId: string) => string;
+}
+
+/** Die Module jedes Executors, im Server wie auf dem Arbeitsplatz dieselben. */
+export const workspaceExecutorModules = (options: WorkspaceExecutorModuleOptions = {}): readonly WorkspaceModuleFactory[] => [
+  sandboxToolsModule,
+  languageServerModule(workspaceLanguageServers),
+  fileModule,
+  processModule(),
+  commandModule(),
+  browserModule(),
+  runFolderModule(options.runFolder),
+];