@schlenkr/ragents 0.1.0

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

@@ -0,0 +1,112 @@
+import { readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { isPluginModule, type PluginModule } from "../plugin-support/plugin-module.js";
+import {
+  isPluginPath,
+  PLUGIN_SERVER_FOLDER,
+  pluginFolderFor,
+  pluginIdOf,
+  pluginsRoot,
+  registerPluginFolder,
+} from "../plugin-support/plugins-root.js";
+
+const ENTRY_FILES = ["index.ts", "index.js"] as const;
+
+const entryFile = (folder: string): string | undefined =>
+  ENTRY_FILES
+    .map((name) => path.join(folder, PLUGIN_SERVER_FOLDER, name))
+    .find((candidate) => statSync(candidate, { throwIfNoEntry: false })?.isFile() === true);
+
+const assertEntryFile = (folder: string): string => {
+  const entry = entryFile(folder);
+  if (entry) return entry;
+  throw new Error(
+    `Der Plugin-Ordner ${folder} hat keinen Einstiegspunkt; erwartet wird `
+    + `${ENTRY_FILES.map((name) => `${PLUGIN_SERVER_FOLDER}/${name}`).join(" oder ")} `
+    + "mit \"export const plugin: PluginModule\"");
+};
+
+export const discoverPluginIds = (root = pluginsRoot): readonly string[] => {
+  const folders = readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort();
+  for (const id of folders) assertEntryFile(path.join(root, id));
+  return folders;
+};
+
+export interface ResolvedPlugin {
+  readonly id: string;
+  readonly folder: string;
+}
+
+/** Resolves the profile's entries to folders; ids come from plugins/, paths from anywhere on disk. */
+export const resolvePluginEntries = (
+  entries: readonly string[],
+  base = process.cwd(),
+  root = pluginsRoot,
+): readonly ResolvedPlugin[] => {
+  const known = discoverPluginIds(root);
+  const resolved = entries.map((entry) => {
+    if (!isPluginPath(entry) && !known.includes(entry)) {
+      throw new Error(`Unbekanntes Plugin ${entry}; gefunden wurden: ${known.join(", ")}`);
+    }
+    const folder = pluginFolderFor(entry, base, root);
+    if (!statSync(folder, { throwIfNoEntry: false })?.isDirectory()) {
+      throw new Error(`Das Plugin ${entry} hat keinen Ordner ${folder}`);
+    }
+    assertEntryFile(folder);
+    return { id: pluginIdOf(folder), folder };
+  });
+  const duplicate = resolved.find((plugin, index) => resolved.findIndex((other) => other.id === plugin.id) !== index);
+  if (duplicate) throw new Error(`Plugin ${duplicate.id} steht mehrfach in der Pluginliste`);
+  return resolved;
+};
+
+const loadPluginModule = async (folder: string): Promise<PluginModule> => {
+  const entry = assertEntryFile(folder);
+  const loaded = await import(pathToFileURL(entry).href) as Record<string, unknown>;
+  const module = loaded.plugin;
+  if (!isPluginModule(module)) {
+    throw new Error(
+      `${entry} exportiert keinen gültigen Einstiegspunkt; erwartet wird `
+      + "\"export const plugin: PluginModule\" mit einer create-Funktion");
+  }
+  return module;
+};
+
+const assertRequires = (ids: readonly string[], modules: ReadonlyMap<string, PluginModule>): void => {
+  const positions = new Map(ids.map((id, index) => [id, index]));
+  for (const [index, id] of ids.entries()) {
+    for (const dependency of modules.get(id)?.requires ?? []) {
+      const position = positions.get(dependency);
+      if (position === undefined) throw new Error(`Plugin ${id} benötigt das fehlende Plugin ${dependency}`);
+      if (position >= index) throw new Error(`Plugin ${dependency} muss vor ${id} registriert werden`);
+    }
+  }
+};
+
+export interface LoadedPlugins {
+  readonly known: readonly string[];
+  readonly ids: readonly string[];
+  readonly modules: ReadonlyMap<string, PluginModule>;
+}
+
+export const loadPlugins = async (
+  entries: readonly string[],
+  root = pluginsRoot,
+  base = process.cwd(),
+): Promise<LoadedPlugins> => {
+  const plugins = resolvePluginEntries(entries, base, root);
+  const discovered = discoverPluginIds(root);
+  const known = [...discovered, ...plugins.map((plugin) => plugin.id).filter((id) => !discovered.includes(id))];
+  const modules = new Map<string, PluginModule>();
+  for (const plugin of plugins) {
+    registerPluginFolder(plugin.id, plugin.folder);
+    modules.set(plugin.id, await loadPluginModule(plugin.folder));
+  }
+  const ids = plugins.map((plugin) => plugin.id);
+  assertRequires(ids, modules);
+  return { known, ids, modules };
+};

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

@@ -0,0 +1,19 @@
+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));

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

@@ -0,0 +1,81 @@
+import { statSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { hostDataDirectory, pluginToolsDirectory } from "@aicontainer/workspace-executor/src/tools.ts";
+import { isPluginProvision, type PluginProvision } from "../plugin-support/provision.js";
+import { resolvePluginEntries, type ResolvedPlugin } from "./plugin-discovery.js";
+
+/** Die Sprachserver, die jeder Arbeitsplatz-Executor anbietet und deren Werkzeuge auf seiner Maschine liegen. */
+export const WORKSPACE_PROVISION_PLUGINS = ["ragents.lsp-roslyn", "ragents.lsp-fsharp"] as const;
+
+const ENTRY_FILES = ["provision.ts", "provision.js"] as const;
+
+export const provisionEntry = (folder: string): string | undefined =>
+  ENTRY_FILES
+    .map((name) => path.join(folder, name))
+    .find((candidate) => statSync(candidate, { throwIfNoEntry: false })?.isFile() === true);
+
+export const loadProvision = async (entry: string): Promise<PluginProvision> => {
+  const loaded = await import(pathToFileURL(entry).href) as Record<string, unknown>;
+  if (!isPluginProvision(loaded.provision)) {
+    throw new Error(`${entry} exportiert keine Provisionierung; erwartet wird "export const provision: PluginProvision" mit check und apply`);
+  }
+  return loaded.provision;
+};
+
+export type ProvisionOutcome = "ready" | "installed" | "missing";
+
+export interface PluginProvisionReport {
+  readonly id: string;
+  readonly target: string;
+  readonly outcome: ProvisionOutcome;
+  readonly reason?: string;
+}
+
+export const provisionReportLine = (report: PluginProvisionReport): string =>
+  `${report.id}: ${report.outcome === "ready" ? "bereit" : report.outcome === "installed" ? "installiert" : `fehlt: ${report.reason ?? "ohne Grund"}`}`;
+
+const reason = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
+
+const provisionPlugin = async (
+  plugin: ResolvedPlugin,
+  entry: string,
+  dataDirectory: string,
+  log: (line: string) => void,
+): Promise<PluginProvisionReport> => {
+  const target = pluginToolsDirectory(dataDirectory, plugin.id);
+  try {
+    const provision = await loadProvision(entry);
+    const state = await provision.check(target);
+    if (state.kind === "ready") return { id: plugin.id, target, outcome: "ready" };
+    if (!state.installable) return { id: plugin.id, target, outcome: "missing", reason: state.instruction };
+    await mkdir(target, { recursive: true });
+    await provision.apply(target, (line) => log(`   ${line}`));
+    const after = await provision.check(target);
+    if (after.kind === "ready") return { id: plugin.id, target, outcome: "installed" };
+    return { id: plugin.id, target, outcome: "missing", reason: after.instruction };
+  } catch (cause) {
+    return { id: plugin.id, target, outcome: "missing", reason: reason(cause) };
+  }
+};
+
+/** Provisioniert jedes Plugin, das eine provision.ts mitbringt, in seinen Werkzeugordner unterhalb des Datenordners. */
+export const provisionPlugins = async (
+  plugins: readonly ResolvedPlugin[],
+  dataDirectory: string,
+  log: (line: string) => void,
+): Promise<readonly PluginProvisionReport[]> => {
+  const reports: PluginProvisionReport[] = [];
+  for (const plugin of plugins) {
+    const entry = provisionEntry(plugin.folder);
+    if (!entry) continue;
+    const report = await provisionPlugin(plugin, entry, dataDirectory, log);
+    log(provisionReportLine(report));
+    reports.push(report);
+  }
+  return reports;
+};
+
+export const provisionWorkspace = (log: (line: string) => void): Promise<readonly PluginProvisionReport[]> =>
+  provisionPlugins(resolvePluginEntries([...WORKSPACE_PROVISION_PLUGINS]), hostDataDirectory(), log);

package/apps/server/src/protocol.ts

@@ -0,0 +1,106 @@
+import { appendFileSync, createWriteStream, mkdirSync, renameSync, statSync, type WriteStream } from "node:fs";
+import path from "node:path";
+import { layout } from "./layout.js";
+
+const MAX_BYTES = 32 * 1024 * 1024;
+const KEPT_GENERATIONS = 3;
+
+export class Protocol {
+  private stream: WriteStream | undefined;
+  private written = 0;
+
+  constructor(private readonly file: string, private readonly dirMode = 0o750) {}
+
+  static forServer(): Protocol {
+    return new Protocol(layout.serverLog);
+  }
+
+  static fatal(text: string): void {
+    const file = layout.serverLog;
+    try {
+      mkdirSync(path.dirname(file), { recursive: true, mode: 0o750 });
+      appendFileSync(file, `${new Date().toISOString()} [fatal] ${text}\n`, { mode: 0o640 });
+    } catch {
+    }
+    process.stderr.write(`${text}\n`);
+  }
+
+  write(text: string): void {
+    const stamp = new Date().toISOString();
+    const block = text
+      .split("\n")
+      .map((line) => `${stamp} ${line.replaceAll("\r", "")}`)
+      .join("\n");
+    this.target().write(`${block}\n`);
+    this.written += Buffer.byteLength(block) + 1;
+    if (this.written >= MAX_BYTES) this.rotate();
+  }
+
+  async close(): Promise<void> {
+    const stream = this.stream;
+    this.stream = undefined;
+    if (!stream || stream.closed) return;
+    await new Promise<void>((resolve, reject) => {
+      const finished = (): void => {
+        stream.off("error", failed);
+        resolve();
+      };
+      const failed = (error: Error): void => {
+        stream.off("close", finished);
+        reject(error);
+      };
+      stream.once("close", finished);
+      stream.once("error", failed);
+      stream.end();
+    });
+  }
+
+  private target(): WriteStream {
+    if (this.stream) return this.stream;
+    mkdirSync(path.dirname(this.file), { recursive: true, mode: this.dirMode });
+    this.written = statSync(this.file, { throwIfNoEntry: false })?.size ?? 0;
+    this.stream = createWriteStream(this.file, { flags: "a", mode: 0o640 });
+    this.stream.on("error", (error) => {
+      process.stderr.write(`Protokoll ${this.file} nicht schreibbar: ${error.message}\n`);
+      this.stream = undefined;
+    });
+    return this.stream;
+  }
+
+  private rotate(): void {
+    const stream = this.stream;
+    this.stream = undefined;
+    this.written = 0;
+    stream?.end();
+    try {
+      for (let generation = KEPT_GENERATIONS - 1; generation >= 1; generation--) {
+        const from = generation === 1 ? this.file : `${this.file}.${generation - 1}`;
+        if (statSync(from, { throwIfNoEntry: false })) renameSync(from, `${this.file}.${generation}`);
+      }
+    } catch (error) {
+      process.stderr.write(`Protokoll ${this.file} nicht rotierbar: ${(error as Error).message}\n`);
+    }
+  }
+}
+
+export const teeConsole = (protocol: Protocol): void => {
+  const forward = (level: string, original: (...args: unknown[]) => void) =>
+    (...args: unknown[]) => {
+      original(...args);
+      protocol.write(`[${level}] ${args.map((arg) => textOf(arg)).join(" ")}`);
+    };
+  console.log = forward("log", console.log.bind(console));
+  console.info = forward("info", console.info.bind(console));
+  console.warn = forward("warn", console.warn.bind(console));
+  console.error = forward("error", console.error.bind(console));
+};
+
+const textOf = (value: unknown): string => {
+  if (typeof value === "string") return value;
+  if (value instanceof Error) return `${value.message}\n${value.stack ?? ""}`;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};