@schlenkr/ragents 0.1.7 → 0.1.9

package/{packages/workspace-executor/src/browser → plugins/ragents.browser/executor}/playwright.ts

@@ -1,30 +1,16 @@
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { homedir } from "node:os";
-import path from "node:path";
+import { pathToFileURL } from "node:url";
 import type { Browser } from "playwright-core";
-import { RUN_MARKER_ENV } from "../run-marker.js";
-import { safeProcessEnvironment } from "../safe-environment.js";
+import type { WorkspaceExecutorMachine } from "@ragents/workspace-executor";
 import { BROWSER_EXECUTABLE_VARIABLE } from "./contract.js";
 
 type Playwright = typeof import("playwright-core");
 
-const messageOf = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
-
-/** playwright-core liegt in den node_modules des Hosts dieser Maschine und wird erst im Aufruf geladen, nie mit dem Executor. */
-export const hostPlaywright = (hostRoot: string | undefined): Playwright => {
-  if (!hostRoot) {
-    throw new Error("Für die Browserprüfung ist auf diesem Rechner kein Host bekannt, aus dem sich playwright-core auflösen "
-      + "ließe. Ein Arbeitsplatz bekommt ihn mit der ersten Verbindung zu einem verteilenden Server oder über die "
-      + "Einstellung ragents.hostPath");
-  }
-  const load = createRequire(path.join(hostRoot, "package.json"));
-  try {
-    return load("playwright-core") as Playwright;
-  } catch (cause) {
-    throw new Error(`playwright-core liegt nicht im Host ${hostRoot}: ${messageOf(cause)}`);
-  }
+/** playwright-core liegt in den node_modules des Hosts dieser Maschine und wird erst im Aufruf geladen, nie mit dem Beitrag. */
+export const hostPlaywright = async (machine: WorkspaceExecutorMachine, hostRoot: string | undefined): Promise<Playwright> => {
+  const loaded = await import(pathToFileURL(machine.hostPackageFile(hostRoot, "playwright-core")).href) as { default: Playwright };
+  return loaded.default;
 };
 
 /** Der Chrome dieser Maschine: der aus ihrer Umgebung, sonst das Chromium, das die Provisionierung für playwright-core holt. */
@@ -41,12 +27,12 @@ export const browserExecutable = async (playwright: Playwright, environment: Nod
 };
 
 /** Startet Chrome headless mit der Umgebung dieser Maschine und dem Marker des Runs, damit die Prozessanzeige ihn zuordnet. */
-export const launchChromium = async (hostRoot: string | undefined, runId: string, timeoutMs: number): Promise<Browser> => {
-  const playwright = hostPlaywright(hostRoot);
+export const launchChromium = async (machine: WorkspaceExecutorMachine, hostRoot: string | undefined, runId: string, timeoutMs: number): Promise<Browser> => {
+  const playwright = await hostPlaywright(machine, hostRoot);
   return playwright.chromium.launch({
     executablePath: await browserExecutable(playwright),
     headless: true,
     timeout: timeoutMs,
-    env: { ...safeProcessEnvironment(process.env), HOME: homedir(), [RUN_MARKER_ENV]: runId },
+    env: machine.processEnvironment(runId),
   });
 };

package/plugins/ragents.browser/provision.ts

@@ -2,13 +2,13 @@ import { spawn } from "node:child_process";
 import { access, constants } from "node:fs/promises";
 import path from "node:path";
 import { chromium } from "playwright-core";
-import { BROWSER_EXECUTABLE_VARIABLE } from "@ragents/workspace-executor";
 import {
   hostPackageFolder,
   provisionGap,
   provisionReady,
   type PluginProvision,
 } from "@ragents/host/plugin-support/provision.js";
+import { BROWSER_EXECUTABLE_VARIABLE } from "./executor/contract.js";
 
 const executable = async (file: string): Promise<boolean> => access(file, constants.X_OK).then(() => true, () => false);
 

package/plugins/ragents.browser/server/browser.ts

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+import type { SandboxServices } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
+import { documentsApiPrefix } from "@ragents/plugins/ragents.documents/contract.js";
 import {
   BROWSER_OPERATIONS,
   type BrowserCheck,
@@ -10,9 +12,7 @@ import {
   type BrowserStep,
   type BrowserTarget,
   type BrowserViewport,
-} from "@ragents/workspace-executor";
-import type { SandboxServices } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
-import { documentsApiPrefix } from "@ragents/plugins/ragents.documents/contract.js";
+} from "../executor/contract.js";
 import type { BrowserCallOptions, BrowserEvidence, BrowserRuntime } from "./contract.js";
 
 export const DEFAULT_VIEWPORT: BrowserViewport = { width: 1920, height: 1080 };

package/plugins/ragents.browser/server/contract.ts

@@ -1,7 +1,7 @@
 import { serviceToken } from "@ragents/engine";
-import type { BrowserSnapshot } from "@ragents/workspace-executor";
+import type { BrowserSnapshot } from "../executor/contract.js";
 
-export type { BrowserSnapshot, BrowserTarget } from "@ragents/workspace-executor";
+export type { BrowserSnapshot, BrowserTarget } from "../executor/contract.js";
 
 export interface BrowserEvidence {
   checkedAt?: string;

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

@@ -1,8 +1,8 @@
 import type { RAgentsPlugin } from "@ragents/engine";
-import { BROWSER_EXECUTABLE_VARIABLE } from "@ragents/workspace-executor";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
 import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
 import { documentStoreToken } from "@ragents/host/ragents/document-store.js";
+import { BROWSER_EXECUTABLE_VARIABLE } from "../executor/contract.js";
 import { RunBrowser } from "./browser.js";
 import { browserRuntimeToken } from "./contract.js";
 import { createBrowserFunctions, createBrowserImageContribution } from "./tools.js";

package/plugins/ragents.lsp-fsharp/executor.ts

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { LanguageServerDescription, WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+
+export const FSHARP_SERVER_VARIABLE = "FSHARP_LANGUAGE_SERVER";
+export const FSHARP_SERVER_FILE = "fsautocomplete/fsautocomplete.dll";
+
+const languages = { ".fs": "fsharp", ".fsi": "fsharp", ".fsx": "fsharp" } as const;
+
+export const fsharpLanguageServer: LanguageServerDescription = {
+  id: "fsharp",
+  label: "FSAC",
+  languages,
+  rootDescription: "the .sln file (or a single .fsproj)",
+};
+
+const PROJECT_LINE = /^Project\("\{[^}]+\}"\)\s*=\s*"[^"]*",\s*"([^"]+)"/gm;
+
+/** Die Projekte einer .sln, aufgelöst neben ihr; Ordnereinträge der Solution zählen nicht. */
+export const solutionProjects = async (solutionFile: string): Promise<string[]> => {
+  const text = await readFile(solutionFile, "utf8");
+  const directory = path.dirname(solutionFile);
+  return [...text.matchAll(PROJECT_LINE)]
+    .map((match) => match[1].replaceAll("\\", "/"))
+    .filter((relative) => /\.[a-z]+proj$/i.test(relative))
+    .map((relative) => path.resolve(directory, relative));
+};
+
+const dotnetCommand = (server: string, args: readonly string[]): { command: string; args: string[] } =>
+  server.toLowerCase().endsWith(".dll")
+    ? { command: "dotnet", args: [server, ...args] }
+    : { command: server, args: [...args] };
+
+const serverPath = (toolsDirectory: string): string => {
+  const configured = process.env[FSHARP_SERVER_VARIABLE];
+  if (configured) return configured;
+  const provisioned = path.join(toolsDirectory, ...FSHARP_SERVER_FILE.split("/"));
+  if (existsSync(provisioned)) return provisioned;
+  throw new Error("fsautocomplete gibt es auf diesem Rechner nicht: weder "
+    + `${FSHARP_SERVER_VARIABLE} gesetzt noch ${provisioned} vorhanden. Ein Arbeitsplatz holt es mit `
+    + `pnpm provision --workspace, ein Server über pnpm provision <profil>; ${FSHARP_SERVER_VARIABLE} übersteuert beides`);
+};
+
+const contentOf = (params: unknown): string => (params as { content?: string } | undefined)?.content ?? "";
+
+export const executor: WorkspaceExecutorContribution = (machine) => ({
+  languageServers: [{
+    ...fsharpLanguageServer,
+    resolveRoot: (workspaceRoot, root) => machine.resolveRootFile(workspaceRoot, root, [".sln", ".fsproj"]),
+    rootDirectory: (root) => path.dirname(root),
+    launch: async (context, root) => ({
+      label: "FSAC",
+      ...dotnetCommand(serverPath(machine.toolsDirectory), ["--state-directory", path.join(context.logDirectory, "fsautocomplete")]),
+      cwd: path.dirname(root),
+      env: context.env,
+      uid: context.uid,
+      gid: context.gid,
+      rootUri: pathToFileURL(path.dirname(root)).href,
+      initializationOptions: { AutomaticWorkspaceInit: false },
+      languages,
+    }),
+    open: async (session, root, timeoutMs) => {
+      const projects = root.toLowerCase().endsWith(".sln")
+        ? (await solutionProjects(root)).filter((project) => project.toLowerCase().endsWith(".fsproj"))
+        : [root];
+      if (projects.length === 0) throw new Error(`${path.basename(root)} enthält keine F#-Projekte`);
+      const finished = session.waitForNotification(timeoutMs, "Projekte geladen", (method, params) =>
+        method === "fsharp/notifyWorkspace"
+        && contentOf(params).includes("\"workspaceLoad\"")
+        && contentOf(params).includes("\"finished\""));
+      await session.request("fsharp/workspaceLoad", {
+        textDocuments: projects.map((project) => ({ uri: pathToFileURL(project).href })),
+      });
+      await finished;
+      return `${projects.length} F#-Projekt${projects.length === 1 ? "" : "e"} aus ${path.basename(root)} geladen`;
+    },
+  }],
+});

package/plugins/ragents.lsp-fsharp/provision.ts

@@ -1,6 +1,5 @@
 import { stat } from "node:fs/promises";
 import path from "node:path";
-import { FSHARP_SERVER_FILE } from "@ragents/workspace-executor";
 import {
   DOTNET_INSTRUCTION,
   downloadArchive,
@@ -15,6 +14,7 @@ import {
   type PluginProvision,
   type ProvisionState,
 } from "@ragents/host/plugin-support/provision.js";
+import { FSHARP_SERVER_FILE } from "./executor.js";
 
 export const FSAUTOCOMPLETE_VERSION = "0.83.0";
 

package/plugins/ragents.lsp-fsharp/server/index.ts

@@ -1,6 +1,6 @@
-import { fsharpAdapter, FSHARP_SERVER_VARIABLE } from "@ragents/workspace-executor";
 import { createLanguageServerPlugin } from "@ragents/host/plugin-support/language-server/plugin.js";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
+import { fsharpLanguageServer, FSHARP_SERVER_VARIABLE } from "../executor.js";
 
 export const fsharpConfigDescriptors = [
   { key: FSHARP_SERVER_VARIABLE, source: "environment" },
@@ -9,7 +9,7 @@ export const fsharpConfigDescriptors = [
 export const plugin: PluginModule = {
   create: () => createLanguageServerPlugin({
     id: "ragents.lsp-fsharp",
-    adapter: fsharpAdapter,
+    languageServer: fsharpLanguageServer,
     tabLabel: "F#",
     configDescriptors: fsharpConfigDescriptors,
   }),

package/plugins/ragents.lsp-roslyn/executor.ts

@@ -0,0 +1,64 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { LanguageServerDescription, WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+
+export const ROSLYN_SERVER_VARIABLE = "ROSLYN_LANGUAGE_SERVER";
+export const ROSLYN_SERVER_FILE = "roslyn/Microsoft.CodeAnalysis.LanguageServer.dll";
+
+const languages = { ".cs": "csharp" } as const;
+
+export const roslynLanguageServer: LanguageServerDescription = {
+  id: "roslyn",
+  label: "Roslyn",
+  languages,
+  rootDescription: "the .sln file (or a single .csproj)",
+  solutionExtensions: [".sln", ".slnx"],
+};
+
+const dotnetCommand = (server: string, args: readonly string[]): { command: string; args: string[] } =>
+  server.toLowerCase().endsWith(".dll")
+    ? { command: "dotnet", args: [server, ...args] }
+    : { command: server, args: [...args] };
+
+const serverPath = (toolsDirectory: string): string => {
+  const configured = process.env[ROSLYN_SERVER_VARIABLE];
+  if (configured) return configured;
+  const provisioned = path.join(toolsDirectory, ...ROSLYN_SERVER_FILE.split("/"));
+  if (existsSync(provisioned)) return provisioned;
+  throw new Error("Microsoft.CodeAnalysis.LanguageServer gibt es auf diesem Rechner nicht: weder "
+    + `${ROSLYN_SERVER_VARIABLE} gesetzt noch ${provisioned} vorhanden. Ein Arbeitsplatz holt ihn mit `
+    + `pnpm provision --workspace, ein Server über pnpm provision <profil>; ${ROSLYN_SERVER_VARIABLE} übersteuert beides`);
+};
+
+export const executor: WorkspaceExecutorContribution = (machine) => ({
+  languageServers: [{
+    ...roslynLanguageServer,
+    resolveRoot: (workspaceRoot, root) => machine.resolveRootFile(workspaceRoot, root, [".sln", ".slnx", ".csproj"]),
+    rootDirectory: (root) => path.dirname(root),
+    launch: async (context, root) => ({
+      label: "Roslyn",
+      ...dotnetCommand(serverPath(machine.toolsDirectory), [
+        "--stdio",
+        "--logLevel", "Warning",
+        "--extensionLogDirectory", path.join(context.logDirectory, "roslyn-logs"),
+      ]),
+      cwd: path.dirname(root),
+      env: context.env,
+      uid: context.uid,
+      gid: context.gid,
+      rootUri: pathToFileURL(path.dirname(root)).href,
+      languages,
+      newFileSettleMs: 2_000,
+    }),
+    open: async (session, root, timeoutMs) => {
+      const uri = pathToFileURL(root).href;
+      const loaded = session.waitForNotification(timeoutMs, "Projekte geladen",
+        (method) => method === "workspace/projectInitializationComplete");
+      if (root.toLowerCase().endsWith(".csproj")) session.notify("project/open", { projects: [uri] });
+      else session.notify("solution/open", { solution: uri });
+      await loaded;
+      return `${path.basename(root)} geladen`;
+    },
+  }],
+});

package/plugins/ragents.lsp-roslyn/provision.ts

@@ -1,6 +1,5 @@
 import { stat } from "node:fs/promises";
 import path from "node:path";
-import { ROSLYN_SERVER_FILE } from "@ragents/workspace-executor";
 import {
   DOTNET_INSTRUCTION,
   downloadArchive,
@@ -14,6 +13,7 @@ import {
   type PluginProvision,
   type ProvisionState,
 } from "@ragents/host/plugin-support/provision.js";
+import { ROSLYN_SERVER_FILE } from "./executor.js";
 
 export const ROSLYN_VERSION = "5.4.0-2.26179.14";
 

package/plugins/ragents.lsp-roslyn/server/index.ts

@@ -1,15 +1,22 @@
-import { roslynAdapter, ROSLYN_SERVER_VARIABLE } from "@ragents/workspace-executor";
+import path from "node:path";
 import { declaredEnvironment } from "@ragents/host/plugin-support/plugin-config.js";
 import { createLanguageServerPlugin } from "@ragents/host/plugin-support/language-server/plugin.js";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
 import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
 import { runtimeProviderToken } from "@ragents/host/ragents/host-services.js";
 import { askServiceToken } from "@ragents/plugins/ragents.ask/server/contract.js";
-import { createSolutionOnStart, SOLUTION_ON_START_VARIABLE, type SolutionOnStart } from "./solution-on-start.js";
+import { roslynLanguageServer, ROSLYN_SERVER_VARIABLE } from "../executor.js";
+import {
+  createSolutionOnStart,
+  SOLUTION_ON_START_VARIABLE,
+  SOLUTION_PREFERRED_VARIABLE,
+  type SolutionOnStart,
+} from "./solution-on-start.js";
 
 export const roslynConfigDescriptors = [
   { key: ROSLYN_SERVER_VARIABLE, source: "environment" },
   { key: SOLUTION_ON_START_VARIABLE, source: "environment" },
+  { key: SOLUTION_PREFERRED_VARIABLE, source: "environment" },
 ] as const;
 
 const PLUGIN_ID = "ragents.lsp-roslyn";
@@ -25,13 +32,26 @@ export const solutionOnStart = (): boolean => {
   return mode === "on";
 };
 
+/** Ein Pfad relativ zur Wurzel des Arbeitsbereichs, wie ihn `roslyn_solutions` nennt; ohne Laden beim Start hätte er keine Wirkung. */
+export const preferredSolution = (loadOnStart: boolean): string | undefined => {
+  const preferred = env.optional(SOLUTION_PREFERRED_VARIABLE);
+  if (preferred === undefined) return undefined;
+  if (!loadOnStart) {
+    throw new Error(`${SOLUTION_PREFERRED_VARIABLE} in der Sektion ragents.lsp-roslyn verlangt ${SOLUTION_ON_START_VARIABLE}: "on"`);
+  }
+  if (preferred === "" || preferred.includes("\\") || path.win32.isAbsolute(preferred)) {
+    throw new Error(`${SOLUTION_PREFERRED_VARIABLE} in der Sektion ragents.lsp-roslyn ist ein Pfad relativ zum Arbeitsbereich mit Schrägstrichen, nicht "${preferred}"`);
+  }
+  return preferred;
+};
+
 export const plugin: PluginModule = {
   requires: ["ragents.ask"],
   create: () => {
     let startup: SolutionOnStart | undefined;
     const languageServer = createLanguageServerPlugin({
       id: PLUGIN_ID,
-      adapter: roslynAdapter,
+      languageServer: roslynLanguageServer,
       configDescriptors: roslynConfigDescriptors,
       onOpened: (runId) => startup?.opened(runId),
     });
@@ -39,10 +59,13 @@ export const plugin: PluginModule = {
       manifest: languageServer.manifest,
       register: (host) => {
         languageServer.register(host);
-        if (!solutionOnStart()) return;
+        const loadOnStart = solutionOnStart();
+        const preferred = preferredSolution(loadOnStart);
+        if (!loadOnStart) return;
         startup = createSolutionOnStart({
           pluginId: PLUGIN_ID,
-          adapterId: roslynAdapter.id,
+          adapterId: roslynLanguageServer.id,
+          preferred,
           sandbox: () => host.service(sandboxServicesToken),
           runtime: () => host.service(runtimeProviderToken)(),
           ask: () => host.service(askServiceToken),

package/plugins/ragents.lsp-roslyn/server/solution-on-start.ts

@@ -8,6 +8,7 @@ import type { SandboxServices } from "@ragents/host/plugin-support/workspace-san
 import { DISMISSED_ANSWER, type AskService } from "@ragents/plugins/ragents.ask/server/contract.js";
 
 export const SOLUTION_ON_START_VARIABLE = "ROSLYN_SOLUTION_ON_START";
+export const SOLUTION_PREFERRED_VARIABLE = "ROSLYN_SOLUTION_PREFERRED";
 export const NO_SOLUTION = "Keine laden";
 export const SOLUTION_QUESTION = "Welche Solution soll Roslyn für die Diagnostik laden?";
 
@@ -21,11 +22,21 @@ export type SolutionAnswer =
   | { kind: "open"; path: string }
   | { kind: "forward" };
 
-/** Was jemand schon geöffnet hat oder gerade öffnet, bleibt ohne Frage und ohne zweites Laden. */
-export const solutionStartStep = (listing: LanguageServerSolutions): SolutionStartStep => {
+/** Die Vorgabe passt auch in einem Unterordner, etwa wenn der Arbeitsbereich der Ordner über dem Checkout ist. */
+const matchesPreferred = (solution: string, preferred: string): boolean => {
+  const path = solution.toLowerCase();
+  const expected = preferred.toLowerCase();
+  return path === expected || path.endsWith(`/${expected}`);
+};
+
+/** Was jemand schon geöffnet hat oder gerade öffnet, bleibt ohne Frage und ohne zweites Laden; passt die Vorgabe, zählen nur die passenden Solutions. */
+export const solutionStartStep = (listing: LanguageServerSolutions, preferred?: string): SolutionStartStep => {
   if (listing.opened || listing.solutions.length === 0) return { kind: "none" };
-  if (listing.solutions.length === 1) return { kind: "open", path: listing.solutions[0].path };
-  return { kind: "ask", options: [...listing.solutions.map((solution) => solution.path), NO_SOLUTION] };
+  const paths = listing.solutions.map((solution) => solution.path);
+  const matching = preferred === undefined ? [] : paths.filter((path) => matchesPreferred(path, preferred));
+  const candidates = matching.length > 0 ? matching : paths;
+  if (candidates.length === 1) return { kind: "open", path: candidates[0] };
+  return { kind: "ask", options: [...candidates, NO_SOLUTION] };
 };
 
 /** Eine frei formulierte Antwort bekommt der Koordinator, damit sie nicht verloren geht. */
@@ -38,6 +49,7 @@ export const solutionAnswer = (options: readonly string[], answer: string): Solu
 export interface SolutionOnStartOptions {
   pluginId: string;
   adapterId: string;
+  preferred?: string;
   sandbox: () => SandboxServices;
   runtime: () => Orchestration;
   ask: () => AskService;
@@ -45,7 +57,7 @@ export interface SolutionOnStartOptions {
 
 const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
 
-/** Lädt beim Start ohne Run-Script die einzige Solution oder fragt bei mehreren; der Merker im Journal lässt das je Run höchstens einmal zu. */
+/** Lädt beim Start ohne Run-Script die Vorgabe oder die einzige Solution oder fragt bei mehreren; der Merker im Journal lässt das je Run höchstens einmal zu. */
 export interface SolutionOnStart {
   lifecycle: SessionLifecycleContribution;
   /** Jemand hat eine Instanz geöffnet; eine noch offene Startfrage erledigt sich damit ohne Laden und ohne Input. */
@@ -78,7 +90,7 @@ export const createSolutionOnStart = (options: SolutionOnStartOptions): Solution
 
   const begin = async (runId: string, ownerId: string, coordinatorId: string, signal: AbortSignal): Promise<{ rest: Promise<void> }> => {
     const listing = await options.sandbox().execute(runId, languageServerSolutionsOperation(options.adapterId), null, { signal }) as LanguageServerSolutions;
-    const step = solutionStartStep(listing);
+    const step = solutionStartStep(listing, options.preferred);
     if (step.kind === "none") return { rest: Promise.resolve() };
     if (step.kind === "open") return { rest: load(runId, step.path, true, signal) };
     const answer = options.ask().ask(

package/plugins/ragents.lsp-typescript/executor.ts

@@ -0,0 +1,50 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { LanguageServerDescription, WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+
+const languages = {
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+} as const;
+
+export const typescriptLanguageServer: LanguageServerDescription = {
+  id: "typescript",
+  label: "TypeScript",
+  languages,
+  rootDescription: "the directory whose tsconfig.json projects should be served (e.g. src)",
+};
+
+const hasWorkspaceTypeScript = (root: string): Promise<boolean> =>
+  stat(path.join(root, "node_modules", "typescript", "lib", "tsserver.js")).then((info) => info.isFile(), () => false);
+
+/** Sprachserver und Compiler liegen in den node_modules des Hosts dieser Maschine; ohne Host gibt es sie hier nicht. */
+export const executor: WorkspaceExecutorContribution = (machine) => ({
+  languageServers: [{
+    ...typescriptLanguageServer,
+    resolveRoot: machine.resolveRootDirectory,
+    rootDirectory: (root) => root,
+    launch: async (context, root) => ({
+      label: "TypeScript",
+      command: process.execPath,
+      args: [machine.hostPackageFile(context.hostRoot, "typescript-language-server/lib/cli.mjs"), "--stdio"],
+      cwd: root,
+      // Im Extension-Host ist process.execPath Electron; ohne diese Variable startet es die Anwendung statt des Skripts.
+      env: { ...context.env, ELECTRON_RUN_AS_NODE: "1" },
+      uid: context.uid,
+      gid: context.gid,
+      rootUri: pathToFileURL(root).href,
+      initializationOptions: await hasWorkspaceTypeScript(root)
+        ? {}
+        : { tsserver: { path: path.dirname(machine.hostPackageFile(context.hostRoot, "typescript")) } },
+      languages,
+      publishesOnlyChangedDiagnostics: true,
+    }),
+    open: async (_session, root) =>
+      `TypeScript-Server auf ${path.basename(root)} bereit; Projekte werden je Datei aus der nächsten tsconfig.json geladen`,
+  }],
+});

package/plugins/ragents.lsp-typescript/server/index.ts

@@ -1,7 +1,7 @@
-import { typescriptAdapter } from "@ragents/workspace-executor";
 import { createLanguageServerPlugin } from "@ragents/host/plugin-support/language-server/plugin.js";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
+import { typescriptLanguageServer } from "../executor.js";
 
 export const plugin: PluginModule = {
-  create: () => createLanguageServerPlugin({ id: "ragents.lsp-typescript", adapter: typescriptAdapter }),
+  create: () => createLanguageServerPlugin({ id: "ragents.lsp-typescript", languageServer: typescriptLanguageServer }),
 };

package/plugins/ragents.model-relay/server/config.ts

@@ -2,7 +2,7 @@ import { configuredModelAliases, type ModelAlias } from "@ragents/host/plugin-su
 
 /** Das Relay bietet die Aliasse des Profils an (MODEL_ALIASES im Abschnitt host), dieselben wie für die eigenen Runs. */
 export const relayAliases = (aliases: readonly ModelAlias[]): readonly ModelAlias[] => {
-  if (aliases.length === 0) throw new Error("ragents.model-relay braucht MODEL_ALIASES im Abschnitt host; erwartet wird eine Liste \"alias=anbieter/modell\"");
+  if (aliases.length === 0) throw new Error("ragents.model-relay needs MODEL_ALIASES in the host section, a list of { alias, model, thinking?, compaction }");
   return aliases;
 };
 

package/plugins/ragents.model-relay/server/relay.ts

@@ -18,6 +18,7 @@ export interface ResolvedAlias {
   readonly alias: string;
   readonly upstream: ModelUpstream;
   readonly model: ModelUpstream["models"][number];
+  readonly compaction: ModelAlias["compaction"];
 }
 
 /** Jeder Alias muss auf einen konfigurierten Anbieter und ein Modell aus dessen Katalog zeigen. */
@@ -30,10 +31,10 @@ export const resolveAliases = (aliases: readonly ModelAlias[], upstreams: readon
     }
     const model = upstream.models.find((candidate) => candidate.id === entry.model);
     if (!model) throw new Error(`MODEL_ALIASES: das Modell ${entry.model} hinter ${entry.alias} fehlt im Katalog von ${entry.upstream}`);
-    return { alias: entry.alias, upstream, model };
+    return { alias: entry.alias, upstream, model, compaction: entry.compaction };
   });
 
-/** Der Katalogeintrag nennt nur, was der Verbraucher für den Draht braucht; Name, Anbieter und Kosten bleiben beim Server. */
+/** Der Katalogeintrag nennt nur, was der Verbraucher für Draht und Kompaktierung braucht; Name, Anbieter und Kosten bleiben beim Server. */
 export const catalogEntryOf = (resolved: ResolvedAlias) => ({
   id: resolved.alias,
   object: "model" as const,
@@ -44,6 +45,7 @@ export const catalogEntryOf = (resolved: ResolvedAlias) => ({
     input: [...resolved.model.input],
     contextWindow: resolved.model.contextWindow,
     maxTokens: resolved.model.maxTokens,
+    compaction: resolved.compaction,
     ...(resolved.model.compat ? { compat: resolved.model.compat } : {}),
   },
 });

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

@@ -55,7 +55,8 @@ const checkSections = (source: string, raw: Record<string, unknown>, pluginIds:
       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`);
       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) => 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`);
     }