@schlenkr/ragents 0.1.1 → 0.1.2

package/README.md

@@ -22,11 +22,15 @@ npm install -g @schlenkr/ragents
   RAGENTS_TOKEN=<token> ragents connect https://ragents.example.com
   ```
 
-- `start <profile>` - start a profile shipped with the package (`core`, `developer`) or a stand that
-  `connect` already fetched, without asking the server.
+- `start <profile|path>` - start a profile shipped with the package (`core`, `developer`), your
+  own `ragents.config.<name>.ts` anywhere on disk, or a stand that `connect` already fetched,
+  without asking the server. The web interface is built for that set of plugins when it is
+  missing or was last built for another profile or host version; the result goes to
+  `<data dir>/web/<profile>`, never into the package folder.
 
   ```sh
   ragents start developer
+  ragents start ~/projects/mine/ragents.config.mine.ts
   ```
 
 - `provision [<profile>|--workspace]` - fetch the tools the plugins of that profile need, such as
@@ -44,7 +48,8 @@ npm install -g @schlenkr/ragents
   ```
 
 - `run <folder> "<task>"` - start the host if none answers, bind a new run to the folder and wait
-  until the turn is finished; the last line is always `run: <id>`.
+  until the turn is finished; the last line is always `run: <id>`. This host serves no web
+  interface - an agent does not need one; use `start` for that.
 
   ```sh
   ragents run ~/projects/demo "Fix the type error in src/broken.ts"
@@ -71,7 +76,8 @@ npm install -g @schlenkr/ragents
 
 ## Requirements
 
-- Node 22 (>= 22.19.0). No git, no pnpm, no build step.
+- Node 22 (>= 22.19.0). No git, no pnpm, no source checkout; the package builds its own web
+  interface per profile with the Vite it brings along.
 - `dotnet` (.NET 10 SDK) for the C# diagnostics through Roslyn and the F# diagnostics through FSAC;
   without it TypeScript diagnostics still work.
 - Model access: either `OPENROUTER_API_KEY` in the environment, or `ragents connect <server-url>`

package/apps/server/src/profile-target.ts

@@ -0,0 +1,25 @@
+import { statSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { isEnvironmentReference } from "./config-definition.js";
+import { defaultDataDirectory } from "./data-directory.js";
+
+export interface ProfileTarget {
+  readonly profile: string;
+  readonly profileFile: string;
+  readonly port: number;
+  readonly dataDirectory: string;
+  readonly baseUrl: string;
+}
+
+/** Port und Datenordner eines Profils, wie der Server sie später selbst bestimmt: Umgebung vor Profildatei vor Vorgabe. */
+export const readProfileTarget = async (profile: string, profileFile: string, environment = process.env): Promise<ProfileTarget> => {
+  if (!statSync(profileFile, { throwIfNoEntry: false })?.isFile()) throw new Error(`Die Profildatei fehlt: ${profileFile}`);
+  const module = await import(pathToFileURL(profileFile).href) as { config: { host: { PORT?: number; DATA_DIR?: unknown } } };
+  const port = Number(environment.PORT || module.config.host.PORT);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`host.PORT des Profils ${profile} ist keine gültige Portnummer.`);
+  const configured = module.config.host.DATA_DIR;
+  const fromFile = isEnvironmentReference(configured) ? environment[configured.name] : typeof configured === "string" ? configured : undefined;
+  const dataDirectory = path.resolve(environment.DATA_DIR ?? fromFile ?? defaultDataDirectory(profile));
+  return { profile, profileFile, port, dataDirectory, baseUrl: `http://localhost:${port}` };
+};

package/apps/server/src/web-build.ts

@@ -0,0 +1,82 @@
+import { spawn } from "node:child_process";
+import { statSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { readHostVersion } from "./host-version.js";
+
+/** Vite kommt im Checkout aus apps/web/node_modules, im Paket aus dessen Abhängigkeiten; beide Male ab apps/web aufgelöst. */
+export const viteEntry = (root: string): string => {
+  try {
+    const manifest = createRequire(path.join(root, "apps/web/package.json")).resolve("vite/package.json");
+    return path.join(path.dirname(manifest), "bin/vite.js");
+  } catch (cause) {
+    throw new Error(`Der Web-Build findet Vite neben ${path.join(root, "apps/web")} nicht: `
+      + `${cause instanceof Error ? cause.message : String(cause)}`);
+  }
+};
+
+const run = (file: string, args: readonly string[], cwd: string, environment: NodeJS.ProcessEnv, log: (line: string) => void): Promise<void> =>
+  new Promise((resolve, reject) => {
+    const child = spawn(file, args, { cwd, env: environment, stdio: ["ignore", "pipe", "pipe"] });
+    for (const stream of [child.stdout, child.stderr]) createInterface({ input: stream! }).on("line", log);
+    child.once("error", reject);
+    child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`Der Web-Build endete mit Code ${code}`)));
+  });
+
+export interface WebBuild {
+  readonly root: string;
+  /** Node, das Vite ausführt; in der Erweiterung ist process.execPath Electron und taugt nicht. */
+  readonly node?: string;
+  readonly outputDirectory: string;
+  readonly environment: NodeJS.ProcessEnv;
+  readonly log: (line: string) => void;
+}
+
+/** Baut das Web für den Pluginsatz, den die Umgebung nennt: PRODUCT_PROFILE samt Datei oder PLUGIN_LIST_FILE. */
+export const buildWeb = async (build: WebBuild): Promise<void> => {
+  const entry = viteEntry(build.root);
+  await rm(build.outputDirectory, { recursive: true, force: true });
+  await mkdir(path.dirname(build.outputDirectory), { recursive: true });
+  await run(build.node ?? process.execPath, [entry, "build", "--outDir", build.outputDirectory, "--emptyOutDir"], path.join(build.root, "apps/web"), build.environment, build.log);
+  if (!statSync(path.join(build.outputDirectory, "index.html"), { throwIfNoEntry: false })?.isFile()) {
+    throw new Error(`Der Web-Build hat keine index.html in ${build.outputDirectory} hinterlassen`);
+  }
+};
+
+/** Je Profil ein gebautes Web im Datenordner; der Paketordner bleibt unberührt. */
+export const webBuildDirectory = (dataDirectory: string, profile: string): string => path.join(dataDirectory, "web", profile);
+
+export interface WebBuildTarget {
+  readonly root: string;
+  readonly node?: string;
+  readonly profile: string;
+  readonly profileFile: string;
+  readonly dataDirectory: string;
+  readonly environment: NodeJS.ProcessEnv;
+  readonly log: (line: string) => void;
+  readonly build?: (build: WebBuild) => Promise<void>;
+}
+
+const stampOf = (target: WebBuildTarget): string =>
+  JSON.stringify({ root: target.root, profileFile: target.profileFile, hostVersion: readHostVersion(target.root) }, null, 2);
+
+/** Baut das Web des Profils, wenn es fehlt oder zuletzt für ein anderes Profil oder eine andere Host-Fassung gebaut wurde. */
+export const ensureWebBuild = async (target: WebBuildTarget): Promise<string> => {
+  const directory = webBuildDirectory(target.dataDirectory, target.profile);
+  const stampFile = `${directory}.json`;
+  const stamp = stampOf(target);
+  const built = statSync(path.join(directory, "index.html"), { throwIfNoEntry: false })?.isFile() === true;
+  if (built && (await readFile(stampFile, "utf8").catch(() => undefined))?.trim() === stamp) return directory;
+  target.log(`== Web des Profils ${target.profile} bauen nach ${directory}`);
+  await (target.build ?? buildWeb)({
+    root: target.root,
+    node: target.node,
+    outputDirectory: directory,
+    environment: { ...target.environment, PRODUCT_PROFILE: target.profile, PRODUCT_PROFILE_FILE: target.profileFile },
+    log: target.log,
+  });
+  await writeFile(stampFile, `${stamp}\n`);
+  return directory;
+};

package/apps/server/tsconfig.json

@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "types": [
+      "node"
+    ],
+    "noEmit": true,
+    "lib": [
+      "ES2024"
+    ],
+    "paths": {
+      "@aicontainer/server/*": [
+        "../../apps/server/src/*"
+      ],
+      "@aicontainer/web/*": [
+        "../../apps/web/src/*"
+      ],
+      "@aicontainer/plugins/*": [
+        "../../plugins/*"
+      ],
+      "@ragents/workflow": [
+        "../../plugins/ragents.actor-programs/workflow/index.ts"
+      ]
+    }
+  },
+  "include": [
+    "src",
+    "../../plugins/*/server",
+    "../../plugins/*/contract.ts",
+    "../../ragents.config.*.ts"
+  ]
+}

package/apps/web/column.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="de">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>RAgents Panel</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/column.tsx"></script>
+  </body>
+</html>

package/apps/web/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="de">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>RAgents</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/apps/web/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "lib": [
+      "ES2024",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ],
+      "@aicontainer/server/*": [
+        "../../apps/server/src/*"
+      ],
+      "@aicontainer/web/*": [
+        "../../apps/web/src/*"
+      ],
+      "@aicontainer/plugins/*": [
+        "../../plugins/*"
+      ],
+      "@ragents/workflow": [
+        "../../plugins/ragents.actor-programs/workflow/index.ts"
+      ]
+    }
+  },
+  "include": [
+    "src",
+    "../../plugins/*/web",
+    "../../plugins/ragents.actor-programs/client-ui/index.tsx",
+    "../../plugins/*/contract.ts"
+  ]
+}

package/apps/web/vite.config.ts

@@ -0,0 +1,140 @@
+import { fileURLToPath } from "node:url";
+import { execFileSync } from "node:child_process";
+import { readdir, readFile } from "node:fs/promises";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import { defineConfig, type Plugin } from "vite";
+
+const apiTarget = process.env.API_TARGET ?? "http://localhost:4710";
+const repositoryRoot = fileURLToPath(new URL("../../", import.meta.url));
+const hostEntry = path.join(repositoryRoot, "apps/web/src/main.tsx");
+const pluginEntriesModule = "virtual:ragents-plugins";
+
+interface BundledPlugin {
+  readonly id: string;
+  readonly folder: string;
+  readonly web: string | undefined;
+}
+
+const webEntryOf = (folder: string): string | undefined =>
+  ["web/index.ts", "web/index.tsx"].map((name) => path.join(folder, name))
+    .find((candidate) => statSync(candidate, { throwIfNoEntry: false })?.isFile() === true);
+
+const repositoryPlugins = (): BundledPlugin[] => {
+  const root = path.join(repositoryRoot, "plugins");
+  return readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => ({ id: entry.name, folder: path.join(root, entry.name), web: webEntryOf(path.join(root, entry.name)) }));
+};
+
+/** The profile's plugins as the server resolves them; PLUGIN_LIST_FILE names them directly, otherwise the last stdout line carries the JSON. */
+const profilePlugins = (): BundledPlugin[] => {
+  const listFile = process.env.PLUGIN_LIST_FILE;
+  if (listFile) return JSON.parse(readFileSync(listFile, "utf8")) as BundledPlugin[];
+  if (!process.env.PRODUCT_PROFILE) return [];
+  const output = execFileSync("node", ["--import", "tsx", "src/profile/plugin-list.ts"], {
+    cwd: path.join(repositoryRoot, "apps/server"),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "inherit"],
+  });
+  return JSON.parse(output.trim().split("\n").at(-1) ?? "[]") as BundledPlugin[];
+};
+
+/** Bundles the repository's plugins and, with a profile, its plugins from anywhere on disk. */
+const bundledPlugins = (): BundledPlugin[] => {
+  const plugins = repositoryPlugins();
+  for (const plugin of profilePlugins()) {
+    const known = plugins.find((candidate) => candidate.id === plugin.id);
+    if (known && known.folder !== plugin.folder) {
+      throw new Error(`Das Plugin ${plugin.id} liegt unter ${known.folder} und ${plugin.folder}`);
+    }
+    if (!known) plugins.push(plugin);
+  }
+  return plugins;
+};
+
+const isBareSpecifier = (specifier: string): boolean =>
+  !/^(\.{1,2}\/|\/|\0|[a-z][a-z0-9+.-]*:)/i.test(specifier);
+
+const ragentsPlugins = (plugins: readonly BundledPlugin[]): Plugin => {
+  const external = plugins.filter((plugin) => !plugin.folder.startsWith(repositoryRoot));
+  const withWeb = plugins.filter((plugin) => plugin.web !== undefined);
+  return {
+    name: "ragents-plugins",
+    enforce: "pre",
+    config: () => ({
+      resolve: {
+        alias: {
+          "@aicontainer/ragents/src": path.join(repositoryRoot, "packages/ragents/src"),
+          "@aicontainer/server": path.join(repositoryRoot, "apps/server/src"),
+          "@aicontainer/web": path.join(repositoryRoot, "apps/web/src"),
+          "@aicontainer/plugins": path.join(repositoryRoot, "plugins"),
+        },
+      },
+      server: { fs: { allow: [repositoryRoot, ...external.map((plugin) => plugin.folder)] } },
+    }),
+    resolveId(source, importer) {
+      if (source === pluginEntriesModule) return `\0${pluginEntriesModule}`;
+      if (!importer || importer.startsWith(repositoryRoot) || !isBareSpecifier(source)) return null;
+      return this.resolve(source, hostEntry, { skipSelf: true });
+    },
+    load(id) {
+      if (id !== `\0${pluginEntriesModule}`) return null;
+      const entries = withWeb.map((plugin) => `  ${JSON.stringify(plugin.id)}: () => import(${JSON.stringify(plugin.web)}),`);
+      return `export const webPluginEntries = {\n${entries.join("\n")}\n};\n`;
+    },
+    transform(code, id) {
+      if (!id.endsWith("/apps/web/src/ui/tailwind.css") || external.length === 0) return null;
+      const sources = external.flatMap((plugin) => [
+        `@source ${JSON.stringify(path.join(plugin.folder, "web/**/*"))};`,
+        `@source ${JSON.stringify(path.join(plugin.folder, "client-ui/**/*"))};`,
+      ]);
+      return `${code}\n${sources.join("\n")}\n`;
+    },
+  };
+};
+
+export default defineConfig({
+  plugins: [ragentsPlugins(bundledPlugins()), react(), tailwindcss(), {
+    name: "ragents-help",
+    apply: "build",
+    buildStart() {
+      const script = path.join(repositoryRoot, "build/homepage.sh");
+      if (statSync(script, { throwIfNoEntry: false })?.isFile()) execFileSync("bash", [script], { cwd: repositoryRoot, stdio: "inherit" });
+    },
+    async generateBundle() {
+      const directory = path.join(repositoryRoot, "docs/homepage/dist");
+      if (!statSync(directory, { throwIfNoEntry: false })?.isDirectory()) return;
+      const include = async (relative: string): Promise<void> => {
+        for (const entry of await readdir(path.join(directory, relative), { withFileTypes: true })) {
+          const name = path.posix.join(relative, entry.name);
+          if (entry.isDirectory()) await include(name);
+          else this.emitFile({ type: "asset", fileName: `help/${name}`, source: await readFile(path.join(directory, name)) });
+        }
+      };
+      await include("");
+    },
+  }],
+  build: {
+    outDir: path.join(repositoryRoot, "apps/web/dist", process.env.PRODUCT_PROFILE ?? "ohne-profil"),
+    rollupOptions: {
+      input: {
+        main: fileURLToPath(new URL("index.html", import.meta.url)),
+        column: fileURLToPath(new URL("column.html", import.meta.url)),
+      },
+    },
+  },
+  server: {
+    port: 5710,
+    strictPort: true,
+    proxy: {
+      "/api": apiTarget,
+      "/chat": apiTarget,
+      "/plugin-assets": apiTarget,
+      "/ragents": apiTarget,
+      "/help": apiTarget,
+    },
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schlenkr/ragents",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "RAgents-Host: Server, Engine, Plugins und Werkzeuge ohne Quell-Checkout",
   "keywords": [
     "agents",
@@ -37,9 +37,11 @@
     "@silvia-odwyer/photon-node": "0.3.4",
     "@tailwindcss/node": "4.3.3",
     "@tailwindcss/oxide": "4.3.3",
+    "@tailwindcss/vite": "4.3.3",
     "@types/node": "24.13.3",
     "@types/react": "19.2.18",
     "@types/react-dom": "19.2.4",
+    "@vitejs/plugin-react": "4.7.0",
     "@xyflow/react": "12.11.6",
     "ai": "7.0.99",
     "chalk": "5.6.2",
@@ -47,6 +49,7 @@
     "cn": "0.3.0",
     "cross-spawn": "7.0.6",
     "diff": "8.0.4",
+    "dompurify": "3.4.13",
     "elkjs": "0.12.0",
     "esbuild": "0.28.2",
     "glob": "13.0.6",
@@ -73,6 +76,7 @@
     "typescript": "5.9.3",
     "typescript-language-server": "6.0.0",
     "undici": "8.5.0",
+    "vite": "6.4.3",
     "vscode-jsonrpc": "9.0.2",
     "yaml": "2.9.0"
   },

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

@@ -1,29 +1,10 @@
-import { spawn } from "node:child_process";
-import { statSync } from "node:fs";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { createInterface } from "node:readline";
 import { hostRoot } from "@aicontainer/server/host-version.js";
 import { webEntryOf } from "@aicontainer/server/plugin-support/plugins-root.js";
+import { buildWeb } from "@aicontainer/server/web-build.js";
 import type { InspectedClientProfile } from "./archive.js";
 
-const viteEntry = (root: string): string => {
-  const file = path.join(root, "apps/web/node_modules/vite/bin/vite.js");
-  if (!statSync(file, { throwIfNoEntry: false })?.isFile()) {
-    throw new Error(`Die Profilverteilung baut das Web des Client-Profils und braucht dafür Vite unter ${file}; `
-      + "ein verteilender Server ist ein Checkout mit pnpm install");
-  }
-  return file;
-};
-
-const run = (file: string, args: readonly string[], cwd: string, environment: NodeJS.ProcessEnv, log: (line: string) => void): Promise<void> =>
-  new Promise((resolve, reject) => {
-    const child = spawn(file, args, { cwd, env: environment, stdio: ["ignore", "pipe", "pipe"] });
-    for (const stream of [child.stdout, child.stderr]) createInterface({ input: stream! }).on("line", log);
-    child.once("error", reject);
-    child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`Der Web-Build des Client-Profils endete mit Code ${code}`)));
-  });
-
 /** Baut das Web für den Pluginsatz des Client-Profils, damit der Client keinen Build braucht. */
 export const buildClientWeb = async (
   inspected: InspectedClientProfile,
@@ -31,18 +12,13 @@ export const buildClientWeb = async (
   log: (line: string) => void,
   root = hostRoot(),
 ): Promise<void> => {
-  const entry = viteEntry(root);
-  await rm(outputDirectory, { recursive: true, force: true });
-  await mkdir(path.dirname(outputDirectory), { recursive: true });
   const listFile = `${outputDirectory}.plugins.json`;
   const list = inspected.plugins.map((plugin) => ({ id: plugin.id, folder: plugin.folder, web: webEntryOf(plugin.folder) }));
+  await mkdir(path.dirname(listFile), { recursive: true });
   await writeFile(listFile, `${JSON.stringify(list, null, 2)}\n`);
   const environment: NodeJS.ProcessEnv = { ...process.env, PLUGIN_LIST_FILE: listFile };
   delete environment.PRODUCT_PROFILE;
   delete environment.PRODUCT_PROFILE_FILE;
-  await run(process.execPath, [entry, "build", "--outDir", outputDirectory, "--emptyOutDir"], path.join(root, "apps/web"), environment, log);
+  await buildWeb({ root, outputDirectory, environment, log });
   await rm(listFile);
-  if (!statSync(path.join(outputDirectory, "index.html"), { throwIfNoEntry: false })?.isFile()) {
-    throw new Error(`Der Web-Build des Client-Profils hat keine index.html in ${outputDirectory} hinterlassen`);
-  }
 };

package/scripts/agent/agent-cli.ts

@@ -1,13 +1,14 @@
+// Der Hook löst @aicontainer/* 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 { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import { coreContracts } from "../../apps/server/src/api/contracts.ts";
 import { profileFileName } from "../../apps/server/src/config-file.ts";
-import { isEnvironmentReference } from "../../apps/server/src/config-definition.ts";
-import { defaultDataDirectory } from "../../apps/server/src/data-directory.ts";
 import { hostRoot } from "../../apps/server/src/host-version.ts";
+import { readProfileTarget, type ProfileTarget } from "../../apps/server/src/profile-target.ts";
 import { RpcClient } from "../../apps/web/src/rpc/client.ts";
 import { WORKSPACE_BINDING_OPTION_ID } from "../../plugins/ragents.workspace/contract.ts";
 import { JournalReader, journalLines, readJournal, RUN_ID_PATTERN, type JournalEvent } from "./journal.ts";
@@ -33,7 +34,8 @@ export const usage = (): string => `Verwendung: ragents <befehl> [argumente]
 Vorgabeprofil ist ${DEFAULT_PROFILE}. Exit-Code: 0 fertig, 2 abgebrochen, 1 fehlgeschlagen oder
 Verbindungsproblem. Die letzte Zeile auf stdout ist "run: <id>". Die Adresse kommt aus
 <Datenordner>/host.json, sonst aus RAGENTS_URL, sonst aus host.PORT des Profils; RAGENTS_TOKEN
-geht als Bearer-Token mit, falls das Profil eine Anmeldung verlangt.`;
+geht als Bearer-Token mit, falls das Profil eine Anmeldung verlangt. Der so gestartete Host baut
+die Oberfläche nicht - ein Agent braucht sie nicht; mit Oberfläche startet ragents start <profil>.`;
 
 export type AgentCommand =
   | { readonly kind: "run"; readonly profile: string; readonly folder: string; readonly text: string; readonly entry: string | undefined; readonly json: boolean }
@@ -123,14 +125,6 @@ export const parseArguments = (argv: readonly string[]): AgentCommand => {
   throw new Error(command ? `Unbekannter Befehl: ${command}\n\n${usage()}` : usage());
 };
 
-export interface ProfileTarget {
-  readonly profile: string;
-  readonly profileFile: string;
-  readonly port: number;
-  readonly dataDirectory: string;
-  readonly baseUrl: string;
-}
-
 export interface HostRecord {
   readonly profile: string;
   readonly url: string;
@@ -155,17 +149,8 @@ export const writeHostRecord = (dataDirectory: string, record: HostRecord): void
   writeFileSync(hostRecordFile(dataDirectory), `${JSON.stringify(record, null, 2)}\n`);
 };
 
-export const loadProfile = async (profile: string, root = hostRoot()): Promise<ProfileTarget> => {
-  const profileFile = path.join(root, profileFileName(profile));
-  if (!existsSync(profileFile)) throw new Error(`Die Profildatei fehlt: ${profileFile}`);
-  const module = await import(pathToFileURL(profileFile).href) as { config: { host: { PORT?: number; DATA_DIR?: unknown } } };
-  const port = Number(process.env.PORT || module.config.host.PORT);
-  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`host.PORT des Profils ${profile} ist keine gültige Portnummer.`);
-  const configured = module.config.host.DATA_DIR;
-  const fromFile = isEnvironmentReference(configured) ? process.env[configured.name] : typeof configured === "string" ? configured : undefined;
-  const dataDirectory = path.resolve(process.env.DATA_DIR ?? fromFile ?? defaultDataDirectory(profile));
-  return { profile, profileFile, port, dataDirectory, baseUrl: `http://localhost:${port}` };
-};
+export const loadProfile = (profile: string, root = hostRoot()): Promise<ProfileTarget> =>
+  readProfileTarget(profile, path.join(root, profileFileName(profile)));
 
 /** pnpm und der bin-Befehl führen dieses Skript mit dem Arbeitsverzeichnis apps/server aus; ein relativer Ordner gilt trotzdem ab dem Aufrufer. */
 export const callerDirectory = (): string => process.env.RAGENTS_CWD ?? process.env.INIT_CWD ?? process.cwd();

package/scripts/package/build-package.ts

@@ -39,12 +39,17 @@ const ROOT_FILE_SOURCES = new Set(PACKAGE_ROOT_FILES.map(([source]) => source));
 
 const skippedInPackage = (relative: string): boolean => SKIPPED_IN_PACKAGE.test(relative) || ROOT_FILE_SOURCES.has(relative);
 
-/** Was der Host zur Laufzeit lädt: Server, Engine, Plugins, Profile und die Skripte hinter den Unterbefehlen. */
+/** Was der Host zur Laufzeit lädt: Server, Engine, Plugins, Profile, den Web-Build und die Skripte hinter den Unterbefehlen. */
 export const packageContents = (root = repositoryRoot): readonly string[] => [
   "apps/server/package.json",
+  "apps/server/tsconfig.json",
   "apps/server/src",
   "apps/server/agent-home/settings.json",
   "apps/web/package.json",
+  "apps/web/tsconfig.json",
+  "apps/web/vite.config.ts",
+  "apps/web/index.html",
+  "apps/web/column.html",
   "apps/web/src",
   ...readdirSync(path.join(root, "packages"), { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
@@ -58,10 +63,10 @@ export const packageContents = (root = repositoryRoot): readonly string[] => [
   "scripts/workspace-client",
 ];
 
-/** Was der Host ausführt oder in eine Mini-App bündelt; die web-Ordner der Plugins baut der zentrale Server. */
-const SCANNED = ["apps/server/src", "apps/web/src", "packages", "plugins", "scripts"];
+/** Was der Host ausführt, in eine Mini-App bündelt oder beim Start in sein Web baut. */
+const SCANNED = ["apps/server/src", "apps/web", "packages", "plugins", "scripts"];
 const PACKAGE_NAME_PATTERN = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
-const SCAN_SKIPPED = new Set(["web", "node_modules", "dist"]);
+const SCAN_SKIPPED = new Set(["node_modules", "dist"]);
 const SCANNED_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".mjs", ".js", ".css"]);
 const IMPORT_PATTERN = /\b(?:from|import|require(?:\.resolve)?)\s*\(?\s*["']([^"'\n]+)["']/g;
 
@@ -114,10 +119,18 @@ const packageNameOf = (specifier: string): string | undefined => {
   return PACKAGE_NAME_PATTERN.test(name) ? name : undefined;
 };
 
-/** Die Pakete, die der ausgeführte Teil des Pakets wirklich importiert, plus die zur Laufzeit verlinkten Bibliotheken. */
+const declaredWebDependencies = (packageDirectory: string): readonly string[] => {
+  const file = path.join(packageDirectory, "apps/web/package.json");
+  const declared = (JSON.parse(readFileSync(file, "utf8")) as { dependencies?: Record<string, string> }).dependencies ?? {};
+  return Object.keys(declared);
+};
+
+/** Die Pakete, die der ausgeführte Teil des Pakets wirklich importiert, plus die zur Laufzeit verlinkten Bibliotheken
+ * und die, die das Web des Hosts den web-Hälften fremder Plugins anbietet. */
 export const requiredPackages = (packageDirectory: string): ReadonlyMap<string, string> => {
   const sources = new Map<string, string>();
   for (const name of runtimeLibraries) sources.set(name, "plugins/ragents.actor-programs (verlinkt zur Laufzeit)");
+  for (const name of declaredWebDependencies(packageDirectory)) sources.set(name, "apps/web/package.json (für die web-Hälften der Plugins)");
   for (const folder of scanRoots(packageDirectory)) {
     for (const file of scannedFiles(folder)) {
       const content = readFileSync(file, "utf8");

package/scripts/package/publish-package.ts

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { compareVersions, nextVersion, readVersion, versionLine, writeHostPackageVersion, writeVersion } from "../publish-version.ts";
 import { buildPackage, PACKAGE_FOLDER, PACKAGE_NAME } from "./build-package.ts";
 
 const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
@@ -8,7 +9,8 @@ const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url))
 const usage = `Verwendung: pnpm publish:package [--dry-run]
 Baut das Paket ${PACKAGE_NAME} und veröffentlicht es auf npm. Der Token kommt aus der
 Umgebungsvariable npm_key. --dry-run reicht npm den Probelauf durch und veröffentlicht nichts.
-Die Fassung steht in der package.json der Wurzel und wird von Hand erhöht.`;
+Die Fassung steht in der package.json der Wurzel; das Skript zählt vor dem Bauen die letzte Stelle
+über die zuletzt veröffentlichte hoch, im Probelauf nur in der Ausgabe.`;
 
 const REGISTRY_TOKEN_KEY = "npm_config_//registry.npmjs.org/:_authToken";
 
@@ -52,6 +54,10 @@ export const publishedVersions = (name: string, npm: NpmRunner): readonly string
   return typeof parsed === "string" ? [parsed] : parsed;
 };
 
+/** Die höchste Fassung, die auf npm liegt; ein dort unbekanntes Paket hat keine. */
+export const latestPublishedVersion = (npm: NpmRunner = runNpm, name = PACKAGE_NAME): string | undefined =>
+  [...publishedVersions(name, npm)].sort(compareVersions).at(-1);
+
 export interface PublishPlan {
   readonly name: string;
   readonly version: string;
@@ -59,13 +65,13 @@ export interface PublishPlan {
 }
 
 /** Was vor einem Publish stimmen muss: das gebaute Manifest und eine Fassung, die es auf npm noch nicht gibt. */
-export const publishPlan = (manifest: Record<string, unknown>, published: readonly string[]): PublishPlan => {
-  const { name, version } = manifest as { name?: unknown; version?: unknown };
+export const publishPlan = (manifest: Record<string, unknown>, published: readonly string[], version: string): PublishPlan => {
+  const { name } = manifest as { name?: unknown };
   const access = (manifest.publishConfig as { access?: unknown } | undefined)?.access;
   const hostVersion = (manifest.ragents as { hostVersion?: unknown } | undefined)?.hostVersion;
   if (name !== PACKAGE_NAME) throw new Error(`Das gebaute Paket heißt ${String(name)}, veröffentlicht wird ${PACKAGE_NAME}`);
   if (access !== "public") throw new Error(`${PACKAGE_NAME} hat einen Scope und braucht publishConfig.access "public", nicht ${JSON.stringify(access)}`);
-  if (typeof version !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?$/.test(version)) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?$/.test(version)) {
     throw new Error(`Die Fassung ${JSON.stringify(version)} ist keine Fassung; sie steht als version in der package.json der Wurzel`);
   }
   if (typeof hostVersion !== "string" || !/^[0-9a-f]{40}$/.test(hostVersion)) {
@@ -113,8 +119,17 @@ const main = async (): Promise<void> => {
   if (unknown.length) throw new Error(`Unbekanntes Argument: ${unknown.join(" ")}\n${usage}`);
   const token = process.env.npm_key;
   if (!token) throw new Error(`npm_key fehlt: der npm-Token mit Schreibrecht auf ${PACKAGE_NAME}.\n${usage}`);
+  const manifestFile = path.join(repositoryRoot, "package.json");
+  const published = publishedVersions(PACKAGE_NAME, runNpm);
+  const next = nextVersion(readVersion(manifestFile), published);
+  console.log(versionLine(next));
+  const extensionManifestFile = path.join(repositoryRoot, "apps", "vscode", "package.json");
+  if (!dryRun) {
+    writeVersion(manifestFile, next.version);
+    writeHostPackageVersion(extensionManifestFile, next.version);
+  }
   const built = await buildPackage(path.join(repositoryRoot, "dist", PACKAGE_FOLDER));
-  const plan = publishPlan(built.manifest, publishedVersions(PACKAGE_NAME, runNpm));
+  const plan = publishPlan(built.manifest, published, next.version);
   console.log(`== ${plan.name}@${plan.version} aus Host ${plan.hostVersion.slice(0, 12)}, ${built.fileCount} Dateien, ${(built.byteSize / 1024 / 1024).toFixed(1)} MB`);
   publishDirectory({ directory: built.directory, version: plan.version, token, dryRun, npm: runNpm, log: (line) => console.log(line) });
 };

package/scripts/package/ragents.mjs

@@ -20,12 +20,13 @@ export const commands = {
 
 const usage = `Verwendung: ragents <befehl> [argumente]
 
-  run <ordner> "<auftrag>"         Host starten, Run auf dem Ordner anlegen und auf das Ende warten
+  run <ordner> "<auftrag>"         Host ohne Oberfläche starten, Run anlegen und auf das Ende warten
   send <run> "<text>"              Folgeauftrag im selben Run
   journal <run> [--tools]          Verlauf eines Runs lesen
   stop <run> | stop --host         laufenden Turn abbrechen oder den gemerkten Host beenden
   connect <server-url>             Client-Profil holen und den lokalen Server damit starten
-  start <profil>                   ein Profil des Pakets oder einen geholten Stand starten
+  start <profil|pfad>              ein Profil des Pakets, eine eigene Profildatei oder einen
+                                   geholten Stand starten; baut die Oberfläche bei Bedarf
   provision [<profil>|--workspace] Werkzeuge der Plugins holen
   workspace-client <server-url>    diesen Rechner als Arbeitsplatz anmelden
 `;

package/scripts/remote/connect.ts

@@ -8,6 +8,8 @@ import { fileURLToPath } from "node:url";
 import { extract as extractTar } from "tar";
 import { ragentsDataRoot } from "../../apps/server/src/data-directory.ts";
 import { hostRoot, readHostPackage, readHostVersion } from "../../apps/server/src/host-version.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";
 
@@ -226,24 +228,33 @@ 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;
 }
 
-/** Provisioniert die Werkzeuge des Profils und startet den Server damit. */
+/** Provisioniert die Werkzeuge des Profils, baut sein Web falls nötig und startet den Server damit. */
 export const startProfile = async (started: StartedProfile): Promise<number> => {
+  const dataDirectory = started.dataDirectory ?? (await readProfileTarget(started.profile, started.profileFile)).dataDirectory;
   const env: NodeJS.ProcessEnv = {
     ...process.env,
     PRODUCT_PROFILE: started.profile,
     PRODUCT_PROFILE_FILE: started.profileFile,
-    ...(started.dataDirectory ? { DATA_DIR: started.dataDirectory } : {}),
-    ...(started.webDirectory ? { WEB_DIST_DIR: started.webDirectory } : {}),
+    DATA_DIR: dataDirectory,
   };
   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}`);
-  console.log(started.webDirectory ? `== Server starten (Web ${started.webDirectory})` : "== Server starten");
-  return run(hostScript("apps/server/src/main.ts", started.port !== undefined ? ["--port", String(started.port)] : []), env);
+  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})`);
+  return run(hostScript("apps/server/src/main.ts", started.port !== undefined ? ["--port", String(started.port)] : []), { ...env, WEB_DIST_DIR: webDirectory });
 };
 
 /** Startet einen Stand, den connect geholt hat, mit dem Web aus dem Cache. */

package/scripts/remote/start.ts

@@ -1,3 +1,5 @@
+// Der Hook löst @aicontainer/* 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 { statSync } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import path from "node:path";
@@ -5,14 +7,16 @@ import { fileURLToPath } from "node:url";
 import { profileFileName } from "../../apps/server/src/config-file.ts";
 import { ragentsDataRoot } from "../../apps/server/src/data-directory.ts";
 import { hostRoot } from "../../apps/server/src/host-version.ts";
+import { callerDirectory } from "../agent/agent-cli.ts";
 import { startCached, startProfile, type CachedProfile } from "./connect.ts";
 
-const usage = (): string => `Verwendung: ragents start <profil> [--port <n>]
-Startet ein Profil dieses Hosts (core, developer) oder einen Stand, den ragents connect schon
-geholt hat, ohne den Server zu fragen. Ein geholter Stand bringt sein Web aus demselben Cache
-mit. Ohne Argument nennt der Befehl die Profile im Cache.`;
+const usage = (): string => `Verwendung: ragents start <profil|pfad> [--port <n>]
+Startet ein Profil dieses Hosts (core, developer), 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.`;
 
-export const parseArguments = (argv: readonly string[]): { profile: string; port: number | undefined } => {
+export const parseArguments = (argv: readonly string[]): { selection: string; port: number | undefined } => {
   let profile: string | undefined;
   let port: number | undefined;
   for (let index = 0; index < argv.length; index += 1) {
@@ -28,7 +32,7 @@ export const parseArguments = (argv: readonly string[]): { profile: string; port
     profile = argument;
   }
   if (!profile) throw new Error(`Der Profilname fehlt.\n${usage()}`);
-  return { profile, port };
+  return { selection: profile, port };
 };
 
 const directories = async (folder: string): Promise<readonly string[]> =>
@@ -60,22 +64,36 @@ export const selectCachedProfile = (cached: readonly CachedProfile[], profile: s
     + "nimm ragents connect <server-url>.");
 };
 
-/** Ein Profil, das neben dem Host liegt: im Checkout die Datei im Repo, im Paket die mitgelieferte. */
-export const hostProfileFile = (profile: string, root = hostRoot()): string | undefined => {
-  const file = path.join(root, profileFileName(profile));
-  return statSync(file, { throwIfNoEntry: false })?.isFile() ? file : undefined;
+const PROFILE_FILE = /^ragents\.config\.([a-z0-9]+(?:-[a-z0-9]+)*)\.ts$/;
+
+export interface LocalProfile {
+  readonly profile: string;
+  readonly profileFile: string;
+}
+
+/** Ein Profil ist ein Name neben dem Host (Checkout wie Paket) oder ein Pfad zu einer ragents.config.<profil>.ts an beliebiger Stelle. */
+export const localProfile = (selection: string, root = hostRoot(), caller = callerDirectory()): LocalProfile | undefined => {
+  if (!selection.includes("/") && !selection.endsWith(".ts")) {
+    const file = path.join(root, profileFileName(selection));
+    return statSync(file, { throwIfNoEntry: false })?.isFile() ? { profile: selection, profileFile: file } : undefined;
+  }
+  const profileFile = path.resolve(caller, selection);
+  const match = PROFILE_FILE.exec(path.basename(profileFile));
+  if (!match) throw new Error(`Eine Profildatei heißt ragents.config.<profil>.ts, nicht ${path.basename(profileFile)}`);
+  if (!statSync(profileFile, { throwIfNoEntry: false })?.isFile()) throw new Error(`Die Profildatei fehlt: ${profileFile}`);
+  return { profile: match[1]!, profileFile };
 };
 
 const main = async (): Promise<void> => {
   const arguments_ = parseArguments(process.argv.slice(2));
-  const own = hostProfileFile(arguments_.profile);
+  const own = localProfile(arguments_.selection);
   if (own) {
-    console.log(`== Profil ${arguments_.profile} dieses Hosts`);
-    console.log(`== Profildatei ${own}`);
-    process.exitCode = await startProfile({ profile: arguments_.profile, profileFile: own, port: arguments_.port });
+    console.log(`== Profil ${own.profile}`);
+    console.log(`== Profildatei ${own.profileFile}`);
+    process.exitCode = await startProfile({ profile: own.profile, profileFile: own.profileFile, port: arguments_.port });
     return;
   }
-  const cached = selectCachedProfile(await cachedProfiles(ragentsDataRoot()), arguments_.profile);
+  const cached = selectCachedProfile(await cachedProfiles(ragentsDataRoot()), arguments_.selection);
   console.log(`== Profil ${cached.profile} vom Server ${cached.serverUrl}, Stand ${cached.version.slice(0, 12)} (aus dem Cache)`);
   console.log(`== Profildatei ${cached.profileFile}`);
   console.log(`== Daten ${cached.dataDirectory}`);