@schlenkr/ragents 0.1.0

package/scripts/remote/connect.ts

@@ -0,0 +1,265 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+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 { RpcClient } from "../../apps/web/src/rpc/client.ts";
+import { profileDistributionContracts, type ClientProfileDescription } from "../../plugins/ragents.profile-distribution/contract.ts";
+
+const usage = (): string => `Verwendung: RAGENTS_TOKEN=<token> ragents connect <server-url> [--port <n>] [--clean] [--no-start]
+Holt das Client-Profil des Servers samt gebautem Web in den lokalen Cache, prüft die Host-Version
+gegen diesen Host und startet den lokalen Server mit dem Profil. --clean entfernt ältere Stände,
+--no-start endet nach dem Holen und nennt Profildatei und Datenordner. Im Checkout heißt der
+Befehl pnpm connect.`;
+
+export interface ConnectOptions {
+  readonly serverUrl: string;
+  readonly token: string;
+  readonly dataRoot?: string;
+  /** Der Host, dessen Fassung zur verlangten Host-Version passen muss: Checkout oder Paket; Vorgabe ist dieser hier. */
+  readonly hostPath?: string;
+  readonly localVersion?: string;
+  readonly clean?: boolean;
+  readonly fetch?: typeof fetch;
+}
+
+export interface ConnectedProfile {
+  readonly description: ClientProfileDescription;
+  readonly profileFile: string;
+  readonly webDirectory: string;
+  readonly dataDirectory: string;
+  readonly cacheDirectory: string;
+  readonly downloaded: boolean;
+}
+
+/** Der Stand, den ragents start ohne den Server wieder hochfährt. */
+export interface CachedProfile {
+  readonly serverUrl: string;
+  readonly profile: string;
+  readonly version: string;
+  readonly hostVersion: string;
+  readonly profileFile: string;
+  readonly webDirectory: string;
+  readonly dataDirectory: string;
+}
+
+export const parseArguments = (argv: readonly string[]): { serverUrl: string; port: number | undefined; clean: boolean; start: boolean } => {
+  let serverUrl: string | undefined;
+  let port: number | undefined;
+  let clean = false;
+  let start = true;
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index]!;
+    if (argument === "--clean") { clean = true; continue; }
+    if (argument === "--no-start") { start = false; continue; }
+    if (argument === "--port") {
+      const value = Number(argv[index + 1]);
+      if (!Number.isInteger(value) || value < 0 || value > 65535) throw new Error(`--port braucht eine ganze Zahl von 0 bis 65535, nicht ${argv[index + 1]}`);
+      port = value;
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("-") || serverUrl) throw new Error(`Unbekanntes Argument: ${argument}\n${usage()}`);
+    serverUrl = argument;
+  }
+  if (!serverUrl) throw new Error(`Die Serveradresse fehlt.\n${usage()}`);
+  return { serverUrl, port, clean, start };
+};
+
+/** Ein Ordnername je Server: Hostname und Port, damit zwei Server nie denselben Cache teilen. */
+export const serverFolderName = (serverUrl: string): string => {
+  const parsed = new URL(serverUrl);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`Die Serveradresse braucht http oder https: ${serverUrl}`);
+  const host = parsed.hostname.toLowerCase().replace(/[^a-z0-9.-]/g, "_");
+  return parsed.port ? `${host}-${parsed.port}` : host;
+};
+
+export const remoteLayout = (dataRoot: string, serverUrl: string, profile: string) => {
+  const base = path.join(dataRoot, "remote", serverFolderName(serverUrl), profile);
+  return { base, profiles: path.join(base, "profiles"), data: path.join(base, "data"), current: path.join(base, "current.json") };
+};
+
+const describeProfile = async (options: ConnectOptions): Promise<ClientProfileDescription> => {
+  const baseUrl = options.serverUrl.replace(/\/+$/, "");
+  const fetchImpl = options.fetch ?? fetch;
+  const rpc = new RpcClient({
+    baseUrl,
+    fetch: (input, init) => fetchImpl(input, { ...init, headers: { ...init?.headers as Record<string, string> | undefined, authorization: `Bearer ${options.token}` } }),
+  });
+  try {
+    return await rpc.call(profileDistributionContracts.describe, {});
+  } catch (error) {
+    throw new Error(`Der Server ${baseUrl} liefert kein Client-Profil: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+
+const downloadArchive = async (options: ConnectOptions, description: ClientProfileDescription): Promise<Buffer> => {
+  const address = `${options.serverUrl.replace(/\/+$/, "")}${description.archivePath}`;
+  const response = await (options.fetch ?? fetch)(address, { headers: { authorization: `Bearer ${options.token}` } });
+  if (!response.ok) throw new Error(`Das Archiv ${address} kommt nicht an: ${response.status} ${(await response.text()).slice(0, 200)}`);
+  const archive = Buffer.from(await response.arrayBuffer());
+  const digest = createHash("sha256").update(archive).digest("hex");
+  if (digest !== description.version) throw new Error(`Das Archiv ${address} passt nicht zum angesagten Stand: erwartet ${description.version}, erhalten ${digest}`);
+  if (archive.byteLength !== description.size) throw new Error(`Das Archiv ${address} hat ${archive.byteLength} Byte, angesagt sind ${description.size}`);
+  return archive;
+};
+
+/** Profildatei und Archiv-Plugins sind ESM; ohne diese Marke liest Node sie im Cache als CommonJS. */
+const markAsModule = async (directory: string): Promise<void> => {
+  const file = path.join(directory, "package.json");
+  if (!existsSync(file)) {
+    await writeFile(file, `${JSON.stringify({ private: true, type: "module" }, null, 2)}\n`);
+    return;
+  }
+  const declared = (JSON.parse(await readFile(file, "utf8")) as { type?: unknown }).type;
+  if (declared !== "module") throw new Error(`Das Archiv bringt eine package.json mit type ${JSON.stringify(declared)}; RAgents-Profile sind ESM`);
+};
+
+/** Der Rat bei einer falschen Fassung hängt daran, woher der Host kommt: Paket oder Checkout. */
+const versionMismatch = (hostPath: string, localVersion: string, description: ClientProfileDescription): Error => {
+  const packaged = readHostPackage(hostPath);
+  const advice = packaged
+    ? `Hol die passende Fassung: npm install -g ${packaged.name}@${description.packageVersion} (installiert ist ${packaged.version}).`
+    : `Wechseln mit: git -C ${JSON.stringify(hostPath)} fetch && git -C ${JSON.stringify(hostPath)} checkout ${description.hostVersion}`;
+  return new Error(`Der Server verlangt den Host ${description.hostVersion}, ${packaged ? "das Paket" : "der Checkout"} ${hostPath} `
+    + `steht auf ${localVersion}.\n${advice}`);
+};
+
+/** Holt Beschreibung und Archiv, prüft Host-Version und Stand und legt den Stand im Cache ab; startet nichts. */
+export const prepareProfile = async (options: ConnectOptions): Promise<ConnectedProfile> => {
+  const description = await describeProfile(options);
+  const hostPath = options.hostPath ?? hostRoot();
+  const localVersion = options.localVersion ?? readHostVersion(hostPath);
+  if (localVersion !== description.hostVersion) throw versionMismatch(hostPath, localVersion, description);
+  const layout = remoteLayout(options.dataRoot ?? ragentsDataRoot(), options.serverUrl, description.profile);
+  const cacheDirectory = path.join(layout.profiles, description.version);
+  const profileFile = path.join(cacheDirectory, ...description.file.split("/"));
+  const webDirectory = path.join(cacheDirectory, ...description.web.split("/"));
+  let downloaded = false;
+  if (!existsSync(profileFile)) {
+    const archive = await downloadArchive(options, description);
+    const staging = `${cacheDirectory}.part`;
+    await rm(staging, { recursive: true, force: true });
+    await mkdir(staging, { recursive: true });
+    const file = path.join(staging, "profile.tar.gz");
+    await writeFile(file, archive);
+    await extractTar({ file, cwd: staging, strict: true });
+    await rm(file);
+    if (!existsSync(path.join(staging, ...description.file.split("/")))) throw new Error(`Das Archiv enthält die Profildatei ${description.file} nicht`);
+    if (!existsSync(path.join(staging, ...description.web.split("/"), "index.html"))) {
+      throw new Error(`Das Archiv enthält das gebaute Web ${description.web}/index.html nicht`);
+    }
+    await markAsModule(staging);
+    await rm(cacheDirectory, { recursive: true, force: true });
+    await rename(staging, cacheDirectory);
+    downloaded = true;
+  }
+  if (options.clean) {
+    for (const entry of await readdir(layout.profiles)) {
+      if (entry !== description.version) await rm(path.join(layout.profiles, entry), { recursive: true, force: true });
+    }
+  }
+  await mkdir(layout.data, { recursive: true });
+  const cached: CachedProfile = {
+    serverUrl: options.serverUrl,
+    profile: description.profile,
+    version: description.version,
+    hostVersion: description.hostVersion,
+    profileFile,
+    webDirectory,
+    dataDirectory: layout.data,
+  };
+  await writeFile(layout.current, `${JSON.stringify(cached, null, 2)}\n`);
+  return { description, profileFile, webDirectory, dataDirectory: layout.data, cacheDirectory, downloaded };
+};
+
+/** Startet ein Host-Skript wie der Checkout: Node mit dem tsx-Loader, Arbeitsverzeichnis apps/server, ohne pnpm. */
+export const hostScript = (script: string, args: readonly string[] = []): { file: string; args: readonly string[]; cwd: string } => ({
+  file: process.execPath,
+  args: ["--import", "tsx", path.join(hostRoot(), script), ...args],
+  cwd: path.join(hostRoot(), "apps/server"),
+});
+
+const run = (command: { file: string; args: readonly string[]; cwd: string }, env: NodeJS.ProcessEnv): Promise<number> => new Promise((resolve, reject) => {
+  const child = spawn(command.file, [...command.args], { cwd: command.cwd, env, stdio: "inherit" });
+  const forward = (signal: NodeJS.Signals) => () => child.kill(signal);
+  const onInterrupt = forward("SIGINT");
+  const onTerminate = forward("SIGTERM");
+  process.on("SIGINT", onInterrupt);
+  process.on("SIGTERM", onTerminate);
+  child.once("error", reject);
+  child.once("exit", (code, signal) => {
+    process.off("SIGINT", onInterrupt);
+    process.off("SIGTERM", onTerminate);
+    resolve(code ?? (signal ? 1 : 0));
+  });
+});
+
+const main = async (): Promise<void> => {
+  const arguments_ = parseArguments(process.argv.slice(2));
+  const token = process.env.RAGENTS_TOKEN;
+  if (!token) throw new Error(`RAGENTS_TOKEN fehlt: der persönliche Token aus dem Serverprofil.\n${usage()}`);
+  const prepared = await prepareProfile({ serverUrl: arguments_.serverUrl, token, clean: arguments_.clean });
+  const { description } = prepared;
+  console.log(`== Profil ${description.profile} vom Server ${arguments_.serverUrl}, Stand ${description.version.slice(0, 12)} (${prepared.downloaded ? "geholt" : "im Cache"})`);
+  console.log(`== Profildatei ${prepared.profileFile}`);
+  console.log(`== Daten ${prepared.dataDirectory}`);
+  if (!arguments_.start) return;
+  process.exitCode = await startCached({
+    serverUrl: arguments_.serverUrl,
+    profile: description.profile,
+    version: description.version,
+    hostVersion: description.hostVersion,
+    profileFile: prepared.profileFile,
+    webDirectory: prepared.webDirectory,
+    dataDirectory: prepared.dataDirectory,
+  }, arguments_.port);
+};
+
+export interface StartedProfile {
+  readonly profile: string;
+  readonly profileFile: string;
+  /** Nur bei einem geholten Stand gesetzt; ein Profil des Hosts nimmt die Vorgaben seiner eigenen Konfiguration. */
+  readonly dataDirectory?: string;
+  readonly webDirectory?: string;
+  readonly port: number | undefined;
+}
+
+/** Provisioniert die Werkzeuge des Profils und startet den Server damit. */
+export const startProfile = async (started: StartedProfile): Promise<number> => {
+  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 } : {}),
+  };
+  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);
+};
+
+/** Startet einen Stand, den connect geholt hat, mit dem Web aus dem Cache. */
+export const startCached = (cached: CachedProfile, port: number | undefined): Promise<number> => startProfile({
+  profile: cached.profile,
+  profileFile: cached.profileFile,
+  dataDirectory: cached.dataDirectory,
+  webDirectory: cached.webDirectory,
+  port,
+});
+
+// Im Bundle der Erweiterung ist import.meta leer; dann gibt es keinen Kommandozeileneinstieg.
+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);
+  });
+}

package/scripts/remote/start.ts

@@ -0,0 +1,91 @@
+import { statSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+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 { 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.`;
+
+export const parseArguments = (argv: readonly string[]): { profile: string; port: number | undefined } => {
+  let profile: string | undefined;
+  let port: number | undefined;
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index]!;
+    if (argument === "--port") {
+      const value = Number(argv[index + 1]);
+      if (!Number.isInteger(value) || value < 0 || value > 65535) throw new Error(`--port braucht eine ganze Zahl von 0 bis 65535, nicht ${argv[index + 1]}`);
+      port = value;
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("-") || profile) throw new Error(`Unbekanntes Argument: ${argument}\n${usage()}`);
+    profile = argument;
+  }
+  if (!profile) throw new Error(`Der Profilname fehlt.\n${usage()}`);
+  return { profile, port };
+};
+
+const directories = async (folder: string): Promise<readonly string[]> =>
+  (await readdir(folder, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+
+/** Alle Stände, die connect in diesem Datenordner hinterlassen hat. */
+export const cachedProfiles = async (dataRoot: string): Promise<readonly CachedProfile[]> => {
+  const remote = path.join(dataRoot, "remote");
+  const found: CachedProfile[] = [];
+  for (const server of await directories(remote)) {
+    for (const profile of await directories(path.join(remote, server))) {
+      const file = path.join(remote, server, profile, "current.json");
+      const content = await readFile(file, "utf8").catch(() => undefined);
+      if (content !== undefined) found.push(JSON.parse(content) as CachedProfile);
+    }
+  }
+  return found.sort((left, right) => `${left.profile} ${left.serverUrl}`.localeCompare(`${right.profile} ${right.serverUrl}`, "en"));
+};
+
+export const selectCachedProfile = (cached: readonly CachedProfile[], profile: string): CachedProfile => {
+  const matching = cached.filter((entry) => entry.profile === profile);
+  if (matching.length === 1) return matching[0]!;
+  if (matching.length === 0) {
+    const known = cached.map((entry) => `${entry.profile} (${entry.serverUrl})`);
+    throw new Error(`Das Profil ${profile} liegt nicht im Cache. `
+      + (known.length ? `Geholt sind: ${known.join(", ")}.` : "Es ist noch kein Profil geholt; hol es mit ragents connect <server-url>."));
+  }
+  throw new Error(`Das Profil ${profile} kommt von mehreren Servern (${matching.map((entry) => entry.serverUrl).join(", ")}); `
+    + "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 main = async (): Promise<void> => {
+  const arguments_ = parseArguments(process.argv.slice(2));
+  const own = hostProfileFile(arguments_.profile);
+  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 });
+    return;
+  }
+  const cached = selectCachedProfile(await cachedProfiles(ragentsDataRoot()), arguments_.profile);
+  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}`);
+  process.exitCode = await startCached(cached, arguments_.port);
+};
+
+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);
+  });
+}

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

@@ -0,0 +1,112 @@
+import { createHash } from "node:crypto";
+import { statSync } from "node:fs";
+import { hostname } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { provisionWorkspace } from "../../apps/server/src/profile/provisioning.ts";
+import { workspaceClientTransport } from "../../plugins/ragents.workspace/client/transport.ts";
+import { WorkspaceClient } from "../../plugins/ragents.workspace/client/workspace-client.ts";
+
+const usage = (): string => `Verwendung: [RAGENTS_TOKEN=<token>] pnpm workspace-client <server-url> [ordner ...] [--id <kennung>] [--label <name>]
+Meldet die Ordner als Arbeitsplatz beim Server an und führt dessen Aufträge mit dem Executor
+dieses Rechners aus - dasselbe, was die VS-Code-Erweiterung tut, nur ohne VS Code. Ohne Ordner
+gilt das aktuelle Verzeichnis. Jeder Werkzeugaufruf erscheint als eine Zeile auf stdout.
+Die Sprachserver holt der Start in den Werkzeugordner dieses Rechners (dasselbe wie
+pnpm provision --workspace); ROSLYN_LANGUAGE_SERVER und FSHARP_LANGUAGE_SERVER übersteuern ihn,
+TypeScript bringt der Executor mit. Das Skript läuft, bis es mit Strg-C beendet wird.`;
+
+export interface WorkspaceClientArguments {
+  readonly serverUrl: string;
+  readonly folders: readonly string[];
+  readonly id: string | undefined;
+  readonly label: string | undefined;
+}
+
+export const parseArguments = (argv: readonly string[]): WorkspaceClientArguments => {
+  const folders: string[] = [];
+  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 === "--id" || argument === "--label") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("-")) throw new Error(`${argument} braucht einen Wert.\n${usage()}`);
+      if (argument === "--id") id = value;
+      else label = value;
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("-")) throw new Error(`Unbekanntes Argument: ${argument}\n${usage()}`);
+    if (serverUrl === undefined) serverUrl = argument;
+    else folders.push(argument);
+  }
+  if (!serverUrl) throw new Error(`Die Serveradresse fehlt.\n${usage()}`);
+  if (id !== undefined && !/^[A-Za-z0-9_-]{8,64}$/.test(id)) throw new Error("--id braucht 8 bis 64 Zeichen aus A-Z, a-z, 0-9, _ und -.");
+  return { serverUrl, folders, id, label };
+};
+
+/** Eine stabile Kennung je Rechner und Ordnersatz, damit der Server denselben Arbeitsplatz wiedererkennt. */
+export const workspaceClientId = (host: string, folders: readonly string[]): string =>
+  `cli-${createHash("sha256").update([host, ...folders].join("\n")).digest("hex").slice(0, 32)}`;
+
+export const resolvedFolders = (folders: readonly string[], cwd: string): string[] => {
+  const resolved = (folders.length > 0 ? folders : [cwd]).map((folder) => path.resolve(cwd, folder));
+  for (const folder of resolved) {
+    if (!statSync(folder, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`Kein Verzeichnis: ${folder}`);
+  }
+  return resolved;
+};
+
+const main = async (): Promise<void> => {
+  const parsed = parseArguments(process.argv.slice(2));
+  const folders = resolvedFolders(parsed.folders, process.cwd());
+  const host = hostname();
+  const identity = {
+    id: parsed.id ?? workspaceClientId(host, folders),
+    label: parsed.label ?? `${host} (${path.basename(folders[0]!)})`,
+    hostname: host,
+    platform: process.platform,
+    folders,
+  };
+  const transport = workspaceClientTransport(parsed.serverUrl, process.env.RAGENTS_TOKEN);
+  const client = new WorkspaceClient(transport, identity, {
+    onExecuted: ({ runId, tool, durationMs, error }) =>
+      console.log(`== ${runId.slice(0, 8)} ${tool} ${durationMs} ms ${error ?? "ok"}`),
+  });
+  console.log(`== Arbeitsplatz ${identity.label} (${identity.id})`);
+  for (const folder of folders) console.log(`== Ordner ${folder}`);
+  console.log("== Werkzeuge provisionieren");
+  await provisionWorkspace((line) => console.log(line));
+  console.log(`== Server ${parsed.serverUrl}`);
+  client.onChange(() => {
+    const status = client.status;
+    console.log(status.kind === "failed" ? `== Anmeldung fehlgeschlagen: ${status.message}` : `== Zustand ${status.kind}`);
+  });
+  await client.register();
+  if (client.status.kind !== "registered") {
+    process.exitCode = 1;
+    transport.rpc.close();
+    return;
+  }
+  console.log("== Angemeldet; Strg-C beendet den Arbeitsplatz");
+  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();
+};
+
+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);
+  });
+}