@schlenkr/ragents 0.1.5 → 0.1.6

package/apps/server/src/plugin-build/host-api-names.ts

@@ -0,0 +1,185 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import vm from "node:vm";
+import { build } from "esbuild";
+import ts from "typescript";
+import { HOST_API_VERSION, LIBRARY, hostApi, hostApiModules, type HostApiHalf } from "../host-api.js";
+import { HOST_API_RECORD_FILE, hostRoot, type HostApiRecord } from "../host-version.js";
+
+export { readHostApiRecord, type HostApiRecord } from "../host-version.js";
+
+export const hostApiRecordFile = (root = hostRoot()): string => path.join(root, HOST_API_RECORD_FILE);
+
+/** Where the host itself resolves a module of each half: its tsconfig and an importer inside the host. */
+export const HALF_PLACES: Readonly<Record<HostApiHalf, { readonly app: string; readonly config: string; readonly importer: string }>> = {
+  server: { app: "apps/server", config: "apps/server/tsconfig.json", importer: "apps/server/src/main.ts" },
+  web: { app: "apps/web", config: "apps/web/tsconfig.json", importer: "apps/web/src/main.tsx" },
+};
+
+const parsedConfig = (file: string): ts.ParsedCommandLine => {
+  const parsed = ts.getParsedCommandLineOfConfigFile(file, {}, {
+    ...ts.sys,
+    onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+      throw new Error(ts.flattenDiagnosticMessageText(diagnostic.messageText, " "));
+    },
+  });
+  if (!parsed) throw new Error(`${file} ist keine gültige tsconfig`);
+  return parsed;
+};
+
+interface TypeView {
+  readonly names: readonly string[];
+  /** Resolved through node_modules, so the implementation may be JavaScript whose types promise more than it has. */
+  readonly library: boolean;
+}
+
+/** Value exports as TypeScript sees them; a module with export= also has a default import, a host declaration file has no values at all. */
+export const typeViews = (half: HostApiHalf, root = hostRoot()): ReadonlyMap<string, TypeView> => {
+  const place = HALF_PLACES[half];
+  const options = parsedConfig(path.join(root, place.config)).options;
+  const importer = path.join(root, place.importer);
+  const resolved = hostApiModules(half).map((specifier) => {
+    const module = ts.resolveModuleName(specifier, importer, options, ts.sys).resolvedModule;
+    if (!module) throw new Error(`${specifier} ist für die ${half}-Hälfte nicht auflösbar`);
+    return { specifier, module };
+  });
+  const probe = path.join(path.dirname(importer), "__host-api-probe__.ts");
+  const probeText = resolved.map(({ specifier }, index) => `import * as module${index} from ${JSON.stringify(specifier)};`).join("\n");
+  const compilerOptions = { ...options, noEmit: true };
+  const host = ts.createCompilerHost(compilerOptions);
+  const readSource = host.getSourceFile.bind(host);
+  host.getSourceFile = (file, language, onError, create) =>
+    path.resolve(file) === probe ? ts.createSourceFile(file, probeText, language, true) : readSource(file, language, onError, create);
+  const program = ts.createProgram({ rootNames: [probe], options: compilerOptions, host });
+  const checker = program.getTypeChecker();
+  const imports = program.getSourceFile(probe)!.statements.filter(ts.isImportDeclaration);
+  return new Map(resolved.map(({ specifier, module }, index) => {
+    const symbol = checker.getSymbolAtLocation(imports[index]!.moduleSpecifier);
+    if (!symbol) throw new Error(`${specifier}: ${module.resolvedFileName} hat kein Modulsymbol`);
+    const values = checker.getExportsOfModule(symbol).filter((exported) => {
+      const target = exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
+      return (target.flags & ts.SymbolFlags.Value) !== 0;
+    }).map((exported) => exported.name);
+    const names = symbol.exports?.has(ts.InternalSymbolName.ExportEquals) ? [...values, "default"] : values;
+    const library = module.isExternalLibraryImport === true;
+    const declarationOnly = !library && /\.d\.[cm]?ts$/.test(module.resolvedFileName);
+    return [specifier, { names: declarationOnly ? [] : [...new Set(names)].sort(), library }];
+  }));
+};
+
+const RUNTIME_SCRIPT = `
+const [mode, list] = process.argv.slice(1);
+const found = {};
+for (const specifier of JSON.parse(list)) {
+  const location = import.meta.resolve(specifier);
+  if (/\\.(ts|tsx|mts|cts)$/.test(location)) continue;
+  found[specifier] = mode === "import" ? Object.keys(await import(specifier)) : [];
+}
+process.stdout.write(JSON.stringify(found));
+`;
+
+/** Library modules whose implementation is JavaScript, resolved from the host app of the half; with import, their names as Node sees them. */
+const javaScriptModules = (half: HostApiHalf, specifiers: readonly string[], mode: "import" | "resolve", root: string): Readonly<Record<string, readonly string[]>> =>
+  JSON.parse(execFileSync(process.execPath, ["--input-type=module", "-e", RUNTIME_SCRIPT, mode, JSON.stringify(specifiers)], {
+    cwd: path.join(root, HALF_PLACES[half].app),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "inherit"],
+  })) as Record<string, readonly string[]>;
+
+/** The register of the web half: every listed module as a namespace, keyed by its specifier. */
+export const webRegisterSource = (specifiers: readonly string[] = hostApiModules("web")): string => [
+  ...specifiers.map((specifier, index) => `import * as module${index} from ${JSON.stringify(specifier)};`),
+  `export const hostModules = {`,
+  ...specifiers.map((specifier, index) => `  ${JSON.stringify(specifier)}: module${index},`),
+  `};`,
+].join("\n");
+
+/** Bundles the register the way a production browser build does, with the host's own resolution. */
+export const bundleWebRegister = async (specifiers: readonly string[], format: "cjs" | "iife", root = hostRoot()): Promise<string> => {
+  const result = await build({
+    stdin: { contents: webRegisterSource(specifiers), resolveDir: path.join(root, "apps/web/src"), loader: "ts", sourcefile: "host-modules.ts" },
+    bundle: true,
+    write: false,
+    platform: "browser",
+    format,
+    globalName: format === "iife" ? "__ragentsRegister" : undefined,
+    target: "es2022",
+    jsx: "automatic",
+    define: { "process.env.NODE_ENV": JSON.stringify("production"), "import.meta.hot": "undefined" },
+    loader: { ".css": "empty", ".svg": "empty", ".png": "empty", ".woff2": "empty" },
+    logLevel: "silent",
+  });
+  return result.outputFiles[0]!.text;
+};
+
+/** Names of library modules as a browser bundle sees them, evaluated without a page. */
+const webRuntimeNames = async (specifiers: readonly string[], root: string): Promise<Readonly<Record<string, readonly string[]>>> => {
+  const code = await bundleWebRegister(specifiers, "cjs", root);
+  const module = { exports: {} as { hostModules?: Record<string, object> } };
+  // Browser builds such as the one micromark uses for entities create an element while loading.
+  const document = { createElement: () => ({}) };
+  vm.runInNewContext(code, { module, exports: module.exports, console, setTimeout, clearTimeout, queueMicrotask, TextEncoder, TextDecoder, URL, document });
+  const modules = module.exports.hostModules;
+  if (!modules) throw new Error("Das Register der Web-Hälfte liefert keine Module");
+  return Object.fromEntries(Object.entries(modules).map(([specifier, namespace]) => [specifier, Object.keys(namespace)]));
+};
+
+/** A host module names exactly what it offers, each name a value it exports; a library counts whole. */
+const listedNames = (half: HostApiHalf, specifier: string, view: TypeView): readonly string[] | typeof LIBRARY => {
+  const listed = hostApi[half][specifier]!;
+  const hostCode = specifier.startsWith("@ragents/");
+  if (listed === LIBRARY) {
+    if (hostCode) throw new Error(`${specifier} ist Code des Hosts, keine Bibliothek; host-api.ts nennt seine Namen einzeln`);
+    return LIBRARY;
+  }
+  if (!hostCode) throw new Error(`${specifier} ist eine Bibliothek; host-api.ts gibt sie ganz frei`);
+  const missing = listed.filter((name) => !view.names.includes(name));
+  if (missing.length > 0) throw new Error(`host-api.ts nennt für ${specifier} ${missing.join(", ")}, das Modul exportiert es nicht als Wert`);
+  return [...listed].sort();
+};
+
+/** The value names per module: the list of a host module, for a library its types narrowed to what it really has at runtime. */
+export const hostApiNames = async (root = hostRoot()): Promise<HostApiRecord> => {
+  const half = async (which: HostApiHalf): Promise<Record<string, readonly string[]>> => {
+    const views = typeViews(which, root);
+    const candidates = [...views].filter(([, view]) => view.library).map(([specifier]) => specifier);
+    const runtime = which === "server"
+      ? javaScriptModules("server", candidates, "import", root)
+      : await webRuntimeNames(Object.keys(javaScriptModules("web", candidates, "resolve", root)), root);
+    return Object.fromEntries([...views].map(([specifier, view]) => {
+      const listed = listedNames(which, specifier, view);
+      if (listed !== LIBRARY) return [specifier, listed];
+      const present = runtime[specifier];
+      return [specifier, present ? view.names.filter((name) => present.includes(name)) : view.names];
+    }));
+  };
+  return { version: HOST_API_VERSION, server: await half("server"), web: await half("web") };
+};
+
+export const hostApiRecordText = (record: HostApiRecord): string => `${JSON.stringify(record, null, 2)}\n`;
+
+export interface HostApiChange {
+  readonly half: HostApiHalf;
+  readonly specifier: string;
+  readonly added: readonly string[];
+  readonly removed: readonly string[];
+}
+
+/** What differs between two records, per module; a module that disappeared lists all its names as removed. */
+export const hostApiChanges = (stored: HostApiRecord, current: HostApiRecord): readonly HostApiChange[] =>
+  (["server", "web"] as const).flatMap((half) => {
+    const specifiers = [...new Set([...Object.keys(stored[half]), ...Object.keys(current[half])])].sort();
+    return specifiers.flatMap((specifier) => {
+      const before = stored[half][specifier] ?? [];
+      const after = current[half][specifier] ?? [];
+      const added = after.filter((name) => !before.includes(name));
+      const removed = before.filter((name) => !after.includes(name));
+      return added.length > 0 || removed.length > 0 ? [{ half, specifier, added, removed }] : [];
+    });
+  });
+
+export const describeHostApiChange = (change: HostApiChange): string =>
+  `${change.half} ${change.specifier}: ${[
+    ...change.added.map((name) => `+${name}`),
+    ...change.removed.map((name) => `-${name}`),
+  ].join(" ")}`;

package/apps/server/src/plugin-build/plugin-description.ts

@@ -0,0 +1,118 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import type { HostApiHalf } from "../host-api.js";
+import { pluginsRoot } from "../plugin-support/plugins-root.js";
+
+export const PLUGIN_DESCRIPTION_FILE = "ragents-plugin.json";
+
+/** What the author states about a plugin source folder; entries stay convention. */
+export interface PluginDescription {
+  readonly id: string;
+  readonly exports: Readonly<Record<HostApiHalf, readonly string[]>>;
+  readonly assets: readonly string[];
+}
+
+export interface PluginSource {
+  readonly folder: string;
+  readonly description: PluginDescription;
+}
+
+const ID_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+/** Places of the bundle the build tool writes itself; an asset there would overwrite its output or publish sources under /plugins/<id>/web/. */
+const RESERVED_ASSET_ROOTS = new Set(["server", "web", "ragents-bundle.json"]);
+const DESCRIPTION_KEYS = new Set(["id", "exports", "assets"]);
+const HALVES = new Set(["server", "web"]);
+
+const stringList = (value: unknown, where: string): readonly string[] => {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+    throw new Error(`${where} muss eine Liste von Pfaden sein`);
+  }
+  return value as readonly string[];
+};
+
+/** A relative path inside the plugin folder, written with forward slashes and without leaving the folder. */
+const insidePath = (value: string, where: string): string => {
+  if (path.isAbsolute(value) || value.includes("\\") || value.split("/").some((part) => part === ".." || part === "." || part === "")) {
+    throw new Error(`${where}: ${value} ist kein relativer Pfad im Plugin-Ordner`);
+  }
+  return value;
+};
+
+/** The source file behind a module path without extension, the way a bundler finds it. */
+export const sourceFileOf = (stem: string): string | undefined =>
+  [`${stem}.ts`, `${stem}.tsx`, path.join(stem, "index.ts"), path.join(stem, "index.tsx")]
+    .find((candidate) => statSync(candidate, { throwIfNoEntry: false })?.isFile() === true);
+
+export const readPluginDescription = (folder: string): PluginDescription => {
+  const file = path.join(folder, PLUGIN_DESCRIPTION_FILE);
+  if (!existsSync(file)) {
+    throw new Error(`${folder} hat keine ${PLUGIN_DESCRIPTION_FILE}; ein Plugin beschreibt sich dort mit { "id": "${path.basename(folder)}" }`);
+  }
+  const raw = JSON.parse(readFileSync(file, "utf8")) as unknown;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new Error(`${file} muss ein Objekt enthalten`);
+  const record = raw as Record<string, unknown>;
+  const unknown = Object.keys(record).filter((key) => !DESCRIPTION_KEYS.has(key));
+  if (unknown.length > 0) throw new Error(`${file}: unbekannte Felder ${unknown.join(", ")}; erlaubt sind id, exports und assets`);
+  const id = record.id;
+  if (typeof id !== "string" || !ID_PATTERN.test(id)) throw new Error(`${file}: id muss eine Kennung wie acme.tickets sein`);
+  if (id !== path.basename(folder)) throw new Error(`${file}: die Kennung ${id} weicht vom Ordnernamen ${path.basename(folder)} ab`);
+  const exportsValue = record.exports ?? {};
+  if (typeof exportsValue !== "object" || exportsValue === null || Array.isArray(exportsValue)) {
+    throw new Error(`${file}: exports muss ein Objekt mit server und web sein`);
+  }
+  const halves = Object.keys(exportsValue).filter((half) => !HALVES.has(half));
+  if (halves.length > 0) throw new Error(`${file}: exports kennt nur server und web, nicht ${halves.join(", ")}`);
+  const exportsOf = (half: HostApiHalf): readonly string[] => {
+    const names = stringList((exportsValue as Record<string, unknown>)[half] ?? [], `${file}: exports.${half}`)
+      .map((name) => insidePath(name, `${file}: exports.${half}`));
+    for (const name of names) {
+      if (/\.(js|ts|tsx|mjs)$/.test(name)) throw new Error(`${file}: der Export ${name} wird ohne Endung genannt`);
+      if (!sourceFileOf(path.join(folder, name))) throw new Error(`${file}: der Export ${name} für ${half} hat keine Quelldatei`);
+    }
+    return names;
+  };
+  const assets = stringList(record.assets ?? [], `${file}: assets`).map((name) => insidePath(name, `${file}: assets`));
+  for (const name of assets) {
+    if (RESERVED_ASSET_ROOTS.has(name.split("/")[0]!)) throw new Error(`${file}: das Asset ${name} liegt unter ${name.split("/")[0]}, das schreibt das Bauwerkzeug selbst`);
+    if (!existsSync(path.join(folder, name))) throw new Error(`${file}: das Asset ${name} fehlt im Plugin-Ordner`);
+  }
+  return { id, exports: { server: exportsOf("server"), web: exportsOf("web") }, assets };
+};
+
+export const readPluginSource = (folder: string): PluginSource => {
+  const given = path.resolve(folder);
+  if (!statSync(given, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`${given} ist kein Ordner`);
+  const real = realpathSync.native(given);
+  return { folder: real, description: readPluginDescription(real) };
+};
+
+/** The nearest plugin folder that contains a file, if the file belongs to a plugin at all. */
+export const owningPluginFolder = (file: string): string | undefined => {
+  const parts = path.dirname(file).split(path.sep);
+  for (let length = parts.length; length > 1; length -= 1) {
+    const candidate = parts.slice(0, length).join(path.sep) || path.sep;
+    if (parts[length - 1] === "node_modules") return undefined;
+    if (existsSync(path.join(candidate, PLUGIN_DESCRIPTION_FILE))) return candidate;
+  }
+  return undefined;
+};
+
+/** The export a file stands for in its plugin, for the given half. */
+export const exportOfFile = (source: PluginSource, half: HostApiHalf, file: string): string | undefined =>
+  source.description.exports[half].find((name) => sourceFileOf(path.join(source.folder, name)) === file);
+
+/** Plugins a build may import by id: the siblings of the built folders first, then the host's own. */
+export const pluginCatalog = (folders: readonly string[], builtIn = pluginsRoot): ((id: string) => PluginSource | undefined) => {
+  const roots = [...new Set(folders.map((folder) => path.dirname(path.resolve(folder)))), builtIn];
+  const known = new Map<string, PluginSource | undefined>();
+  return (id) => {
+    if (!ID_PATTERN.test(id)) return undefined;
+    if (known.has(id)) return known.get(id);
+    const found = roots.map((root) => path.join(root, id)).filter((folder) => existsSync(path.join(folder, PLUGIN_DESCRIPTION_FILE)));
+    const distinct = [...new Set(found.map((folder) => realpathSync.native(folder)))];
+    if (distinct.length > 1) throw new Error(`Das Plugin ${id} gibt es mehrfach: ${distinct.join(", ")}`);
+    const source = distinct[0] ? readPluginSource(distinct[0]) : undefined;
+    known.set(id, source);
+    return source;
+  };
+};

package/apps/server/src/plugin-build/typecheck.ts

@@ -0,0 +1,66 @@
+import { readdirSync, existsSync } from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import type { HostApiHalf } from "../host-api.js";
+import { hostRoot } from "../host-version.js";
+import { PLUGIN_DESCRIPTION_FILE, sourceFileOf, type PluginSource } from "./plugin-description.js";
+
+/** The host's compiler settings for plugin code anywhere on disk; authors may extend the same file for their editor. */
+export const PLUGIN_TSCONFIG: Readonly<Record<HostApiHalf, string>> = {
+  server: "apps/server/tsconfig.plugin.json",
+  web: "apps/web/tsconfig.plugin.json",
+};
+
+/** The files a half starts from: its entry, the provisioning for the server, and the declared exports. */
+export const halfEntries = (source: PluginSource, half: HostApiHalf): readonly string[] => {
+  const own = half === "server" ? ["server/index", "provision"] : ["web/index"];
+  return [...own, ...source.description.exports[half]]
+    .map((name) => sourceFileOf(path.join(source.folder, name)))
+    .filter((file): file is string => file !== undefined);
+};
+
+const configOptions = (file: string): ts.CompilerOptions => {
+  const parsed = ts.getParsedCommandLineOfConfigFile(file, {}, {
+    ...ts.sys,
+    onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+      throw new Error(ts.flattenDiagnosticMessageText(diagnostic.messageText, " "));
+    },
+  });
+  if (!parsed) throw new Error(`${file} ist keine gültige tsconfig`);
+  return parsed.options;
+};
+
+/** Plugins beside the built ones can be imported by id; the host's own resolve through the plugin tsconfig. */
+const siblingPaths = (sources: readonly PluginSource[]): ts.MapLike<string[]> => {
+  const parents = [...new Set(sources.map((source) => path.dirname(source.folder)))];
+  return Object.fromEntries(parents.flatMap((parent) => readdirSync(parent, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && existsSync(path.join(parent, entry.name, PLUGIN_DESCRIPTION_FILE)))
+    .map((entry) => [`@ragents/plugins/${entry.name}/*`, [path.join(parent, entry.name, "*")]])));
+};
+
+const inside = (folder: string, file: string): boolean => file.startsWith(folder + path.sep);
+
+/** Type errors per plugin id; one program per half covers all given plugins, errors in host files stay the host's. */
+export const typecheckPlugins = (sources: readonly PluginSource[], root = hostRoot()): ReadonlyMap<string, readonly string[]> => {
+  const problems = new Map<string, string[]>(sources.map((source) => [source.description.id, []]));
+  for (const half of ["server", "web"] as const) {
+    const rootNames = sources.flatMap((source) => halfEntries(source, half));
+    if (rootNames.length === 0) continue;
+    const base = configOptions(path.join(root, PLUGIN_TSCONFIG[half]));
+    const options: ts.CompilerOptions = { ...base, noEmit: true, paths: { ...base.paths, ...siblingPaths(sources) } };
+    const program = ts.createProgram({ rootNames, options });
+    for (const diagnostic of ts.getPreEmitDiagnostics(program)) {
+      const text = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      const file = diagnostic.file?.fileName ? path.resolve(diagnostic.file.fileName) : undefined;
+      if (!file) {
+        for (const list of problems.values()) list.push(`${half}: ${text}`);
+        continue;
+      }
+      const owner = sources.find((source) => inside(source.folder, file));
+      if (!owner) continue;
+      const { line, character } = diagnostic.file!.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+      problems.get(owner.description.id)!.push(`${path.relative(owner.folder, file)}:${line + 1}:${character + 1}: ${text}`);
+    }
+  }
+  return problems;
+};

package/{plugins/ragents.actor-programs/server → apps/server/src/plugin-support/actor-programs}/app-project.ts

@@ -7,13 +7,13 @@ import { build } from "esbuild";
 import ts from "typescript";
 import { Type, type Static } from "typebox";
 import { Value } from "typebox/value";
-import { canonicalHash, typeScriptTypesFromSchema, type NativeTypeScriptExecutor, type RunCapabilityDescriptor, scriptStdDeclarations } from "@aicontainer/ragents";
+import { canonicalHash, schemaComplaints, typeScriptTypesFromSchema, type NativeTypeScriptExecutor, type RunCapabilityDescriptor, scriptStdDeclarations } from "@ragents/engine";
 import { runtimeLibraries, webRuntimeLibraries } from "./runtime-libraries.js";
 
-const webRequire = createRequire(new URL("../../../apps/web/package.json", import.meta.url));
-const rootRequire = createRequire(new URL("../../../package.json", import.meta.url));
-const serverRequire = createRequire(new URL("../../../apps/server/package.json", import.meta.url));
-const serverTypeRoot = fileURLToPath(new URL("../../../apps/server/node_modules/@types", import.meta.url));
+const webRequire = createRequire(new URL("../../../../web/package.json", import.meta.url));
+const rootRequire = createRequire(new URL("../../../../../package.json", import.meta.url));
+const serverRequire = createRequire(new URL("../../../package.json", import.meta.url));
+const serverTypeRoot = fileURLToPath(new URL("../../../node_modules/@types", import.meta.url));
 const libraryDirectory = (name: string): string => {
   const resolver = (webRuntimeLibraries as readonly string[]).includes(name) ? webRequire
     : name === "@types/node" || name === "tsx" ? serverRequire : rootRequire;
@@ -86,9 +86,10 @@ const sdkRuntime = `export const defineActor = (contract, implementation) => ({
 let testingBundle: Promise<string> | undefined;
 const testingRuntime = (): Promise<string> => testingBundle ??= build({
   stdin: {contents: `
-import {createRunContext} from ${JSON.stringify(fileURLToPath(new URL("../../../packages/ragents/src/typescript/run-context.ts",import.meta.url)))};
-import {assertJsonValue} from ${JSON.stringify(fileURLToPath(new URL("../../../packages/ragents/src/domain/json.ts",import.meta.url)))};
-import {createScriptStd} from ${JSON.stringify(fileURLToPath(new URL("../../../packages/ragents/src/script/std.ts",import.meta.url)))};
+import {createRunContext} from ${JSON.stringify(fileURLToPath(new URL("../../../../../packages/ragents/src/typescript/run-context.ts",import.meta.url)))};
+import {assertJsonValue} from ${JSON.stringify(fileURLToPath(new URL("../../../../../packages/ragents/src/domain/json.ts",import.meta.url)))};
+import {createScriptStd} from ${JSON.stringify(fileURLToPath(new URL("../../../../../packages/ragents/src/script/std.ts",import.meta.url)))};
+import {schemaComplaints} from ${JSON.stringify(fileURLToPath(new URL("../../../../../packages/ragents/src/domain/schema-errors.ts",import.meta.url)))};
 import {Value} from "typebox/value";
 export function createTestContextWithContracts(options, contracts) {
   let state = structuredClone(options.state);
@@ -100,10 +101,10 @@ export function createTestContextWithContracts(options, contracts) {
     const contract=declared.get(name);
     const call=options.functions?.[name];
     if(!call)throw new Error("Im Test fehlt die Funktion "+name);
-    if(!Value.Check(contract.schema,input))throw new Error("Testeingabe verletzt den Vertrag von "+name);
+    if(!Value.Check(contract.schema,input))throw new Error("Testeingabe verletzt den Vertrag von "+name+": "+schemaComplaints(contract.schema,input));
     const result=await call(input);
     assertJsonValue(result,"Testantwort von "+name);
-    if(!Value.Check(contract.resultSchema,result))throw new Error("Testantwort verletzt den Vertrag von "+name);
+    if(!Value.Check(contract.resultSchema,result))throw new Error("Testantwort verletzt den Vertrag von "+name+": "+schemaComplaints(contract.resultSchema,result,"result"));
     return result;
   }};
   return {...createRunContext({runId:"test",invocationId:"test",invocationKind:"tool",principal:{id:"test",kind:"service"},state:statePort,capabilities,log:()=>{},signal:controller.signal}),
@@ -150,11 +151,11 @@ export declare function defineActor<const C extends ActorContract>(contract: C,
 };
 
 let workflowSdk: Promise<{ javaScript: string; declarations: string; promptReader: string; promptDeclarations: string }> | undefined;
-const workflowSource = fileURLToPath(new URL("../workflow/index.ts", import.meta.url));
+const workflowSource = fileURLToPath(new URL("./workflow/index.ts", import.meta.url));
 const workflowSdkFiles = () => workflowSdk ??= (async () => {
   let declarations = "";
   let promptDeclarations = "";
-  const promptSource = fileURLToPath(new URL("../workflow/prompt-reader.ts", import.meta.url));
+  const promptSource = fileURLToPath(new URL("./workflow/prompt-reader.ts", import.meta.url));
   const program = ts.createProgram([workflowSource, promptSource], {
     target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext, moduleResolution: ts.ModuleResolutionKind.Bundler,
     strict: true, skipLibCheck: true, types: ["node"], typeRoots: [serverTypeRoot], declaration: true, emitDeclarationOnly: true,
@@ -178,7 +179,7 @@ export const installWorkflowSdk = async (directory: string): Promise<void> => {
   await writeFile(path.join(target, "prompt-reader.d.ts"), files.promptDeclarations);
   await writeFile(path.join(target, "prompt-reader.js"), files.promptReader);
   await writeFile(path.join(target, "prompts.d.ts"), 'import { createPromptReader } from "./prompt-reader.js";\nexport declare const readPrompt: ReturnType<typeof createPromptReader>;\n');
-  await writeFile(path.join(target, "prompts.js"), `import { createPromptReader } from "./prompt-reader.js";\nexport const readPrompt = createPromptReader(${JSON.stringify(directory)});\n`);
+  await writeFile(path.join(target, "prompts.js"), 'import { fileURLToPath } from "node:url";\nimport { createPromptReader } from "./prompt-reader.js";\nexport const readPrompt = createPromptReader(fileURLToPath(new URL("../../../", import.meta.url)));\n');
 };
 
 export const installServerSdk = async (directory: string, capabilities: readonly RunCapabilityDescriptor[] = []): Promise<void> => {
@@ -214,7 +215,7 @@ export const prepareAppProject = async (directory: string): Promise<void> => {
 
 export const readAppPackage = async (directory: string): Promise<AppPackage> => {
   const pkg = JSON.parse(await readFile(path.join(directory, "package.json"), "utf8")) as Record<string, unknown>;
-  if (!Value.Check(appPackageSchema, pkg.ragents)) throw new Error("package.json.ragents braucht title und gültige backend/views-Angaben.");
+  if (!Value.Check(appPackageSchema, pkg.ragents)) throw new Error(`package.json.ragents ist ungültig: ${schemaComplaints(appPackageSchema, pkg.ragents, "ragents")}`);
   if (!pkg.ragents.backend && !pkg.ragents.views?.length) throw new Error("Ein Actor-Paket braucht ein Backend oder mindestens eine Ansicht.");
   const views = pkg.ragents.views ?? [];
   if (new Set(views.map((view) => view.id)).size !== views.length) throw new Error("Ansichtsnamen müssen eindeutig sein.");
@@ -277,6 +278,6 @@ export const handle = (request, context) => {
     input: {}, state: {}, cwd: options.directory,
     context: { runId: options.runId, invocationId: "app-contract", invocationKind: "tool", principal: { id: "app-build", kind: "service" }, capabilities: [] },
   }, { signal, call: async () => { throw new Error("Beim Laden des App-Vertrags sind Run-Aufrufe nicht verfügbar."); }, log: () => undefined });
-  if (!Value.Check(appContractSchema, described.result)) throw new Error("Der Backend-Export braucht defineActor({state, functions, input?}, {functions, onInput?}) mit gültigen Aktionsverträgen.");
+  if (!Value.Check(appContractSchema, described.result)) throw new Error(`Der Backend-Export braucht defineActor({state, functions, input?}, {functions, onInput?}) mit gültigen Aktionsverträgen: ${schemaComplaints(appContractSchema, described.result, "contract")}`);
   return { contract: described.result, javaScript, hash: canonicalHash({ javaScript }) };
 };

package/{plugins/ragents.actor-programs/server → apps/server/src/plugin-support/actor-programs}/client-compiler.ts

@@ -5,7 +5,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { build, type Message } from "esbuild";
 import ts from "typescript";
-import { canonicalTypeScriptBuildContract, typeScriptTypeFromSchema, type VirtualTypeScriptDiagnostic } from "@aicontainer/ragents";
+import { canonicalTypeScriptBuildContract, typeScriptTypeFromSchema, type VirtualTypeScriptDiagnostic } from "@ragents/engine";
 import { installWorkflowSdk } from "./app-project.js";
 import { readClientUiContractFiles } from "./client-contracts.js";
 
@@ -25,9 +25,9 @@ export interface ClientProjectRequest extends ClientContracts {
   entryPoint: string;
 }
 
-const webRequire = createRequire(new URL("../../../apps/web/package.json", import.meta.url));
+const webRequire = createRequire(new URL("../../../../web/package.json", import.meta.url));
 const packageRoot = (id: string): string => path.dirname(webRequire.resolve(`${id}/package.json`));
-const uiSource = fileURLToPath(new URL("../client-ui/index.tsx", import.meta.url));
+const uiSource = fileURLToPath(new URL("../../../../web/src/actor-programs/client-ui/index.tsx", import.meta.url));
 
 const actionMap = (actions: readonly ClientActionContract[]): string => {
   const seen = new Set<string>();
@@ -102,7 +102,7 @@ export const installClientSdk = async (directory: string, contracts: ClientContr
     "tsconfig.json": JSON.stringify(clientCompilerConfig, null, 2),
     "index.d.ts": clientDeclarations(contracts),
     "index.js": clientSdkSource,
-    "ui.d.ts": 'export * from "./contracts/plugins/ragents.actor-programs/client-ui/contracts";\n',
+    "ui.d.ts": 'export * from "./contracts/apps/web/src/actor-programs/client-ui/contracts";\n',
     "ui.js": `export * from ${JSON.stringify(uiSource)};\n`,
     ...Object.fromEntries(Object.entries(readClientUiContractFiles()).map(([name, text]) => [`contracts/${name}`, text])),
   };

package/{plugins/ragents.actor-programs/server → apps/server/src/plugin-support/actor-programs}/client-contracts.ts

@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import ts from "typescript";
 
 function readContracts(repoRoot: string): { names: string[]; files: Record<string, string> } {
-  const filename = path.join(repoRoot, "plugins/ragents.actor-programs/client-ui/contracts.d.ts");
+  const filename = path.join(repoRoot, "apps/web/src/actor-programs/client-ui/contracts.d.ts");
   const options: ts.CompilerOptions = {
     target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext,
     moduleResolution: ts.ModuleResolutionKind.Bundler, jsx: ts.JsxEmit.ReactJSX,
@@ -59,7 +59,7 @@ function readContracts(repoRoot: string): { names: string[]; files: Record<strin
 
 let cached: ReturnType<typeof readContracts> | undefined;
 const contracts = (repoRoot?: string) => repoRoot === undefined
-  ? cached ??= readContracts(fileURLToPath(new URL("../../../", import.meta.url)))
+  ? cached ??= readContracts(fileURLToPath(new URL("../../../../../", import.meta.url)))
   : readContracts(repoRoot);
 
 export function readClientUiContractFiles(repoRoot?: string): Record<string, string> {
@@ -76,7 +76,7 @@ export function readClientUiComponentContracts(component: string, repoRoot?: str
 }
 
 export function readClientUiExportContracts(component: string, repoRoot?: string): Record<string, string> {
-  const root = repoRoot ?? fileURLToPath(new URL("../../../", import.meta.url));
+  const root = repoRoot ?? fileURLToPath(new URL("../../../../../", import.meta.url));
   const catalog = contracts(repoRoot);
   const files = new Map(Object.entries(catalog.files).map(([name, text]) => [path.resolve(root, name), text]));
   const options: ts.CompilerOptions = { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext, moduleResolution: ts.ModuleResolutionKind.Bundler, strict: true, skipLibCheck: true };
@@ -94,7 +94,7 @@ export function readClientUiExportContracts(component: string, repoRoot?: string
     const text = host.readFile(name);
     return text === undefined ? undefined : ts.createSourceFile(name, text, languageVersion, true);
   };
-  const entry = path.join(root, "plugins/ragents.actor-programs/client-ui/contracts.d.ts");
+  const entry = path.join(root, "apps/web/src/actor-programs/client-ui/contracts.d.ts");
   const program = ts.createProgram([entry], options, host);
   const checker = program.getTypeChecker();
   const selected = new Set<ts.Statement>();

package/apps/server/src/plugin-support/actor-programs/client-runtime.ts

@@ -0,0 +1,27 @@
+import { fileURLToPath } from "node:url";
+import { buildSync } from "esbuild";
+
+export { FRAME_BODY_CLASS, FRAME_DOCUMENT_CLASS, FRAME_ROOT_CLASS } from "../../../../web/src/actor-programs/client-ui/frame-layout.js";
+
+/** Third-party stylesheets every mini-app frame needs: syntax colors, diff markup and the flow diagram. */
+const entries = ["../../highlighting.css", "../../diff-view.css", "./flow-diagram.css"];
+
+export const browserRuntimeStyles = buildSync({
+  stdin: {
+    contents: entries.map((file) => `@import "${file}";`).join("\n"),
+    resolveDir: fileURLToPath(new URL("../../../../web/src/actor-programs/client-ui/", import.meta.url)),
+    loader: "css",
+  },
+  bundle: true,
+  write: false,
+  minify: true,
+}).outputFiles[0].text;
+
+export const browserInputRuntime = buildSync({
+  entryPoints: [fileURLToPath(new URL("../../../../web/src/run-panel/input-bridge.ts", import.meta.url))],
+  bundle: true,
+  write: false,
+  minify: true,
+  format: "iife",
+  globalName: "ragentsInputBridge",
+}).outputFiles[0].text;

package/{plugins/ragents.actor-programs → apps/server/src/plugin-support/actor-programs}/contract.ts

@@ -1,6 +1,6 @@
 import { Type } from "typebox";
-import { defineOperation } from "@aicontainer/ragents/src/rpc/contract";
-import { openJson } from "@aicontainer/ragents/src/http/contracts";
+import { defineOperation } from "@ragents/engine/src/rpc/contract";
+import { openJson } from "@ragents/engine/src/http/contracts";
 
 export const ACTOR_PROGRAMS_STATE_ID = "ragents.actor-programs";
 export const ACTOR_INVOCATIONS_STATE_ID = "ragents.actor-programs.invocations";
@@ -57,7 +57,7 @@ export const resolveActorView = (programs: readonly ActorProgramDefinition[], re
   const matches = named.length > 0 ? named : views.filter(({ view }) => view.title.toLowerCase() === normalized);
   const names = (entries: typeof views) => entries.map(({ program, view }) => `${program.name}/${view.key} (@${program.actorHandle}/${view.key})`).join(", ") || "keine";
   if (matches.length === 0) {
-    throw new Error(`${reference} ist keine aktive Actor-Ansicht dieses Laufs. Zuerst das Programm aktivieren. Vorhanden: ${names(views)}`);
+    throw new Error(`${reference} ist keine aktive Actor-Ansicht dieses Runs. Zuerst das Programm aktivieren. Vorhanden: ${names(views)}`);
   }
   if (matches.length > 1) throw new Error(`${reference} ist mehrdeutig. Verwende einen eindeutigen Namen: ${names(matches)}`);
   return matches[0]!;

package/apps/server/src/plugin-support/actor-programs/service.ts

@@ -1,4 +1,4 @@
-import { serviceToken, type ActorProgramExecutor, type CommandContext } from "@aicontainer/ragents";
+import { serviceToken, type ActorProgramExecutor, type CommandContext } from "@ragents/engine";
 export interface ActorProgramSource {
     path: string;
     content: string;

package/{plugins/ragents.actor-programs/server → apps/server/src/plugin-support/actor-programs}/tailwind.ts

@@ -4,8 +4,7 @@ import { fileURLToPath } from "node:url";
 import { compile } from "@tailwindcss/node";
 import { Scanner } from "@tailwindcss/oxide";
 
-const hostDirectory = fileURLToPath(new URL("../../../apps/web/src/", import.meta.url));
-const clientUiDirectory = fileURLToPath(new URL("../client-ui/", import.meta.url));
+const hostDirectory = fileURLToPath(new URL("../../../../web/src/", import.meta.url));
 export const frameStylesheet = path.join(hostDirectory, "ui/frame.css");
 
 export type TailwindSource = string | { base: string; pattern: string };
@@ -16,7 +15,7 @@ export const buildTailwind = async (sources: readonly TailwindSource[], entry =
   const compiler = await compile(css, { base: path.dirname(entry), onDependency: () => {} });
   const scanner = new Scanner({ sources: [
     ...compiler.sources,
-    ...[hostDirectory, clientUiDirectory, ...sources].map((source) => typeof source === "string" ? { base: source, pattern: "**/*", negated: false } : { ...source, negated: false }),
+    ...[hostDirectory, ...sources].map((source) => typeof source === "string" ? { base: source, pattern: "**/*", negated: false } : { ...source, negated: false }),
   ] });
   return compiler.build(scanner.scan());
 };