@schlenkr/ragents 0.1.4 → 0.1.6

package/scripts/remote/connect.ts

@@ -1,32 +1,32 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { extract as extractTar } from "tar";
 import { ragentsDataRoot } from "../../apps/server/src/data-directory.ts";
+import { filesBelow } from "../../apps/server/src/folder-install.ts";
 import { removeHostRecord, writeHostRecord } from "../../apps/server/src/host-record.ts";
-import { hostRoot, readHostPackage, readHostVersion } from "../../apps/server/src/host-version.ts";
+import { hostRoot, readHostApiVersion, readHostPackage } from "../../apps/server/src/host-version.ts";
+import { BUNDLE_MANIFEST_FILE, bundleStand } from "../../apps/server/src/profile/bundle-manifest.ts";
 import { readProfileTarget } from "../../apps/server/src/profile-target.ts";
-import { ensureWebBuild } from "../../apps/server/src/web-build.ts";
 import { RpcClient } from "../../apps/web/src/rpc/client.ts";
 import { profileDistributionContracts, type ClientProfileDescription } from "../../plugins/ragents.profile-distribution/contract.ts";
 
 const usage = (): string => `Verwendung: RAGENTS_TOKEN=<token> ragents connect <server-url> [--port <n>] [--clean] [--no-start]
-Holt das Client-Profil des Servers samt gebautem Web in den lokalen Cache, prüft die Host-Version
-gegen diesen Host und startet den lokalen Server mit dem Profil. --clean entfernt ältere Stände,
---no-start endet nach dem Holen und nennt Profildatei und Datenordner. Im Checkout heißt der
-Befehl pnpm connect.`;
+Holt das Client-Profil des Servers samt seinen Bundles in den lokalen Cache, prüft die Host-API
+gegen diesen Host und startet den lokalen Server mit dem Profil und dem Web dieses Hosts. --clean
+entfernt ältere Stände, --no-start endet nach dem Holen und nennt Profildatei und Datenordner. Im
+Checkout heißt der Befehl pnpm connect.`;
 
 export interface ConnectOptions {
   readonly serverUrl: string;
   readonly token: string;
   readonly dataRoot?: string;
-  /** Der Host, dessen Fassung zur verlangten Host-Version passen muss: Checkout oder Paket; Vorgabe ist dieser hier. */
+  /** Der Host, dessen Host-API und eingebaute Bundles zum Profil passen müssen: Checkout oder Paket; Vorgabe ist dieser hier. */
   readonly hostPath?: string;
-  readonly localVersion?: string;
   readonly clean?: boolean;
   readonly fetch?: typeof fetch;
 }
@@ -34,7 +34,6 @@ export interface ConnectOptions {
 export interface ConnectedProfile {
   readonly description: ClientProfileDescription;
   readonly profileFile: string;
-  readonly webDirectory: string;
   readonly dataDirectory: string;
   readonly cacheDirectory: string;
   readonly downloaded: boolean;
@@ -45,9 +44,7 @@ export interface CachedProfile {
   readonly serverUrl: string;
   readonly profile: string;
   readonly version: string;
-  readonly hostVersion: string;
   readonly profileFile: string;
-  readonly webDirectory: string;
   readonly dataDirectory: string;
 }
 
@@ -94,11 +91,22 @@ const describeProfile = async (options: ConnectOptions): Promise<ClientProfileDe
     baseUrl,
     fetch: (input, init) => fetchImpl(input, { ...init, headers: { ...init?.headers as Record<string, string> | undefined, authorization: `Bearer ${options.token}` } }),
   });
-  try {
-    return await rpc.call(profileDistributionContracts.describe, {});
-  } catch (error) {
+  const description = await rpc.call(profileDistributionContracts.describe, {}).catch((error: unknown) => {
     throw new Error(`Der Server ${baseUrl} liefert kein Client-Profil: ${error instanceof Error ? error.message : String(error)}`);
-  }
+  });
+  return checkedDescription(baseUrl, description);
+};
+
+/** Stand, Profil und Datei werden Pfade im Cache; nur, was dort nicht herausführen kann, wird angenommen. */
+const checkedDescription = (baseUrl: string, description: ClientProfileDescription): ClientProfileDescription => {
+  const rejected = (field: string, value: string): Error =>
+    new Error(`Der Server ${baseUrl} nennt ein ungültiges Client-Profil: ${field} ${JSON.stringify(value)}`);
+  if (!/^[0-9a-f]{64}$/.test(description.version)) throw rejected("version", description.version);
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(description.profile)) throw rejected("profile", description.profile);
+  const segments = description.file.split("/");
+  if (segments.some((segment) => segment === "" || segment === "." || segment === ".." || segment.includes("\\"))
+    || segments.at(-1) !== `ragents.config.${description.profile}.ts`) throw rejected("file", description.file);
+  return description;
 };
 
 const downloadArchive = async (options: ConnectOptions, description: ClientProfileDescription): Promise<Buffer> => {
@@ -112,7 +120,7 @@ const downloadArchive = async (options: ConnectOptions, description: ClientProfi
   return archive;
 };
 
-/** Profildatei und Archiv-Plugins sind ESM; ohne diese Marke liest Node sie im Cache als CommonJS. */
+/** Die Profildatei ist ESM; ohne diese Marke liest Node sie im Cache als CommonJS. Bundles lädt der Haken des Hosts ohnehin als ESM. */
 const markAsModule = async (directory: string): Promise<void> => {
   const file = path.join(directory, "package.json");
   if (!existsSync(file)) {
@@ -123,26 +131,50 @@ const markAsModule = async (directory: string): Promise<void> => {
   if (declared !== "module") throw new Error(`Das Archiv bringt eine package.json mit type ${JSON.stringify(declared)}; RAgents-Profile sind ESM`);
 };
 
-/** Der Rat bei einer falschen Fassung hängt daran, woher der Host kommt: Paket oder Checkout. */
-const versionMismatch = (hostPath: string, localVersion: string, description: ClientProfileDescription): Error => {
+/** Jedes Bundle im Archiv muss genau die Dateien tragen, mit denen es gebaut wurde; ein verlustbehaftetes Packen fiele sonst erst beim Laden auf. */
+const assertArchivedBundles = (staging: string): void => {
+  for (const manifestFile of filesBelow(staging).filter((file) => path.posix.basename(file) === BUNDLE_MANIFEST_FILE)) {
+    const folder = path.join(staging, ...path.posix.dirname(manifestFile).split("/"));
+    const manifest = JSON.parse(readFileSync(path.join(folder, BUNDLE_MANIFEST_FILE), "utf8")) as { id?: unknown; stand?: unknown };
+    if (bundleStand(folder) !== manifest.stand) {
+      throw new Error(`Das Bundle ${String(manifest.id)} im Archiv des Servers hat nicht die Dateien, mit denen es gebaut wurde (stand in ${manifestFile}); auf dem Server neu bauen und ragents connect wiederholen`);
+    }
+  }
+};
+
+/** Wie ein Host zum Stand des Servers kommt, hängt daran, woher er stammt: Paket oder Checkout. */
+const hostAdvice = (hostPath: string, description: ClientProfileDescription): string => {
   const packaged = readHostPackage(hostPath);
-  const advice = packaged
-    ? `Hol die passende Fassung: npm install -g ${packaged.name}@${description.packageVersion} (installiert ist ${packaged.version}).`
-    : `Wechseln mit: git -C ${JSON.stringify(hostPath)} fetch && git -C ${JSON.stringify(hostPath)} checkout ${description.hostVersion}`;
-  return new Error(`Der Server verlangt den Host ${description.hostVersion}, ${packaged ? "das Paket" : "der Checkout"} ${hostPath} `
-    + `steht auf ${localVersion}.\n${advice}`);
+  return packaged
+    ? `Hol die Fassung des Servers: npm install -g ${packaged.name}@${description.packageVersion} (installiert ist ${packaged.version}).`
+    : `Wechsle auf den Commit des Servers: git -C ${JSON.stringify(hostPath)} fetch && git -C ${JSON.stringify(hostPath)} checkout ${description.hostVersion}, danach pnpm build:plugins und pnpm build:web.`;
 };
 
-/** Holt Beschreibung und Archiv, prüft Host-Version und Stand und legt den Stand im Cache ab; startet nichts. */
+/** Die eingebauten Plugins des Profils, für die der Host kein Bundle hat; ohne sie startet das Profil nicht. */
+const missingBuiltIns = (hostPath: string, description: ClientProfileDescription): readonly string[] =>
+  description.plugins
+    .filter((plugin) => plugin.source === "host" && !existsSync(path.join(hostPath, "bundles", plugin.id, "ragents-bundle.json")))
+    .map((plugin) => plugin.id);
+
+/** Die Bundles im Archiv sind gegen die Host-API des Servers gebaut, die eingebauten kommen vom Host des Clients; beides muss dort passen. */
+const assertHostFits = (hostPath: string, description: ClientProfileDescription): void => {
+  const localApi = readHostApiVersion(hostPath);
+  if (localApi !== description.hostApi) {
+    throw new Error(`Der Server verteilt sein Profil für Host-API ${description.hostApi}, der Host ${hostPath} bietet Host-API ${localApi}.\n${hostAdvice(hostPath, description)}`);
+  }
+  const missing = missingBuiltIns(hostPath, description);
+  if (missing.length === 0) return;
+  const rebuild = readHostPackage(hostPath) ? "" : "Im Checkout zuerst pnpm build:plugins; fehlt die Quelle unter plugins/: ";
+  throw new Error(`Das Profil nennt eingebaute Plugins, für die der Host ${hostPath} kein Bundle hat: ${missing.join(", ")}.\n${rebuild}${hostAdvice(hostPath, description)}`);
+};
+
+/** Holt Beschreibung und Archiv, prüft Host-API, eingebaute Bundles und Stand und legt den Stand im Cache ab; startet nichts. */
 export const prepareProfile = async (options: ConnectOptions): Promise<ConnectedProfile> => {
   const description = await describeProfile(options);
-  const hostPath = options.hostPath ?? hostRoot();
-  const localVersion = options.localVersion ?? readHostVersion(hostPath);
-  if (localVersion !== description.hostVersion) throw versionMismatch(hostPath, localVersion, description);
+  assertHostFits(options.hostPath ?? hostRoot(), description);
   const layout = remoteLayout(options.dataRoot ?? ragentsDataRoot(), options.serverUrl, description.profile);
   const cacheDirectory = path.join(layout.profiles, description.version);
   const profileFile = path.join(cacheDirectory, ...description.file.split("/"));
-  const webDirectory = path.join(cacheDirectory, ...description.web.split("/"));
   let downloaded = false;
   if (!existsSync(profileFile)) {
     const archive = await downloadArchive(options, description);
@@ -151,12 +183,17 @@ export const prepareProfile = async (options: ConnectOptions): Promise<Connected
     await mkdir(staging, { recursive: true });
     const file = path.join(staging, "profile.tar.gz");
     await writeFile(file, archive);
-    await extractTar({ file, cwd: staging, strict: true });
+    const foreign: string[] = [];
+    await extractTar({ file, cwd: staging, strict: true, filter: (entryPath, entry) => {
+      const type = "type" in entry ? entry.type : undefined;
+      if (type === "File" || type === "Directory") return true;
+      foreign.push(`${entryPath} (${String(type)})`);
+      return false;
+    } });
+    if (foreign.length > 0) throw new Error(`Das Archiv enthält Einträge, die weder Datei noch Ordner sind: ${foreign.join(", ")}; ein Client-Profil trägt nur Dateien`);
     await rm(file);
     if (!existsSync(path.join(staging, ...description.file.split("/")))) throw new Error(`Das Archiv enthält die Profildatei ${description.file} nicht`);
-    if (!existsSync(path.join(staging, ...description.web.split("/"), "index.html"))) {
-      throw new Error(`Das Archiv enthält das gebaute Web ${description.web}/index.html nicht`);
-    }
+    assertArchivedBundles(staging);
     await markAsModule(staging);
     await rm(cacheDirectory, { recursive: true, force: true });
     await rename(staging, cacheDirectory);
@@ -172,13 +209,11 @@ export const prepareProfile = async (options: ConnectOptions): Promise<Connected
     serverUrl: options.serverUrl,
     profile: description.profile,
     version: description.version,
-    hostVersion: description.hostVersion,
     profileFile,
-    webDirectory,
     dataDirectory: layout.data,
   };
   await writeFile(layout.current, `${JSON.stringify(cached, null, 2)}\n`);
-  return { description, profileFile, webDirectory, dataDirectory: layout.data, cacheDirectory, downloaded };
+  return { description, profileFile, dataDirectory: layout.data, cacheDirectory, downloaded };
 };
 
 /** Startet ein Host-Skript wie der Checkout: Node mit dem tsx-Loader, Arbeitsverzeichnis apps/server, ohne pnpm. */
@@ -222,9 +257,7 @@ const main = async (): Promise<void> => {
     serverUrl: arguments_.serverUrl,
     profile: description.profile,
     version: description.version,
-    hostVersion: description.hostVersion,
     profileFile: prepared.profileFile,
-    webDirectory: prepared.webDirectory,
     dataDirectory: prepared.dataDirectory,
   }, arguments_.port);
 };
@@ -234,8 +267,6 @@ export interface StartedProfile {
   readonly profileFile: string;
   /** Nur bei einem geholten Stand gesetzt; ein Profil des Hosts nimmt die Vorgaben seiner eigenen Konfiguration. */
   readonly dataDirectory?: string;
-  /** Nur bei einem geholten Stand gesetzt; sonst baut der Start das Web des Profils selbst. */
-  readonly webDirectory?: string;
   readonly port: number | undefined;
 }
 
@@ -249,7 +280,7 @@ export const noteHost = (profile: string, dataDirectory: string, port: number):
     startedAt: new Date().toISOString(),
   }) : undefined;
 
-/** Provisioniert die Werkzeuge des Profils, baut sein Web falls nötig und startet den Server damit. */
+/** Provisioniert die Werkzeuge des Profils und startet den Server damit. */
 export const startProfile = async (started: StartedProfile): Promise<number> => {
   const target = await readProfileTarget(started.profile, started.profileFile);
   const dataDirectory = started.dataDirectory ?? target.dataDirectory;
@@ -263,29 +294,20 @@ export const startProfile = async (started: StartedProfile): Promise<number> =>
   console.log("== Werkzeuge provisionieren");
   const provisioned = await run(hostScript("scripts/provision/run-provision.ts"), env);
   if (provisioned !== 0) throw new Error(`Die Provisionierung endete mit Code ${provisioned}`);
-  const webDirectory = started.webDirectory ?? await ensureWebBuild({
-    root: hostRoot(),
-    profile: started.profile,
-    profileFile: started.profileFile,
-    dataDirectory,
-    environment: env,
-    log: (line) => console.log(line),
-  });
-  console.log(`== Server starten (Web ${webDirectory}, Daten ${dataDirectory})`);
+  console.log(`== Server starten (Daten ${dataDirectory})`);
   const note = noteHost(started.profile, dataDirectory, port);
   try {
-    return await run(hostScript("apps/server/src/main.ts", started.port !== undefined ? ["--port", String(started.port)] : []), { ...env, WEB_DIST_DIR: webDirectory }, note);
+    return await run(hostScript("apps/server/src/main.ts", started.port !== undefined ? ["--port", String(started.port)] : []), env, note);
   } finally {
     if (note) removeHostRecord(dataDirectory);
   }
 };
 
-/** Startet einen Stand, den connect geholt hat, mit dem Web aus dem Cache. */
+/** Startet einen Stand, den connect geholt hat; das Web kommt wie bei jedem Profil vom Host. */
 export const startCached = (cached: CachedProfile, port: number | undefined): Promise<number> => startProfile({
   profile: cached.profile,
   profileFile: cached.profileFile,
   dataDirectory: cached.dataDirectory,
-  webDirectory: cached.webDirectory,
   port,
 });
 

package/scripts/remote/start.ts

@@ -1,4 +1,4 @@
-// Der Hook löst @aicontainer/* auch für eine Profildatei außerhalb des Hosts auf; im Paket gibt es dort kein node_modules.
+// Der Hook löst @ragents/* auch für eine Profildatei außerhalb des Hosts auf; im Paket gibt es dort kein node_modules.
 import "../../apps/server/src/host-resolution.ts";
 import { readFile, readdir } from "node:fs/promises";
 import path from "node:path";
@@ -8,10 +8,9 @@ import { localProfile } from "../../apps/server/src/profile-target.ts";
 import { startCached, startProfile, type CachedProfile } from "./connect.ts";
 
 const usage = (): string => `Verwendung: ragents start <profil|pfad> [--port <n>]
-Startet ein Profil dieses Hosts (core, developer), eine eigene ragents.config.<profil>.ts an
+Startet ein Profil dieses Hosts (core, developer, showcase), eine eigene ragents.config.<profil>.ts an
 beliebiger Stelle oder einen Stand, den ragents connect schon geholt hat, ohne den Server zu
-fragen. Ein eigenes Profil bekommt sein Web beim Start gebaut, ein geholter Stand bringt es aus
-demselben Cache mit. Ohne Argument nennt der Befehl die Profile im Cache.`;
+fragen. Das Web kommt fertig mit dem Host, für jedes Profil dasselbe.`;
 
 export const parseArguments = (argv: readonly string[]): { selection: string; port: number | undefined } => {
   let profile: string | undefined;

package/scripts/workspace-client/run-workspace-client.ts

@@ -4,17 +4,20 @@ import { hostname } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { hostRoot } from "../../apps/server/src/host-version.ts";
+import { callerDirectory } from "../../apps/server/src/profile-target.ts";
 import { provisionWorkspace } from "../../apps/server/src/profile/provisioning.ts";
 import { workspaceClientTransport } from "../../plugins/ragents.workspace/client/transport.ts";
-import { WorkspaceClient } from "../../plugins/ragents.workspace/client/workspace-client.ts";
+import { WorkspaceClient, workstationRunsDirectory } from "../../plugins/ragents.workspace/client/workspace-client.ts";
 
 const usage = (): string => `Verwendung: [RAGENTS_TOKEN=<token>] pnpm workspace-client <server-url> [ordner ...] [--id <kennung>] [--label <name>]
 Meldet die Ordner als Arbeitsplatz beim Server an und führt dessen Aufträge mit dem Executor
 dieses Rechners aus - dasselbe, was die VS-Code-Erweiterung tut, nur ohne VS Code. Ohne Ordner
 gilt das aktuelle Verzeichnis. Jeder Werkzeugaufruf erscheint als eine Zeile auf stdout.
-Die Sprachserver holt der Start in den Werkzeugordner dieses Rechners (dasselbe wie
-pnpm provision --workspace); ROSLYN_LANGUAGE_SERVER und FSHARP_LANGUAGE_SERVER übersteuern ihn,
-TypeScript kommt aus dem Host-Ordner. Das Skript läuft, bis es mit Strg-C beendet wird.`;
+Sprachserver und Chromium holt der Start auf diesen Rechner (dasselbe wie pnpm provision
+--workspace); ROSLYN_LANGUAGE_SERVER, FSHARP_LANGUAGE_SERVER und BROWSER_EXECUTABLE_PATH
+übersteuern das, TypeScript und playwright-core kommen aus dem Host-Ordner. Unter Windows nennt
+RAGENTS_BASH die bash.exe, die RAgents mitbringt (aus der Windows-Fassung der VS-Code-Erweiterung);
+ohne sie scheitert das Werkzeug bash. Das Skript läuft, bis es mit Strg-C beendet wird.`;
 
 export interface WorkspaceClientArguments {
   readonly serverUrl: string;
@@ -51,8 +54,9 @@ export const parseArguments = (argv: readonly string[]): WorkspaceClientArgument
 export const workspaceClientId = (host: string, folders: readonly string[]): string =>
   `cli-${createHash("sha256").update([host, ...folders].join("\n")).digest("hex").slice(0, 32)}`;
 
-export const resolvedFolders = (folders: readonly string[], cwd: string): string[] => {
-  const resolved = (folders.length > 0 ? folders : [cwd]).map((folder) => path.resolve(cwd, folder));
+/** Ordner gelten ab dem Aufrufer; pnpm und der bin-Befehl starten das Skript in apps/server. */
+export const resolvedFolders = (folders: readonly string[], caller = callerDirectory()): string[] => {
+  const resolved = (folders.length > 0 ? folders : [caller]).map((folder) => path.resolve(caller, folder));
   for (const folder of resolved) {
     if (!statSync(folder, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`Kein Verzeichnis: ${folder}`);
   }
@@ -61,7 +65,7 @@ export const resolvedFolders = (folders: readonly string[], cwd: string): string
 
 const main = async (): Promise<void> => {
   const parsed = parseArguments(process.argv.slice(2));
-  const folders = resolvedFolders(parsed.folders, process.cwd());
+  const folders = resolvedFolders(parsed.folders);
   const host = hostname();
   const identity = {
     id: parsed.id ?? workspaceClientId(host, folders),
@@ -69,12 +73,14 @@ const main = async (): Promise<void> => {
     hostname: host,
     platform: process.platform,
     folders,
+    runsDirectory: workstationRunsDirectory(),
   };
   const transport = workspaceClientTransport(parsed.serverUrl, process.env.RAGENTS_TOKEN);
   const client = new WorkspaceClient(transport, identity, {
     hostRoot,
-    onExecuted: ({ runId, tool, durationMs, error }) =>
-      console.log(`== ${runId.slice(0, 8)} ${tool} ${durationMs} ms ${error ?? "ok"}`),
+    bash: process.env.RAGENTS_BASH || undefined,
+    onExecuted: ({ runId, operation, durationMs, error }) =>
+      console.log(`== ${runId.slice(0, 8)} ${operation} ${durationMs} ms ${error ?? "ok"}`),
   });
   console.log(`== Arbeitsplatz ${identity.label} (${identity.id})`);
   for (const folder of folders) console.log(`== Ordner ${folder}`);

package/apps/server/agent-home/settings.json

@@ -1,3 +0,0 @@
-{
-  "defaultProvider": "openrouter"
-}

package/apps/server/src/chat-attachments.ts

@@ -1,52 +0,0 @@
-import type { ChatAttachmentInput } from "./chat-events.js";
-
-export const MAX_CHAT_ATTACHMENTS = 8;
-export const MAX_CHAT_ATTACHMENT_BYTES = 20 * 1024 * 1024;
-export const MAX_CHAT_REQUEST_BYTES = 29 * 1024 * 1024;
-
-export const chatAttachmentMediaType = (name: string, mediaType: string): string => {
-  const explicit = mediaType.trim().toLowerCase();
-  if (explicit) return explicit === "video/quicktime" ? "video/mov" : explicit;
-  const types: Record<string, string> = {
-    png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp",
-    avif: "image/avif", svg: "image/svg+xml", pdf: "application/pdf",
-    mp4: "video/mp4", webm: "video/webm", mov: "video/mov", mpeg: "video/mpeg", mpg: "video/mpeg",
-    txt: "text/plain", md: "text/markdown", csv: "text/csv", tsv: "text/tab-separated-values",
-    json: "application/json", jsonl: "application/x-ndjson", xml: "application/xml",
-    yaml: "application/yaml", yml: "application/yaml", ts: "text/plain", tsx: "text/plain",
-    js: "application/javascript", py: "text/plain", cs: "text/plain", fs: "text/plain",
-    html: "text/html", css: "text/css", log: "text/plain",
-  };
-  return types[name.split(".").at(-1)?.toLowerCase() ?? ""] ?? "application/octet-stream";
-};
-
-export const parseChatAttachments = (value: unknown): ChatAttachmentInput[] => {
-  if (value === undefined) return [];
-  if (!Array.isArray(value) || value.length > MAX_CHAT_ATTACHMENTS) {
-    throw new Error(`Anhänge müssen eine Liste mit höchstens ${MAX_CHAT_ATTACHMENTS} Dateien sein.`);
-  }
-  let total = 0;
-  return value.map((entry, index) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry)) throw new Error(`Anhang ${index + 1} ist ungültig.`);
-    const { name, mediaType, data } = entry as Record<string, unknown>;
-    if (typeof name !== "string" || !name.trim() || name.length > 255 || /[/\\\u0000-\u001f\u007f]/.test(name)
-      || name === "." || name === "..") throw new Error(`Anhang ${index + 1} benötigt einen gültigen Dateinamen ohne Pfad.`);
-    const normalizedType = typeof mediaType === "string" ? chatAttachmentMediaType(name, mediaType) : "";
-    if (!/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/i.test(normalizedType)) {
-      throw new Error(`Anhang ${name} benötigt einen gültigen MIME-Typ.`);
-    }
-    if (typeof data === "string" && data.length > Math.ceil(MAX_CHAT_ATTACHMENT_BYTES / 3) * 4)
-      throw new Error("Anhänge dürfen zusammen höchstens 20 MiB groß sein.");
-    if (typeof data !== "string" || data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(data)) {
-      throw new Error(`Anhang ${name} enthält ungültiges Base64.`);
-    }
-    const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
-    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    if (padding && (alphabet.indexOf(data[data.length - padding - 1]) & (padding === 2 ? 15 : 3)) !== 0) {
-      throw new Error(`Anhang ${name} enthält nichtkanonisches Base64.`);
-    }
-    total += data.length / 4 * 3 - padding;
-    if (total > MAX_CHAT_ATTACHMENT_BYTES) throw new Error("Anhänge dürfen zusammen höchstens 20 MiB groß sein.");
-    return { name, mediaType: normalizedType, data };
-  });
-};

package/apps/server/src/chat-events.ts

@@ -1,185 +0,0 @@
-export type Role = "user" | "assistant" | "thinking" | "tool" | "system" | "question";
-
-export interface ChatAttachmentInput {
-  name: string;
-  mediaType: string;
-  data: string;
-}
-
-export interface ChatAttachment {
-  name: string;
-  mediaType: string;
-  size: number;
-  url: string;
-}
-
-export interface ChatAttachmentCapabilities {
-  input: readonly string[];
-  model: string;
-}
-
-export interface ToolInfo {
-  id: string;
-  name: string;
-  arguments: string;
-  result?: string;
-  isError?: boolean;
-}
-
-export interface ChatTextCursor {
-  conversationId: string;
-  sequence: number;
-  /** Accumulated non-whitespace UTF-16 units in the turn anchored by sequence. */
-  offset: number;
-}
-
-export interface ChatJournalCursor {
-  conversationId: string;
-  eventId: string;
-  sequence: number;
-}
-
-/** Eine Rückfrage des Assistenten. `answer` gesetzt heißt: beantwortet, die Karte ist nur noch Beleg. */
-export interface Question {
-  callId: string;
-  options: string[];
-  multi?: boolean;
-  answer?: string;
-}
-
-export interface Message {
-  key: string;
-  role: Role;
-  /** Absenderkennung für die Darstellung; unabhängig von Rolle und Sprechblasenlabel. */
-  sender?: string;
-  text: string;
-  textCursor?: ChatTextCursor;
-  closed?: boolean;
-  attachments?: ChatAttachment[];
-  tool?: ToolInfo;
-  question?: Question;
-  /** ISO-Zeitpunkt der Nachricht; Anzeige optional (ChatMessages showTimestamps). */
-  at?: string;
-  /** Farbige Sprechblase statt Fliesstext, z.B. fuer Mehrparteien-Gespraeche. */
-  bubble?: { color: string; side: "start" | "end"; label?: string };
-}
-
-export interface ChatStartupStatus {
-  status: "preparing" | "failed";
-  message: string;
-}
-
-export type ChatEvent =
-  | { kind: "reset"; reason?: "conversation-reset"; conversationId: string | null }
-  | { kind: "replay-end"; conversationId: string | null }
-  | { kind: "user"; text: string; at?: string; attachments?: ChatAttachment[] }
-  | { kind: "text"; delta: string; at?: string; cursor: ChatTextCursor }
-  | { kind: "thinking"; delta: string; at?: string }
-  | { kind: "tool"; id: string; name: string; arguments: string; label?: string; at?: string }
-  | { kind: "tool-result"; id: string; result: string; isError?: boolean }
-  | { kind: "question"; callId: string; text: string; options: string[]; multi?: boolean; at?: string }
-  | { kind: "question-answered"; callId: string; answer: string }
-  | { kind: "system"; text: string; at?: string }
-  | { kind: "status"; running: boolean; startup?: ChatStartupStatus }
-  | { kind: "turn-done" }
-  | { kind: "extension"; pluginId: string; type: string; payload?: unknown; at?: string; journal?: ChatJournalCursor };
-
-function openMessageIndex(messages: Message[]): number {
-  for (let index = messages.length - 1; index >= 0; index--) {
-    const message = messages[index];
-    if (!message.closed && (message.role === "assistant" || message.role === "thinking")) return index;
-  }
-  return -1;
-}
-
-function closeOpen(messages: Message[]): Message[] {
-  const index = openMessageIndex(messages);
-  if (index === -1) {
-    return messages;
-  }
-  return messages.map((message, position) => position === index ? { ...message, closed: true } : message);
-}
-
-function appendDelta(messages: Message[], role: Role, delta: string, at?: string, textCursor?: ChatTextCursor): Message[] {
-  const index = openMessageIndex(messages);
-  const current = messages[index];
-  if (current && current.role === role
-    && current.textCursor?.conversationId === textCursor?.conversationId
-    && current.textCursor?.sequence === textCursor?.sequence) {
-    return messages.map((message, position) => position === index
-      ? { ...message, text: message.text + delta, ...(textCursor ? { textCursor } : {}) }
-      : message);
-  }
-  return [...closeOpen(messages), { key: crypto.randomUUID(), role, text: delta, at, ...(textCursor ? { textCursor } : {}) }];
-}
-
-/** Eingehende Nachrichten lassen den laufenden Ausgabeblock offen. */
-export function applyEvent(messages: Message[], event: ChatEvent): Message[] {
-  switch (event.kind) {
-    case "reset":
-      return [];
-    case "user":
-      return [...messages, { key: crypto.randomUUID(), role: "user", text: event.text, closed: true, at: event.at,
-        ...(event.attachments?.length ? { attachments: event.attachments } : {}) }];
-    case "text":
-      return appendDelta(messages, "assistant", event.delta, event.at, event.cursor);
-    case "thinking":
-      return appendDelta(messages, "thinking", event.delta, event.at);
-    case "tool":
-      return [
-        ...closeOpen(messages),
-        {
-          key: crypto.randomUUID(),
-          role: "tool",
-          text: event.label ?? event.name,
-          closed: true,
-          tool: { id: event.id, name: event.name, arguments: event.arguments },
-          at: event.at,
-        },
-      ];
-    case "tool-result":
-      return messages.map((message) =>
-        message.tool?.id === event.id
-          ? { ...message, tool: { ...message.tool, result: event.result, isError: event.isError } }
-          : message,
-      );
-    case "question":
-      return [
-        ...closeOpen(messages),
-        {
-          key: crypto.randomUUID(),
-          role: "question",
-          text: event.text,
-          closed: true,
-          question: { callId: event.callId, options: event.options, multi: event.multi },
-          at: event.at,
-        },
-      ];
-    case "question-answered":
-      return messages.map((message) =>
-        message.question?.callId === event.callId
-          ? { ...message, question: { ...message.question, answer: event.answer } }
-          : message,
-      );
-    case "system":
-      return [...closeOpen(messages), { key: crypto.randomUUID(), role: "system", text: event.text, closed: true, at: event.at }];
-    case "turn-done":
-      return closeOpen(messages);
-    default:
-      return messages;
-  }
-}
-
-export function prettyJson(value: string): string {
-  try {
-    return JSON.stringify(JSON.parse(value), null, 2);
-  } catch {
-    return value;
-  }
-}
-
-export function compactToolLine(tool: ToolInfo): string {
-  const args = tool.arguments.replace(/\s+/g, " ").trim();
-  const line = args && args !== "{}" ? `${tool.name} ${args}` : tool.name;
-  return line.length > 160 ? `${line.slice(0, 160)} ...` : line;
-}

package/apps/server/src/plugin-support/asset-path.ts

@@ -1,4 +0,0 @@
-import { fileURLToPath } from "node:url";
-
-export const pluginAssetPath = (moduleUrl: string, relativePath: string): string =>
-  fileURLToPath(new URL(relativePath, moduleUrl));

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

@@ -1,19 +0,0 @@
-import "../host-resolution.js";
-import { statSync } from "node:fs";
-import path from "node:path";
-import { loadConfigFile } from "../config-file.js";
-import { webEntryOf } from "../plugin-support/plugins-root.js";
-import { resolvePluginEntries } from "./plugin-discovery.js";
-
-const hasFolder = (folder: string, name: string): boolean =>
-  statSync(path.join(folder, name), { throwIfNoEntry: false })?.isDirectory() === true;
-
-/** Prints the profile's plugins as JSON for build scripts: id, folder and whether a web half exists. */
-await loadConfigFile();
-const { config } = await import("../config.js");
-const plugins = resolvePluginEntries(config.plugins).map((plugin) => ({
-  ...plugin,
-  web: webEntryOf(plugin.folder),
-  clientUi: hasFolder(plugin.folder, "client-ui"),
-}));
-console.log(JSON.stringify(plugins));