@schlenkr/ragents 0.1.17 → 0.1.19

package/scripts/package/ragents.mjs

@@ -3,6 +3,7 @@ import { spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { terminateProcessTree, watchOwnerLifetime } from "../../packages/workspace-executor/src/owner-lifetime.mjs";
 import { ensureHostLinks } from "./host-links.mjs";
 
 const AGENT_CLI = "scripts/agent/agent-cli.ts";
@@ -55,14 +56,39 @@ const main = () => {
   }
   ensureHostLinks(root);
   const passed = script === AGENT_CLI ? [command, ...rest] : rest;
+  const workspace = command === "workspace-client";
+  const detached = rest.includes("--detached");
   const child = spawn(process.execPath, ["--import", "tsx", path.join(root, script), ...passed], {
     cwd: path.join(root, "apps/server"),
-    env: { ...process.env, RAGENTS_CWD: process.cwd() },
-    stdio: "inherit",
+    env: { ...process.env, RAGENTS_CWD: process.cwd(), ...(workspace ? { RAGENTS_WORKSPACE_OWNER_PID: String(process.ppid) } : {}) },
+    stdio: workspace ? ["ignore", "inherit", "inherit", "ipc"] : "inherit",
+    detached: workspace && process.platform !== "win32",
   });
+  if (workspace) {
+    let stopReason;
+    let deadline;
+    const requestStop = () => {
+      if (child.connected && stopReason) child.send({ type: "workspace-stop", reason: stopReason }, () => undefined);
+    };
+    const release = watchOwnerLifetime({ detached, onStop: (reason) => {
+      stopReason = reason;
+      requestStop();
+      deadline = setTimeout(() => { if (child.pid) terminateProcessTree(child.pid); }, 20_000);
+    } });
+    child.on("message", (message) => { if (message?.type === "workspace-ready") requestStop(); });
+    child.once("exit", () => {
+      release();
+      clearTimeout(deadline);
+      if (process.platform !== "win32" && child.pid) {
+        try { process.kill(-child.pid, "SIGKILL"); } catch {}
+      }
+    });
+  }
   const forward = (signal) => () => child.kill(signal);
-  process.on("SIGINT", forward("SIGINT"));
-  process.on("SIGTERM", forward("SIGTERM"));
+  if (!workspace) {
+    process.on("SIGINT", forward("SIGINT"));
+    process.on("SIGTERM", forward("SIGTERM"));
+  }
   child.once("error", (error) => {
     console.error(`ragents ${command} could not be started: ${error.message}`);
     process.exit(1);

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

@@ -3,25 +3,28 @@ import { statSync } from "node:fs";
 import { hostname } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveBundledTools } from "../../packages/workspace-executor/src/bundled-tools.ts";
+import { exitWorkspaceProcess, watchOwnerLifetime } from "../../packages/workspace-executor/src/owner-lifetime.mjs";
+import { isCheckout } from "../../apps/server/src/host-web.ts";
 import { hostRoot } from "../../apps/server/src/host-version.ts";
 import { callerDirectory } from "../../apps/server/src/profile-target.ts";
 import { provisionWorkspace } from "../../apps/server/src/profile/provisioning.ts";
 import { workspaceClientTransport } from "../../plugins/ragents.workspace/client/transport.ts";
 import { WorkspaceClient, workstationRunsDirectory } from "../../plugins/ragents.workspace/client/workspace-client.ts";
 
-const usage = (): string => `Usage: [RAGENTS_TOKEN=<token>] pnpm workspace-client <server-url> [folder ...] [--id <id>] [--label <name>]
-Registers the folders as a workspace with the server and executes its tasks with the executor
-of this machine - the same as the VS Code extension does, just without VS Code. Without folders
-the current directory applies. Every tool call appears as one line on stdout.
-What the server's plugins contribute to the executor, such as language servers, the workspace loads
-at registration from this host's bundles; startup fetches their tools onto this machine
-(the same as pnpm provision --workspace). On Windows
-RAGENTS_BASH names the bash.exe that RAgents brings along (from the Windows build of the VS Code
-extension); without it the bash tool fails. RAGENTS_RG names an rg whose folder the bash has at the
-front of its PATH, such as the one from the extension; if not given, one in the PATH applies. The
-script runs until it is ended with Ctrl-C.`;
+const usage = (): string => `Usage: ragents workspace-client <server-url> [folder ...] [--id <id>] [--label <name>] [--detached]
+Registers the folders as a workspace and executes tasks with the same tools as VS Code.
+Without folders the current directory applies. Tools are provisioned before registration.
+The npm package includes ripgrep and, on Windows, Bash. In a checkout run pnpm bundle:rg
+(and pnpm bundle:bash on Windows) first.
+Set RAGENTS_TOKEN for an existing session or RAGENTS_USER and RAGENTS_PASSWORD for automatic
+sign-in and renewal. Credentials belong only in the environment.
+By default closing stdin, the terminal, or the owning process ends the client and its children.
+--detached explicitly opts out of terminal and parent ownership for nohup or a service manager;
+SIGINT and SIGTERM still stop it. It does not daemonize the process.`;
 
 export interface WorkspaceClientArguments {
+  readonly detached: boolean;
   readonly serverUrl: string;
   readonly folders: readonly string[];
   readonly id: string | undefined;
@@ -30,11 +33,13 @@ export interface WorkspaceClientArguments {
 
 export const parseArguments = (argv: readonly string[]): WorkspaceClientArguments => {
   const folders: string[] = [];
+  let detached = false;
   let serverUrl: string | undefined;
   let id: string | undefined;
   let label: string | undefined;
   for (let index = 0; index < argv.length; index += 1) {
     const argument = argv[index]!;
+    if (argument === "--detached") { detached = true; continue; }
     if (argument === "--id" || argument === "--label") {
       const value = argv[index + 1];
       if (!value || value.startsWith("-")) throw new Error(`${argument} needs a value.\n${usage()}`);
@@ -49,7 +54,7 @@ export const parseArguments = (argv: readonly string[]): WorkspaceClientArgument
   }
   if (!serverUrl) throw new Error(`The server address is missing.\n${usage()}`);
   if (id !== undefined && !/^[A-Za-z0-9_-]{8,64}$/.test(id)) throw new Error("--id needs 8 to 64 characters from A-Z, a-z, 0-9, _ and -.");
-  return { serverUrl, folders, id, label };
+  return { serverUrl, folders, id, label, detached };
 };
 
 /** A stable id per machine and folder set, so the server recognizes the same workspace again. */
@@ -67,6 +72,27 @@ export const resolvedFolders = (folders: readonly string[], caller = callerDirec
 
 const main = async (): Promise<void> => {
   const parsed = parseArguments(process.argv.slice(2));
+  let stopping: Promise<void> | undefined;
+  const stop = (code: number, reason: string): Promise<void> => stopping ??= (async () => {
+    console.log(`== Stopping workspace: ${reason}`);
+    const force = setTimeout(() => exitWorkspaceProcess(code || 1), 15_000);
+    try {
+      await client.unregister();
+      transport.rpc.close();
+    } finally {
+      clearTimeout(force);
+      exitWorkspaceProcess(code);
+    }
+  })();
+  const releaseOwner = watchOwnerLifetime({
+    detached: parsed.detached,
+    parents: [process.ppid, ...process.env.RAGENTS_WORKSPACE_OWNER_PID ? [Number(process.env.RAGENTS_WORKSPACE_OWNER_PID)] : []],
+    stdin: process.send ? null : process.stdin,
+    onStop: (reason) => { void stop(0, reason); },
+  });
+  process.on("message", (message: unknown) => {
+    if (typeof message === "object" && message !== null && (message as { type?: string }).type === "workspace-stop") void stop(0, "owner stopped");
+  });
   const folders = resolvedFolders(parsed.folders);
   const host = hostname();
   const identity = {
@@ -78,46 +104,37 @@ const main = async (): Promise<void> => {
     runsDirectory: workstationRunsDirectory(),
   };
   const transport = workspaceClientTransport(parsed.serverUrl, process.env.RAGENTS_TOKEN);
+  const root = hostRoot();
+  const tools = resolveBundledTools({ root: isCheckout(root) ? path.join(root, "apps/vscode") : root, distribution: isCheckout(root) ? "extension" : "package" });
   const client = new WorkspaceClient(transport, identity, {
     hostRoot,
-    bash: process.env.RAGENTS_BASH || undefined,
-    rg: process.env.RAGENTS_RG || undefined,
+    ...tools,
     onExecuted: ({ runId, operation, durationMs, error }) =>
       console.log(`== ${runId.slice(0, 8)} ${operation} ${durationMs} ms ${error ?? "ok"}`),
   });
   console.log(`== Workspace ${identity.label} (${identity.id})`);
   for (const folder of folders) console.log(`== Folder ${folder}`);
+  process.send?.({ type: "workspace-ready" });
   console.log("== Provisioning tools");
   await provisionWorkspace((line) => console.log(line));
   console.log(`== Server ${parsed.serverUrl}`);
-  client.onChange(() => {
-    const status = client.status;
+  const workspace = client;
+  workspace.onChange(() => {
+    const status = workspace.status;
     console.log(status.kind === "failed" ? `== Registration failed: ${status.message}` : `== State ${status.kind}`);
+    if (status.kind === "failed" && !stopping && (status.mismatch || transport.rpc.status.kind === "unauthorized")) void stop(1, "registration or sign-in failed");
   });
-  await client.register();
-  if (client.status.kind !== "registered") {
-    process.exitCode = 1;
-    transport.rpc.close();
-    return;
-  }
+  await workspace.register();
+  if (stopping) return;
+  if (workspace.status.kind !== "registered") return stop(1, "registration failed");
   console.log("== Registered; Ctrl-C ends the workspace");
-  await new Promise<void>((finish) => {
-    const stop = () => {
-      process.off("SIGINT", stop);
-      process.off("SIGTERM", stop);
-      finish();
-    };
-    process.on("SIGINT", stop);
-    process.on("SIGTERM", stop);
-  });
-  await client.unregister();
-  transport.rpc.close();
+  process.once("exit", releaseOwner);
 };
 
 const moduleUrl: string | undefined = import.meta.url;
 if (moduleUrl && process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(moduleUrl)) {
   main().catch((error: unknown) => {
     console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
+    exitWorkspaceProcess(1);
   });
 }

package/scripts/package/build-package.ts

@@ -1,319 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { copyFile, mkdir, readdir, rm, writeFile } from "node:fs/promises";
-import { builtinModules } from "node:module";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { readHostVersion, readPackageVersion } from "../../apps/server/src/host-version.ts";
-import { hostWebDirectory, hostWebProblem, isCheckout } from "../../apps/server/src/host-web.ts";
-import { runtimeLibraries } from "../../apps/server/src/plugin-support/actor-programs/runtime-libraries.ts";
-import { assertBundleRevision, readBundleManifest, sourceRevisionOf } from "../../apps/server/src/profile/bundle-manifest.ts";
-import { builtInPluginFolders } from "../plugin/build-builtin-plugins.ts";
-
-export const PACKAGE_NAME = "@schlenkr/ragents";
-/** The folder under dist/; the package name has a scope, the folder name stays plain. */
-export const PACKAGE_FOLDER = "ragents";
-
-const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
-
-const SKIPPED_FOLDERS = new Set(["node_modules", "dist", ".git"]);
-const SKIPPED_FILES = new Set([".DS_Store"]);
-
-/** The subcommands' tests run in the checkout; in the package only their test material would be visible. */
-const SKIPPED_IN_PACKAGE = /^scripts\/.*\.test\.tsx?$/;
-
-const packagePath = (packageRoot: string, file: string): string => path.relative(packageRoot, file).split(path.sep).join("/");
-
-/** The repository's neutral profiles; ragents start runs them from the package as from the checkout. */
-export const PACKAGED_PROFILES = ["core", "developer", "showcase"] as const;
-
-export const PACKAGE_LICENSE = "PolyForm-Shield-1.0.0";
-export const PACKAGE_AUTHOR = "Ronald Schlenker";
-export const REPOSITORY_URL = "https://github.com/SchlenkR/RAgents";
-export const PACKAGE_KEYWORDS = ["agents", "llm", "actors", "typescript", "csharp", "fsharp", "vscode"] as const;
-
-/** License and listing README are at the root of the package, their sources elsewhere in the repository. */
-export const PACKAGE_ROOT_FILES: readonly (readonly [string, string])[] = [
-  ["LICENSE", "LICENSE"],
-  ["scripts/package/README.md", "README.md"],
-];
-
-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);
-
-/** What the host loads at runtime: server, engine, the built web, the built-in bundles, plugin sources for contracts and the build tool, profiles and the scripts behind the subcommands; plus the types from declarationFolders. */
-export const packageContents = (root = repositoryRoot): readonly string[] => [
-  "apps/server/package.json",
-  "apps/server/tsconfig.json",
-  "apps/server/tsconfig.plugin.json",
-  "apps/server/src",
-  "apps/web/package.json",
-  "apps/web/tsconfig.json",
-  "apps/web/tsconfig.plugin.json",
-  "apps/web/src",
-  "apps/web/dist",
-  ...readdirSync(path.join(root, "packages"), { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .flatMap((entry) => [`packages/${entry.name}/package.json`, `packages/${entry.name}/src`]),
-  "bundles",
-  "plugins",
-  ...PACKAGED_PROFILES.map((profile) => `ragents.config.${profile}.ts`),
-  "scripts/agent",
-  "scripts/package",
-  "scripts/plugin",
-  "scripts/provision",
-  "scripts/remote",
-  "scripts/workspace-client",
-];
-
-/** The forked agent runtime runs from its sources, its types exist only built; the build tool checks third-party plugins against them. */
-export const declarationFolders = (root = repositoryRoot): readonly string[] =>
-  readdirSync(path.join(root, "packages"), { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .filter((entry) => {
-      const manifest = path.join(root, "packages", entry.name, "package.json");
-      const types = statSync(manifest, { throwIfNoEntry: false })?.isFile() ? (JSON.parse(readFileSync(manifest, "utf8")) as { types?: unknown }).types : undefined;
-      return typeof types === "string" && types.startsWith("./dist/");
-    })
-    .map((entry) => `packages/${entry.name}/dist`);
-
-/** What the host executes, bundles into a mini-app or reads when building a plugin. */
-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(["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;
-/** An executor contribution resolves packages from the host at runtime; the package must carry them too. */
-const HOST_PACKAGE_PATTERN = /\bhostPackageFile\([^,()]*,\s*["']([^"'\n]+)["']/g;
-
-const files = async (folder: string, skippedFolders: ReadonlySet<string> = SKIPPED_FOLDERS): Promise<readonly string[]> => {
-  const found: string[] = [];
-  for (const entry of (await readdir(folder, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name, "en"))) {
-    if (entry.isDirectory()) {
-      if (!skippedFolders.has(entry.name)) found.push(...await files(path.join(folder, entry.name), skippedFolders));
-    } else if (entry.isFile() && !SKIPPED_FILES.has(entry.name)) {
-      found.push(path.join(folder, entry.name));
-    }
-  }
-  return found;
-};
-
-const copyTo = async (source: string, target: string, packageRoot: string, skippedFolders?: ReadonlySet<string>): Promise<readonly string[]> => {
-  if (statSync(source).isFile()) {
-    if (skippedInPackage(packagePath(packageRoot, target))) return [];
-    await mkdir(path.dirname(target), { recursive: true });
-    await copyFile(source, target);
-    return [target];
-  }
-  const copied: string[] = [];
-  for (const file of await files(source, skippedFolders)) {
-    const destination = path.join(target, path.relative(source, file));
-    if (skippedInPackage(packagePath(packageRoot, destination))) continue;
-    await mkdir(path.dirname(destination), { recursive: true });
-    await copyFile(file, destination);
-    copied.push(destination);
-  }
-  return copied;
-};
-
-const scanRoots = (root: string): readonly string[] => SCANNED.map((entry) => path.join(root, entry));
-
-const scannedFiles = (folder: string): readonly string[] => {
-  if (!statSync(folder, { throwIfNoEntry: false })?.isDirectory()) return [];
-  return readdirSync(folder, { withFileTypes: true }).flatMap((entry) => {
-    const absolute = path.join(folder, entry.name);
-    if (entry.isDirectory()) return SCAN_SKIPPED.has(entry.name) ? [] : scannedFiles(absolute);
-    return entry.isFile() && SCANNED_EXTENSIONS.has(path.extname(entry.name)) ? [absolute] : [];
-  });
-};
-
-const packageNameOf = (specifier: string): string | undefined => {
-  if (/^(\.{1,2}\/|\/|node:|data:|@ragents\/|virtual:)/.test(specifier) || specifier === "vscode") return undefined;
-  const parts = specifier.split("/");
-  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0]!;
-  if (builtinModules.includes(name)) return undefined;
-  return PACKAGE_NAME_PATTERN.test(name) ? name : undefined;
-};
-
-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);
-};
-
-/** The packages that the executed part of the package actually imports, plus the libraries linked at runtime
- * and those that the host's web offers to the web halves of third-party plugins. */
-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 (linked at runtime)");
-  for (const name of declaredWebDependencies(packageDirectory)) sources.set(name, "apps/web/package.json (for the web halves of the plugins)");
-  for (const folder of scanRoots(packageDirectory)) {
-    for (const file of scannedFiles(folder)) {
-      const content = readFileSync(file, "utf8");
-      for (const match of [...content.matchAll(IMPORT_PATTERN), ...content.matchAll(HOST_PACKAGE_PATTERN)]) {
-        const name = packageNameOf(match[1]!);
-        if (name && !sources.has(name)) sources.set(name, path.relative(packageDirectory, file));
-      }
-    }
-  }
-  return new Map([...sources].sort(([left], [right]) => left.localeCompare(right, "en")));
-};
-
-const compareVersions = (left: string, right: string): number => {
-  const parts = (value: string) => value.split(/[.+-]/).map((part) => Number.isInteger(Number(part)) ? Number(part) : part);
-  const [first, second] = [parts(left), parts(right)];
-  for (let index = 0; index < Math.max(first.length, second.length); index += 1) {
-    const [one, other] = [first[index] ?? 0, second[index] ?? 0];
-    if (one === other) continue;
-    return typeof one === "number" && typeof other === "number" ? one - other : String(one).localeCompare(String(other), "en");
-  }
-  return 0;
-};
-
-const anchors = (root: string): readonly string[] => [
-  path.join(root, "package.json"),
-  ...["apps", "packages"].flatMap((group) => readdirSync(path.join(root, group), { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => path.join(root, group, entry.name, "package.json"))
-    .filter((file) => statSync(file, { throwIfNoEntry: false })?.isFile() === true)),
-];
-
-/** The versions this checkout has installed for a package; the newest goes into the package. */
-export const installedVersions = (name: string, root = repositoryRoot): readonly string[] => {
-  const found = new Set<string>();
-  for (const anchor of anchors(root)) {
-    for (let directory = path.dirname(anchor); ; directory = path.dirname(directory)) {
-      const file = path.join(directory, "node_modules", ...name.split("/"), "package.json");
-      if (statSync(file, { throwIfNoEntry: false })?.isFile()) {
-        found.add((JSON.parse(readFileSync(file, "utf8")) as { version: string }).version);
-        break;
-      }
-      if (path.dirname(directory) === directory) break;
-    }
-  }
-  const versions = [...found].sort(compareVersions);
-  if (versions.length === 0) throw new Error(`The package ${name} is not installed in this checkout; without a version it cannot go into the package`);
-  return versions;
-};
-
-export interface BuiltPackage {
-  readonly directory: string;
-  readonly manifest: Record<string, unknown>;
-  readonly fileCount: number;
-  readonly byteSize: number;
-  readonly flattened: readonly string[];
-}
-
-/** The package ships the web prebuilt; it must be built and match its sources. */
-const assertHostWeb = (root: string): void => {
-  const problem = hostWebProblem(hostWebDirectory(root), root, isCheckout(root));
-  if (problem) throw new Error(`${problem}; run pnpm build:web first`);
-};
-
-/** Every built-in plugin must exist as a bundle and match its sources, otherwise the package starts no profile. */
-const assertBuiltInBundles = (root: string): void => {
-  for (const folder of builtInPluginFolders(path.join(root, "plugins"))) {
-    const bundle = path.join(root, "bundles", path.basename(folder));
-    if (!statSync(bundle, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`The bundle ${bundle} is missing; run pnpm build:plugins first`);
-    if (readBundleManifest(bundle).sourceRevision !== sourceRevisionOf(folder)) throw new Error(`The bundle ${bundle} no longer matches ${folder}; run pnpm build:plugins first`);
-  }
-};
-
-const copyDeclarations = async (root: string, target: string): Promise<readonly string[]> => {
-  const copied: string[] = [];
-  for (const folder of declarationFolders(root)) {
-    if (!statSync(path.join(root, folder), { throwIfNoEntry: false })?.isDirectory()) throw new Error(`${folder} is missing; run pnpm build:agent first`);
-    for (const file of (await files(path.join(root, folder))).filter((name) => name.endsWith(".d.ts"))) {
-      const destination = path.join(target, path.relative(root, file));
-      await mkdir(path.dirname(destination), { recursive: true });
-      await copyFile(file, destination);
-      copied.push(destination);
-    }
-  }
-  return copied;
-};
-
-export const buildPackage = async (target: string, root = repositoryRoot): Promise<BuiltPackage> => {
-  assertBuiltInBundles(root);
-  assertHostWeb(root);
-  await rm(target, { recursive: true, force: true });
-  await mkdir(target, { recursive: true });
-  let fileCount = 0;
-  let byteSize = 0;
-  for (const entry of packageContents(root)) {
-    // A bundle is fully built and goes into the package completely, including an asset folder named dist.
-    const copied = await copyTo(path.join(root, entry), path.join(target, entry), target, entry === "bundles" ? new Set() : undefined);
-    fileCount += copied.length;
-    for (const file of copied) byteSize += statSync(file).size;
-  }
-  for (const folder of builtInPluginFolders(path.join(root, "plugins"))) {
-    const bundle = path.join(target, "bundles", path.basename(folder));
-    assertBundleRevision(bundle, readBundleManifest(bundle));
-  }
-  for (const file of await copyDeclarations(root, target)) {
-    fileCount += 1;
-    byteSize += statSync(file).size;
-  }
-  for (const [source, packaged] of PACKAGE_ROOT_FILES) {
-    const destination = path.join(target, packaged);
-    await mkdir(path.dirname(destination), { recursive: true });
-    await copyFile(path.join(root, source), destination);
-    fileCount += 1;
-    byteSize += statSync(destination).size;
-  }
-  const flattened: string[] = [];
-  const dependencies: Record<string, string> = {};
-  for (const [name] of requiredPackages(target)) {
-    const versions = installedVersions(name, root);
-    if (versions.length > 1) flattened.push(`${name}: ${versions.join(", ")} -> ${versions.at(-1)!}`);
-    dependencies[name] = versions.at(-1)!;
-  }
-  const manifest = {
-    name: PACKAGE_NAME,
-    version: readPackageVersion(root),
-    description: "RAgents host: server, engine, plugins and tools without a source checkout",
-    keywords: [...PACKAGE_KEYWORDS],
-    homepage: "https://schlenkr.github.io/RAgents/",
-    bugs: { url: `${REPOSITORY_URL}/issues` },
-    license: PACKAGE_LICENSE,
-    author: PACKAGE_AUTHOR,
-    repository: { type: "git", url: `git+${REPOSITORY_URL}.git` },
-    type: "module",
-    bin: { ragents: "scripts/package/ragents.mjs" },
-    engines: { node: ">=22.19.0" },
-    publishConfig: { access: "public" },
-    dependencies,
-    ragents: { hostVersion: readHostVersion(root) },
-  };
-  const manifestFile = path.join(target, "package.json");
-  await writeFile(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`);
-  fileCount += 1;
-  byteSize += statSync(manifestFile).size;
-  return { directory: target, manifest, fileCount, byteSize, flattened };
-};
-
-const main = async (): Promise<void> => {
-  const pack = process.argv.includes("--pack");
-  const unknown = process.argv.slice(2).filter((argument) => argument !== "--pack");
-  if (unknown.length) throw new Error(`Unknown argument: ${unknown.join(" ")} (allowed: --pack)`);
-  const target = path.join(repositoryRoot, "dist", PACKAGE_FOLDER);
-  const built = await buildPackage(target);
-  console.log(`== Package ${PACKAGE_NAME}@${built.manifest.version as string} in ${built.directory}`);
-  console.log(`== Host version ${(built.manifest.ragents as { hostVersion: string }).hostVersion}`);
-  console.log(`== ${built.fileCount} files, ${(built.byteSize / 1024 / 1024).toFixed(1)} MB, ${Object.keys(built.manifest.dependencies as object).length} dependencies`);
-  for (const [name, version] of Object.entries(built.manifest.dependencies as Record<string, string>)) console.log(`   ${name}@${version}`);
-  for (const entry of built.flattened) console.log(`== Multiple versions flattened: ${entry}`);
-  if (!pack) return;
-  const packed = spawnSync("npm", ["pack", "--pack-destination", path.dirname(built.directory)], { cwd: built.directory, encoding: "utf8", stdio: ["ignore", "pipe", "inherit"] });
-  if (packed.status !== 0) throw new Error(`npm pack ended with code ${packed.status}`);
-  console.log(`== Archive ${path.join(path.dirname(built.directory), packed.stdout.trim().split("\n").at(-1) ?? "")}`);
-};
-
-const moduleUrl: string | undefined = import.meta.url;
-if (moduleUrl && process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(moduleUrl)) {
-  main().catch((error: unknown) => {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  });
-}