@schlenkr/ragents 0.1.0

package/apps/server/src/plugin-support/system-prompts.ts

@@ -0,0 +1,138 @@
+import { readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { DeclaredEnvironment } from "./plugin-config.js";
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../..");
+
+export const SYSTEM_PROMPT_MODES = ["fixed", "selectable"] as const;
+
+export type SystemPromptMode = (typeof SYSTEM_PROMPT_MODES)[number];
+
+export interface SystemPromptOption {
+  readonly id: string;
+  readonly label: string;
+  readonly file: string;
+  readonly text: string;
+}
+
+export interface SystemPromptCatalog {
+  readonly mode: SystemPromptMode;
+  readonly options: readonly SystemPromptOption[];
+  readonly defaultIds: readonly string[];
+  readonly shareDefault: boolean;
+}
+
+export const systemPromptEnvDescriptors = [
+  { key: "SYSTEM_PROMPTS_DIR", source: "environment" },
+  { key: "SYSTEM_PROMPT_MODE", source: "environment" },
+  { key: "SYSTEM_PROMPT_DEFAULT", source: "environment" },
+  { key: "SYSTEM_PROMPT_SHARE_DEFAULT", source: "environment" },
+] as const;
+
+type SystemPromptEnvironment = DeclaredEnvironment<(typeof systemPromptEnvDescriptors)[number]["key"]>;
+
+const PROMPT_EXTENSIONS = [".md", ".hbs"];
+
+const flag = (value: string | undefined, key: string): boolean => {
+  if (value === undefined || value === "") return false;
+  if (value === "1") return true;
+  if (value === "0") return false;
+  throw new Error(`${key} muss "0" oder "1" sein, nicht "${value}"`);
+};
+
+const labelOf = (text: string, id: string): string => {
+  const heading = text.split("\n").find((line) => line.startsWith("# "));
+  return heading ? heading.slice(2).trim() : id;
+};
+
+export const systemPromptOptionsFromDirectory = (directory: string): readonly SystemPromptOption[] => {
+  let entries;
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch (error) {
+    throw new Error(
+      `Das Prompt-Verzeichnis ${directory} ist nicht lesbar (${error instanceof Error ? error.message : String(error)})`);
+  }
+  const files = entries
+    .filter((entry) => entry.isFile() && PROMPT_EXTENSIONS.includes(path.extname(entry.name)))
+    .map((entry) => entry.name)
+    .sort((left, right) => left.localeCompare(right, "de-DE"));
+  const options = files.map((name) => {
+    const file = path.join(directory, name);
+    const id = path.basename(name, path.extname(name));
+    const text = readFileSync(file, "utf8").trim();
+    return { id, label: labelOf(text, id), file, text };
+  });
+  const duplicate = options.find((option, index) => options.findIndex((other) => other.id === option.id) !== index);
+  if (duplicate) throw new Error(`Das Prompt-Verzeichnis ${directory} enthält die Kennung ${duplicate.id} mehrfach`);
+  if (options.length === 0) {
+    throw new Error(`Das Prompt-Verzeichnis ${directory} enthält keine ${PROMPT_EXTENSIONS.join("- oder ")}-Datei`);
+  }
+  return options;
+};
+
+export const lazySystemPromptCatalog = (
+  env: SystemPromptEnvironment,
+  folderOptions: () => readonly SystemPromptOption[],
+): (() => SystemPromptCatalog) => {
+  let catalog: SystemPromptCatalog | undefined;
+  return () => catalog ??= systemPromptCatalogFromEnvironment(env, folderOptions());
+};
+
+export const systemPromptCatalogFromEnvironment = (
+  env: SystemPromptEnvironment,
+  folderOptions: readonly SystemPromptOption[] = [],
+): SystemPromptCatalog => {
+  const directory = env.optional("SYSTEM_PROMPTS_DIR");
+  const mode = env.optional("SYSTEM_PROMPT_MODE") || undefined;
+  const defaultId = env.optional("SYSTEM_PROMPT_DEFAULT") || undefined;
+  const shareRaw = env.optional("SYSTEM_PROMPT_SHARE_DEFAULT") || undefined;
+  const options = [
+    ...folderOptions,
+    ...(directory ? systemPromptOptionsFromDirectory(path.resolve(rootDir, directory)) : []),
+  ];
+  const collision = options.find((option, index) => options.findIndex((other) => other.id === option.id) !== index);
+  if (collision) {
+    throw new Error(`Der Systemprompt ${collision.id} kommt aus dem Plugin-Ordner und aus SYSTEM_PROMPTS_DIR`);
+  }
+  if (options.length === 0) {
+    return Object.freeze({ mode: "fixed" as const, options: [], defaultIds: [], shareDefault: false });
+  }
+  if (mode !== undefined && !SYSTEM_PROMPT_MODES.includes(mode as SystemPromptMode)) {
+    throw new Error(`SYSTEM_PROMPT_MODE muss einer der Werte ${SYSTEM_PROMPT_MODES.join(", ")} sein, nicht "${mode}"`);
+  }
+  const effectiveMode = (mode ?? "selectable") as SystemPromptMode;
+  const wanted = (defaultId ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
+  if (effectiveMode === "fixed" && wanted.length === 0) {
+    throw new Error("SYSTEM_PROMPT_MODE ist fixed, SYSTEM_PROMPT_DEFAULT benennt dann die gültigen Prompts");
+  }
+  for (const id of wanted) {
+    if (!options.some((option) => option.id === id)) {
+      throw new Error(
+        `SYSTEM_PROMPT_DEFAULT ${id} ist kein auswählbarer Systemprompt; `
+        + `vorhanden sind ${options.map((option) => option.id).join(", ")}`);
+    }
+  }
+  const duplicate = wanted.find((id, index) => wanted.indexOf(id) !== index);
+  if (duplicate) throw new Error(`SYSTEM_PROMPT_DEFAULT nennt ${duplicate} mehrfach`);
+  return Object.freeze({
+    mode: effectiveMode,
+    options,
+    defaultIds: Object.freeze(wanted.length > 0 ? wanted : [options[0].id]),
+    shareDefault: flag(shareRaw, "SYSTEM_PROMPT_SHARE_DEFAULT"),
+  });
+};
+
+export const selectedSystemPrompts = (
+  catalog: SystemPromptCatalog,
+  selection: readonly string[] | undefined,
+): readonly SystemPromptOption[] => {
+  if (catalog.options.length === 0) return [];
+  const wanted = catalog.mode === "fixed" ? catalog.defaultIds : selection ?? catalog.defaultIds;
+  return wanted.map((id) => {
+    const option = catalog.options.find((entry) => entry.id === id);
+    if (!option) throw new Error(`Der Systemprompt ${id} ist nicht mehr konfiguriert`);
+    return option;
+  });
+};

package/apps/server/src/plugin-support/thinking-level.ts

@@ -0,0 +1,8 @@
+import { isThinkingLevel, thinkingLevels, type ThinkingLevel } from "@aicontainer/ragents";
+
+export const checkedThinkingLevel = (value: string, label: string): ThinkingLevel => {
+  if (!isThinkingLevel(value)) {
+    throw new Error(`${label} hat die unbekannte Denktiefe "${value}"; erlaubt sind ${thinkingLevels.join(", ")}.`);
+  }
+  return value;
+};

package/apps/server/src/plugin-support/tool-availability.ts

@@ -0,0 +1,20 @@
+import {
+  defineToolAvailability,
+  holdsUsable,
+  type ToolAvailability,
+} from "@aicontainer/ragents";
+
+export const alwaysAvailable = defineToolAvailability({
+  availability: "always",
+  availabilityDetail: "In jedem Modell-Turn verfügbar.",
+}, () => true);
+
+export const canUseWorkspace = defineToolAvailability({
+  availability: "conditional",
+  availabilityDetail: "Nur mit der Capability workspace.use.",
+}, (actor) => holdsUsable(actor, "workspace.use"));
+
+export const facesOperator: ToolAvailability = defineToolAvailability({
+  availability: "always",
+  availabilityDetail: "In jedem Turn verfügbar; die Frage geht immer an den Benutzer des Runs.",
+}, () => true);

package/apps/server/src/plugin-support/workspace-ownership.ts

@@ -0,0 +1,36 @@
+import { chmod, chown, lstat, readdir, realpath } from "node:fs/promises";
+import path from "node:path";
+import { containsWorkspacePath } from "@aicontainer/workspace-executor";
+
+export interface WorkspaceIdentity {
+  uid?: number;
+  gid?: number;
+  storageRoot?: string;
+}
+
+export const syncWorkspaceOwnership = async (directory: string, identity: WorkspaceIdentity): Promise<void> => {
+  if (identity.uid === undefined && identity.gid === undefined) return;
+  if (identity.uid === undefined || identity.gid === undefined || !identity.storageRoot) {
+    throw new Error("Für private Arbeitsdateien fehlen UID, GID oder die Run-Speichergrenze.");
+  }
+  if ((await lstat(directory)).isSymbolicLink()) throw new Error("Das private Arbeitsverzeichnis darf kein Symlink sein.");
+  const [root, target] = await Promise.all([realpath(identity.storageRoot), realpath(directory)]);
+  if (!containsWorkspacePath(root, target) || target === root) throw new Error("Das private Arbeitsverzeichnis liegt außerhalb seiner Run-Speichergrenze.");
+  const { uid, gid } = identity;
+  const visit = async (file: string): Promise<void> => {
+    const info = await lstat(file);
+    if (info.isSymbolicLink() || !info.isDirectory() && !info.isFile()) return;
+    if (info.uid !== uid || info.gid !== gid) await chown(file, uid, gid);
+    const mode = info.isDirectory() ? 0o700 : (info.mode & 0o100) | 0o600;
+    if ((info.mode & 0o7777) !== mode) await chmod(file, mode);
+    if (info.isDirectory()) for (const entry of await readdir(file)) await visit(path.join(file, entry));
+  };
+  await visit(target);
+  for (let ancestor = path.dirname(target); containsWorkspacePath(root, ancestor); ancestor = path.dirname(ancestor)) {
+    const info = await lstat(ancestor);
+    if (!info.isDirectory()) throw new Error("Ein Vorfahr des Arbeitsverzeichnisses ist kein Verzeichnis.");
+    const mode = (info.mode & 0o7777) | 0o111;
+    if ((info.mode & 0o7777) !== mode) await chmod(ancestor, mode);
+    if (ancestor === root) break;
+  }
+};

package/apps/server/src/plugin-support/workspace-sandbox-host.ts

@@ -0,0 +1,213 @@
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+import {
+  serviceToken,
+  type RunFunction,
+  type PluginContext,
+  type ToolContributor,
+} from "@aicontainer/ragents";
+import {
+  createBashToolDefinition,
+  createEditToolDefinition,
+  createReadToolDefinition,
+  createWriteToolDefinition,
+} from "@aicontainer/agent";
+import {
+  SandboxWorkspaceExecutor,
+  resolvedWorkspacePath,
+  sandboxRunEnvironment,
+  workspaceLanguageServers,
+  workspaceProcessContext,
+  type ResolvedWorkspaceRoot,
+  type SandboxHomeEnvironment,
+  type SessionIdent,
+  type WorkspaceExecuteOptions,
+  type WorkspaceExecutor,
+  type WorkspaceProcessContext,
+} from "@aicontainer/workspace-executor";
+import type { SessionWorkspace } from "../ragents/workspace-runtime.js";
+import { agentToolFrom, toolDescriptorFrom, type AgentToolDefinition } from "./agent-tool.js";
+import { alwaysAvailable } from "./tool-availability.js";
+import { syncWorkspaceOwnership } from "./workspace-ownership.js";
+
+export interface RegisteredWorkspaceRoot {
+  id: string;
+  alias?: string;
+  environmentVariable?: string;
+  directoryFor: (runId: string) => string | undefined | Promise<string | undefined>;
+  ownershipDirectoryFor?: (runId: string) => string | Promise<string>;
+}
+
+export interface SandboxServices {
+  processContextFor: (runId: string) => Promise<WorkspaceProcessContext>;
+  registerWorkspaceRoot: (root: RegisteredWorkspaceRoot) => void;
+  execute: (runId: string, tool: string, input: unknown, options?: WorkspaceExecuteOptions) => Promise<unknown>;
+  shutdown: (runId: string) => Promise<void>;
+}
+
+export const sandboxServicesToken = serviceToken<SandboxServices>("ragents.workspace.sandbox-services");
+
+export interface WorkspaceSandboxHostOptions {
+  contributorName: string;
+  workspaceFor: (runId: string) => Promise<SessionWorkspace>;
+  identFor: (runId: string) => Promise<SessionIdent | undefined>;
+  skillPaths: () => Promise<readonly string[]>;
+  homeFor: (runId: string) => Promise<SandboxHomeEnvironment>;
+  storageRootFor?: (runId: string) => string;
+  /** Der Executor des Runs; ohne Antwort führt der Executor des Servers aus. */
+  executorFor?: (runId: string) => Promise<WorkspaceExecutor | undefined>;
+}
+
+const sandboxDescriptions: Readonly<Record<string, string>> = {
+  read: "Read file contents or images within the run's allowed workspace roots.",
+  edit: "Apply exact text replacements to existing files within the run's writable workspace roots.",
+  write: "Create or overwrite files within the run's writable workspace roots.",
+  bash: "Execute shell commands in the run's workspace with sandbox restrictions.",
+};
+
+const describeSandboxTool = (definition: AgentToolDefinition): AgentToolDefinition => {
+  const description = sandboxDescriptions[definition.name];
+  if (!description) throw new Error(`Das Sandbox-Werkzeug ${definition.name} hat keine Kurzbeschreibung`);
+  return { ...definition, description, longDescription: definition.description, nativeTool: true };
+};
+
+const sandboxDescriptorDefinitions = [
+  createReadToolDefinition("."),
+  createEditToolDefinition("."),
+  createWriteToolDefinition("."),
+  createBashToolDefinition("."),
+] as readonly AgentToolDefinition[];
+
+const sandboxDescriptors = sandboxDescriptorDefinitions.map((definition) =>
+  toolDescriptorFrom(describeSandboxTool(definition), alwaysAvailable));
+
+interface StableRunParts {
+  ident?: SessionIdent;
+  home: SandboxHomeEnvironment;
+  readOnlyRoots: readonly ResolvedWorkspaceRoot[];
+}
+
+/** Der Executor des Servers, seine Wurzeln und die Weiterreichung der Arbeitsplatz-Werkzeuge an den Executor des Runs. */
+export class WorkspaceSandboxHost implements SandboxServices {
+  readonly #options: WorkspaceSandboxHostOptions;
+  readonly #workspaceRoots: RegisteredWorkspaceRoot[] = [];
+  readonly #local: SandboxWorkspaceExecutor;
+  readonly #stable = new Map<string, Promise<StableRunParts>>();
+
+  constructor(options: WorkspaceSandboxHostOptions) {
+    this.#options = options;
+    this.#local = new SandboxWorkspaceExecutor({
+      contextFor: (runId) => this.processContextFor(runId),
+      languageServers: workspaceLanguageServers,
+    });
+  }
+
+  registerWorkspaceRoot(root: RegisteredWorkspaceRoot): void {
+    if (!root.id.trim() || this.#workspaceRoots.some((entry) => entry.id === root.id)) {
+      throw new Error(`Arbeitsverzeichnis ${root.id} ist leer oder bereits registriert`);
+    }
+    if (root.alias && (!/^@[a-z][a-z0-9-]*$/.test(root.alias) || this.#workspaceRoots.some((entry) => entry.alias === root.alias))) {
+      throw new Error(`Arbeitsverzeichnis-Alias ${root.alias} ist ungültig oder bereits registriert`);
+    }
+    if (root.environmentVariable && (!/^RAGENTS_[A-Z_]+_DIR$/.test(root.environmentVariable) || this.#workspaceRoots.some((entry) => entry.environmentVariable === root.environmentVariable))) {
+      throw new Error(`Arbeitsverzeichnis-Variable ${root.environmentVariable} ist ungültig oder bereits registriert`);
+    }
+    this.#workspaceRoots.push(root);
+  }
+
+  async #additionalRoots(runId: string, ident?: SessionIdent): Promise<ResolvedWorkspaceRoot[]> {
+    const roots = await Promise.all(this.#workspaceRoots.map(async (entry) => {
+      const directory = await entry.directoryFor(runId);
+      if (directory === undefined) return undefined;
+      if (!path.isAbsolute(directory)) throw new Error(`Arbeitsverzeichnis ${entry.id} muss absolut sein`);
+      if (ident) await syncWorkspaceOwnership(await entry.ownershipDirectoryFor?.(runId) ?? directory, {
+        ...ident, storageRoot: this.#options.storageRootFor?.(runId),
+      });
+      return { directory: await resolvedWorkspacePath(directory), alias: entry.alias, environmentVariable: entry.environmentVariable };
+    }));
+    return roots.filter((root) => root !== undefined);
+  }
+
+  async processContextFor(runId: string): Promise<WorkspaceProcessContext> {
+    const workspace = await this.#options.workspaceFor(runId);
+    const { ident, home, readOnlyRoots } = await this.#stableParts(runId, workspace);
+    return workspaceProcessContext({
+      runId,
+      cwd: workspace.cwd,
+      root: await workspace.currentRoot(),
+      home,
+      logDirectory: home.home,
+      ...(ident ? { ident } : {}),
+      additionalRoots: await this.#additionalRoots(runId, ident),
+      readOnlyRoots,
+      additions: sandboxRunEnvironment(runId, workspace),
+      runOperation: workspace.runOperation,
+    });
+  }
+
+  /** Kennung, Heimatordner und nur lesbare Wurzeln stehen je Run fest; nur sie werden gemerkt. */
+  #stableParts(runId: string, workspace: SessionWorkspace): Promise<StableRunParts> {
+    const known = this.#stable.get(runId);
+    if (known) return known;
+    const created = this.#resolveStableParts(runId, workspace).catch((error: unknown) => {
+      this.#stable.delete(runId);
+      throw error;
+    });
+    this.#stable.set(runId, created);
+    return created;
+  }
+
+  async #resolveStableParts(runId: string, workspace: SessionWorkspace): Promise<StableRunParts> {
+    if (workspace.hostSandbox) {
+      const readOnlyRoots = await Promise.all(workspace.hostSandbox.readOnlyRoots.map(async (root) =>
+        ({ ...root, directory: await realpath(root.directory) })));
+      return { home: { home: workspace.hostSandbox.home }, readOnlyRoots };
+    }
+    const [ident, home, skills] = await Promise.all([
+      this.#options.identFor(runId),
+      this.#options.homeFor(runId),
+      this.#options.skillPaths(),
+    ]);
+    const resolved = await Promise.all(skills.map((directory) => realpath(directory).then((real) => ({ directory: real }), () => undefined)));
+    return { ...(ident ? { ident } : {}), home, readOnlyRoots: resolved.filter((root) => root !== undefined) };
+  }
+
+  workspaceTools(): ToolContributor {
+    return {
+      name: this.#options.contributorName,
+      descriptors: sandboxDescriptors,
+      tools: (context) => this.#workspaceToolsFor(context),
+    };
+  }
+
+  execute(runId: string, tool: string, input: unknown, options: WorkspaceExecuteOptions = {}): Promise<unknown> {
+    return this.#executorFor(runId).then((executor) => executor.execute(runId, tool, input, options));
+  }
+
+  /** Ein Run mit Bindung `client` legt im Server nie eine Sandbox an; sein Executor allein hält, was zu beenden ist. */
+  async shutdown(runId: string): Promise<void> {
+    this.#stable.delete(runId);
+    await (await this.#executorFor(runId)).stopRun(runId);
+  }
+
+  shutdownAll(): Promise<void> {
+    this.#stable.clear();
+    return this.#local.shutdown();
+  }
+
+  async #executorFor(runId: string): Promise<WorkspaceExecutor> {
+    return await this.#options.executorFor?.(runId) ?? this.#local;
+  }
+
+  #workspaceToolsFor(context: PluginContext): Promise<RunFunction[]> {
+    return Promise.resolve(sandboxDescriptorDefinitions.map((definition) => {
+      const described = describeSandboxTool(definition);
+      const proxy = {
+        ...described,
+        execute: (toolCallId: string, params: unknown, signal: AbortSignal | undefined) =>
+          this.execute(context.runId, described.name, params, { toolCallId, ...(signal ? { signal } : {}) }),
+      } as AgentToolDefinition;
+      return agentToolFrom(proxy, alwaysAvailable, described.name === "bash" ? "sequential" : "parallel");
+    }));
+  }
+}

package/apps/server/src/plugin-support/workspace-tool-naming.ts

@@ -0,0 +1,11 @@
+import type { WorkspaceToolNaming } from "@aicontainer/ragents";
+
+const workspaceToolTable = {
+  manual: { read: [], write: [], execute: [] },
+  script: { read: [], write: [], execute: [] },
+  agent: { read: ["read"], write: ["edit", "write"], execute: ["bash"] },
+} as const;
+
+export const sandboxToolNaming: WorkspaceToolNaming = {
+  agentToolNames: (driver) => workspaceToolTable[driver],
+};

package/apps/server/src/plugin-support/zip.ts

@@ -0,0 +1,69 @@
+import { inflateRawSync } from "node:zlib";
+
+const END_OF_CENTRAL_DIRECTORY = 0x06054b50;
+const CENTRAL_FILE_HEADER = 0x02014b50;
+const LOCAL_FILE_HEADER = 0x04034b50;
+const MAX_COMMENT = 0xffff;
+
+export interface ZipEntry {
+  readonly name: string;
+  readonly content: Buffer;
+}
+
+const endOffset = (archive: Buffer): number => {
+  const first = Math.max(0, archive.byteLength - MAX_COMMENT - 22);
+  for (let offset = archive.byteLength - 22; offset >= first; offset -= 1) {
+    if (archive.readUInt32LE(offset) === END_OF_CENTRAL_DIRECTORY) return offset;
+  }
+  throw new Error("Das Archiv hat kein Ende des Zentralverzeichnisses; es ist keine ZIP-Datei");
+};
+
+const contentOf = (archive: Buffer, localOffset: number, compression: number, compressedSize: number): Buffer => {
+  if (archive.readUInt32LE(localOffset) !== LOCAL_FILE_HEADER) throw new Error(`Der lokale Eintrag bei ${localOffset} fehlt im Archiv`);
+  const start = localOffset + 30 + archive.readUInt16LE(localOffset + 26) + archive.readUInt16LE(localOffset + 28);
+  const raw = archive.subarray(start, start + compressedSize);
+  if (compression === 0) return Buffer.from(raw);
+  if (compression === 8) return inflateRawSync(raw);
+  throw new Error(`Das Archiv verwendet die unbekannte Kompression ${compression}`);
+};
+
+interface DirectoryEntry {
+  readonly name: string;
+  readonly compression: number;
+  readonly compressedSize: number;
+  readonly localOffset: number;
+}
+
+/** Liest das Zentralverzeichnis; Zip64 und Verschlüsselung sind harte Fehler. */
+const readDirectory = (archive: Buffer): readonly DirectoryEntry[] => {
+  const end = endOffset(archive);
+  const count = archive.readUInt16LE(end + 10);
+  const directory = archive.readUInt32LE(end + 16);
+  if (count === 0xffff || directory === 0xffffffff) throw new Error("Das Archiv ist Zip64; diese Form wird nicht gelesen");
+  const entries: DirectoryEntry[] = [];
+  let offset = directory;
+  for (let index = 0; index < count; index += 1) {
+    if (archive.readUInt32LE(offset) !== CENTRAL_FILE_HEADER) throw new Error(`Der Verzeichniseintrag ${index} fehlt im Archiv`);
+    const flags = archive.readUInt16LE(offset + 8);
+    const nameLength = archive.readUInt16LE(offset + 28);
+    const name = archive.subarray(offset + 46, offset + 46 + nameLength).toString("utf8");
+    if ((flags & 0x1) !== 0) throw new Error(`Der Archiveintrag ${name} ist verschlüsselt`);
+    if (!name.endsWith("/")) {
+      entries.push({
+        name,
+        compression: archive.readUInt16LE(offset + 10),
+        compressedSize: archive.readUInt32LE(offset + 20),
+        localOffset: archive.readUInt32LE(offset + 42),
+      });
+    }
+    offset += 46 + nameLength + archive.readUInt16LE(offset + 30) + archive.readUInt16LE(offset + 32);
+  }
+  return entries;
+};
+
+export const readZipNames = (archive: Buffer): readonly string[] => readDirectory(archive).map((entry) => entry.name);
+
+export const readZipEntries = (archive: Buffer, keep: (name: string) => boolean): readonly ZipEntry[] =>
+  readDirectory(archive)
+    .filter((entry) => keep(entry.name))
+    .map((entry) => ({ name: entry.name, content: contentOf(archive, entry.localOffset, entry.compression, entry.compressedSize) }));

package/apps/server/src/profile/compose.ts

@@ -0,0 +1,69 @@
+import { PluginHost } from "@aicontainer/ragents";
+import { config, HOST_SECRET_ENV_NAMES } from "../config.js";
+import { SESSION_MODE, SESSIONS_MODE } from "../layout.js";
+import { withFolderAssets } from "../plugin-support/plugin-folder.js";
+import { pluginFolder, webEntryOf } from "../plugin-support/plugins-root.js";
+import type { PluginModule } from "../plugin-support/plugin-module.js";
+import { sessionManagementToken } from "../ragents/global-chat.js";
+import { registerTypeScriptFunctions } from "../ragents/typescript-tools.js";
+import {
+  runtimeProviderToken,
+  secretEnvNamesToken,
+  sessionGuardToken,
+  sessionWorkspaceProviderToken,
+  type HostBridges,
+} from "../ragents/host-services.js";
+
+export interface ProductDescriptor {
+  readonly id: string;
+  readonly title: string;
+  readonly accessCookieName?: string;
+}
+
+export interface ProfileComposition {
+  readonly product: ProductDescriptor;
+  readonly pluginIds: readonly string[];
+  readonly modules: ReadonlyMap<string, PluginModule>;
+}
+
+export const composeProfile = (options: ProfileComposition, bridges: HostBridges): PluginHost => {
+  const host = new PluginHost({
+    product: options.product,
+    dataDirectory: config.dataDir,
+    storageModes: { sessionsRoot: SESSIONS_MODE, session: SESSION_MODE },
+  });
+  host.provideHost(sessionGuardToken, bridges.ensureSession);
+  host.provideHost(sessionWorkspaceProviderToken, bridges.sessionWorkspaceFor);
+  host.provideHost(runtimeProviderToken, bridges.runtime);
+  host.provideHost(sessionManagementToken, () => {
+    if (!bridges.sessions) throw new Error("Der Host stellt keine Sitzungsverwaltung bereit");
+    return bridges.sessions();
+  });
+  host.provideHost(secretEnvNamesToken, () =>
+    [...new Set([...HOST_SECRET_ENV_NAMES, ...host.config.secretKeys()])]);
+  for (const id of options.pluginIds) {
+    const module = options.modules.get(id);
+    if (!module) throw new Error(`Das Plugin ${id} wurde nicht geladen`);
+    const plugin = module.create(host);
+    if (plugin.manifest.id !== id) {
+      throw new Error(`Der Plugin-Ordner ${id} meldet die abweichende Kennung ${plugin.manifest.id}`);
+    }
+    if (plugin.manifest.requires !== undefined) {
+      throw new Error(`Plugin ${id} deklariert requires im Manifest; es gehört in den Modulvertrag`);
+    }
+    if (plugin.manifest.web !== undefined) {
+      throw new Error(`Plugin ${id} deklariert web im Manifest; das ergibt sich aus dem Plugin-Ordner`);
+    }
+    host.register(withFolderAssets({
+      ...plugin,
+      manifest: {
+        ...plugin.manifest,
+        web: webEntryOf(pluginFolder(id)) !== undefined,
+        ...(module.requires ? { requires: module.requires } : {}),
+      },
+    }));
+  }
+  registerTypeScriptFunctions(host);
+  host.seal();
+  return host;
+};