@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/cli-commands.ts

@@ -16,6 +16,7 @@ export const commands: CommandEntry[] = [
 	{ name: "auth-broker", load: () => import("./commands/auth-broker").then(m => m.default) },
 	{ name: "auth-gateway", load: () => import("./commands/auth-gateway").then(m => m.default) },
 	{ name: "agents", load: () => import("./commands/agents").then(m => m.default) },
+	{ name: "bench", load: () => import("./commands/bench").then(m => m.default) },
 	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },
 	{ name: "completions", load: () => import("./commands/completions").then(m => m.default) },
 	{ name: "__complete", load: () => import("./commands/complete").then(m => m.default) },
@@ -23,20 +24,38 @@ export const commands: CommandEntry[] = [
 	{ name: "dry-balance", load: () => import("./commands/dry-balance").then(m => m.default) },
 	{ name: "gateway", load: () => import("./commands/gateway").then(m => m.default) },
 	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },
+	{ name: "gallery", load: () => import("./commands/gallery").then(m => m.default) },
 	{ name: "grievances", load: () => import("./commands/grievances").then(m => m.default) },
 	{ name: "install", load: () => import("./commands/install").then(m => m.default) },
+	{ name: "join", load: () => import("./commands/join").then(m => m.default) },
+	{ name: "models", load: () => import("./commands/models").then(m => m.default) },
 	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
 	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
+	{ name: "say", load: () => import("./commands/say").then(m => m.default) },
 	{ name: "shell", load: () => import("./commands/shell").then(m => m.default) },
 	{ name: "read", load: () => import("./commands/read").then(m => m.default) },
 	{ name: "ssh", load: () => import("./commands/ssh").then(m => m.default) },
 	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
+	{ name: "usage", load: () => import("./commands/usage").then(m => m.default) },
 	{ name: "tiny-models", load: () => import("./commands/tiny-models").then(m => m.default) },
+	{ name: "token", load: () => import("./commands/token").then(m => m.default) },
 	{ name: "worktree", load: () => import("./commands/worktree").then(m => m.default), aliases: ["wt"] },
 	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
 ];
 
+const RESERVED_TOP_LEVEL_WORDS = new Map<string, string>([
+	[
+		"extensions",
+		'`prometheus extensions` is not a management command. Use `prometheus plugin list` / `prometheus plugin install`, or run `prometheus launch extensions` if you meant to send "extensions" as a prompt.',
+	],
+]);
+
+export function reservedTopLevelWordMessage(first: string | undefined, argc = 1): string | undefined {
+	if (argc !== 1 || !first || first.startsWith("-") || first.startsWith("@")) return undefined;
+	return RESERVED_TOP_LEVEL_WORDS.get(first);
+}
+
 /**
  * Return true when `first` matches a registered subcommand name or alias.
  *
@@ -47,3 +66,20 @@ export function isSubcommand(first: string | undefined): boolean {
 	if (!first || first.startsWith("-") || first.startsWith("@")) return false;
 	return commands.some(entry => entry.name === first || entry.aliases?.includes(first));
 }
+
+export type ResolvedCliArgv = { argv: string[] } | { error: string };
+
+/**
+ * Decide what the CLI runner should do with raw argv: reject bare reserved
+ * management words, pass help/version through untouched, and route everything
+ * that is not a known subcommand to `launch`.
+ */
+export function resolveCliArgv(argv: string[]): ResolvedCliArgv {
+	const first = argv[0];
+	const reservedMessage = reservedTopLevelWordMessage(first, argv.length);
+	if (reservedMessage) return { error: reservedMessage };
+	if (first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help") {
+		return { argv };
+	}
+	return { argv: isSubcommand(first) ? argv : ["launch", ...argv] };
+}

package/src/cli.ts

@@ -14,9 +14,9 @@ try {
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from Prometheus utils.
  */
-import { type CliConfig, run } from "@prometheus-ai/utils/cli";
+import type { CliConfig } from "@prometheus-ai/utils/cli";
 import { APP_NAME, MIN_BUN_VERSION, VERSION } from "@prometheus-ai/utils/dirs";
-import { commands, isSubcommand } from "./cli-commands";
+import { declareWorkerHostEntry } from "@prometheus-ai/utils/env";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.stderr.write(
@@ -27,6 +27,12 @@ if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 
 process.title = APP_NAME;
 
+// Declare this module as the worker-host entry: Worker threads and worker
+// subprocesses re-enter `Bun.main` with a hidden argv selector instead of
+// loading separate worker entrypoints (single-entry contract across source,
+// npm bundle, and compiled binary).
+declareWorkerHostEntry();
+
 async function showHelp(config: CliConfig): Promise<void> {
 	const { renderRootHelp } = await import("@prometheus-ai/utils/cli");
 	const { getExtraHelpText } = await import("./cli/args");
@@ -37,35 +43,63 @@ async function showHelp(config: CliConfig): Promise<void> {
 	}
 }
 /**
- * Smoke-test entry. Spawns bundled workers, pings them, exits.
+ * Smoke-test entry. Spawns bundled workers, serves the stats dashboard once,
+ * pings everything, then exits.
  *
- * Purpose: catch the silent worker-load regressions that hit compiled
- * binaries (issues #1011 and #1027). Version/help paths do not spawn worker
- * modules on a fresh install, so this probe is the minimal end-to-end test
- * that proves `new Worker(...)` resolves and bundled worker modules evaluate.
+ * Purpose: catch the silent worker-load and bundled-asset regressions that hit
+ * compiled binaries and the npm CLI bundle. Version/help paths do not spawn
+ * worker modules or serve dashboard assets on a fresh install, so this probe is
+ * the minimal end-to-end test that proves those distribution-only paths work.
  * Wired into `scripts/install-tests/run-ci.sh` so binary / source-link /
  * tarball installs all exercise it on every CI run.
  */
 async function runSmokeTest(): Promise<void> {
-	const { smokeTestSyncWorker } = await import("@prometheus-ai/stats");
+	const { smokeTestSyncWorker, startServer } = await import("@prometheus-ai/stats");
 	const { smokeTestTinyTitleWorker } = await import("./tiny/title-client");
+	const { smokeTestSttWorker } = await import("./stt/asr-client");
+	const { smokeTestTtsWorker } = await import("./tts/tts-client");
 	await smokeTestSyncWorker();
+
+	const statsServer = await startServer(0);
+	try {
+		const response = await fetch(`http://127.0.0.1:${statsServer.port}/`);
+		if (!response.ok) throw new Error(`stats dashboard smoke failed: HTTP ${response.status}`);
+		const html = await response.text();
+		if (!html.includes('<div id="root"></div>') || !html.includes("index.js")) {
+			throw new Error("stats dashboard smoke failed: dashboard HTML was not served");
+		}
+	} finally {
+		statsServer.stop();
+	}
+
 	await smokeTestTinyTitleWorker();
+	await smokeTestSttWorker();
+	await smokeTestTtsWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 
+const TINY_WORKER_ARGS = new Set(["--tiny-worker", "__tiny_worker"]);
+const STATS_SYNC_WORKER_ARG = "__prometheus_stats_sync_worker";
+const TAB_WORKER_ARG = "__prometheus_tab_worker";
+const JS_EVAL_WORKER_ARG = "__prometheus_js_eval_worker";
+const STT_WORKER_ARG = "__prometheus_stt_worker";
+const TTS_WORKER_ARG = "__prometheus_tts_worker";
+
 /**
- * Hidden subcommand that boots the tiny-model worker inside this process
- * over the parent's IPC channel. The agent's main process spawns the same
- * binary with this flag so `onnxruntime-node` (loaded transitively by
- * `@huggingface/transformers`) lives in a child address space. The parent
- * `SIGKILL`s the child on shutdown so the NAPI finalizer never runs in
- * either process — that finalizer segfaults Bun on Windows (issue #1606).
+ * Boot a subprocess-isolated transformers.js worker over the parent's IPC
+ * channel and block until the parent disconnects. The tiny-model, STT, and TTS
+ * workers each run `onnxruntime-node` (loaded transitively by
+ * `@huggingface/transformers`) in a child address space because its NAPI
+ * finalizer segfaults Bun on shutdown (issue #1606); the parent `SIGKILL`s the
+ * child so that finalizer never runs in either process. This wires `process`
+ * IPC to the worker's typed transport, keeps the event loop alive while the
+ * worker is idle, and hard-kills the process on parent `disconnect`.
  */
-async function runTinyWorker(): Promise<void> {
-	const { startTinyTitleWorker } = await import("./tiny/worker");
+async function runIpcSubprocessWorker<In, Out>(
+	start: (transport: { send(message: Out): void; onMessage(handler: (message: In) => void): () => void }) => void,
+): Promise<void> {
 	const { promise: shuttingDown, resolve: shutdown } = Promise.withResolvers<void>();
-	const send = (message: unknown): void => {
+	const send = (message: Out): void => {
 		// `process.send` only exists when spawned with an IPC channel; the
 		// parent always spawns us that way. If it's missing, the parent
 		// vanished and there's no one to talk to.
@@ -80,44 +114,119 @@ async function runTinyWorker(): Promise<void> {
 			shutdown();
 		}
 	};
-	startTinyTitleWorker({
+	start({
 		send,
 		onMessage(handler) {
-			const wrap = (data: unknown): void => handler(data as never);
+			const wrap = (data: unknown): void => handler(data as In);
 			process.on("message", wrap);
 			return () => {
 				process.off("message", wrap);
 			};
 		},
 	});
+	const keepalive = setInterval(() => {}, 2 ** 30);
 	// Parent went away (crashed, SIGKILL, etc.) — commit suicide so we don't
-	// linger as an orphan. SIGKILL via `process.kill` keeps us symmetrical
-	// with the parent's hard-kill on shutdown: skip every JS/native finalizer.
+	// linger as an orphan. SIGKILL via `process.kill` keeps us symmetrical with
+	// the parent's hard-kill on shutdown: skip every JS/native finalizer.
 	process.on("disconnect", () => shutdown());
-	await shuttingDown;
+	try {
+		await shuttingDown;
+	} finally {
+		clearInterval(keepalive);
+	}
 	process.kill(process.pid, "SIGKILL");
 }
 
+async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
+	if (arg === STATS_SYNC_WORKER_ARG) {
+		// The sync worker handles messages via `self.onmessage`, assigned during
+		// this *async* dynamic import. Bun flushes the worker's initial message
+		// buffer when the entry module's top-level evaluation finishes — before
+		// this dispatch completes — so anything the parent posted right after
+		// spawning (the smoke ping, the first parse request) would be dropped.
+		// Park early events and replay them once the module's handler is live.
+		// (The tab/eval workers are immune: `parentPort.on("message")` queues
+		// until a listener attaches.)
+		const scope = globalThis as unknown as { onmessage: ((event: MessageEvent) => void) | null };
+		const pending: MessageEvent[] = [];
+		const buffer = (event: MessageEvent): void => {
+			pending.push(event);
+		};
+		scope.onmessage = buffer;
+		await import("@prometheus-ai/stats/sync-worker");
+		const handler = scope.onmessage;
+		if (handler && handler !== buffer) {
+			for (const event of pending) handler.call(scope, event);
+		}
+		return true;
+	}
+	if (arg === TAB_WORKER_ARG) {
+		await import("./tools/browser/tab-worker-entry");
+		return true;
+	}
+	if (arg === JS_EVAL_WORKER_ARG) {
+		await import("./eval/js/worker-entry");
+		return true;
+	}
+	if (arg === STT_WORKER_ARG) {
+		const { startSttWorker } = await import("./stt/asr-worker");
+		await runIpcSubprocessWorker(startSttWorker);
+		return true;
+	}
+	if (arg === TTS_WORKER_ARG) {
+		const { startTtsWorker } = await import("./tts/tts-worker");
+		await runIpcSubprocessWorker(startTtsWorker);
+		return true;
+	}
+	return false;
+}
+
+/**
+ * Hidden subcommand that boots the tiny-model worker inside this process
+ * over the parent's IPC channel. The agent's main process spawns the same
+ * binary with this flag so `onnxruntime-node` (loaded transitively by
+ * `@huggingface/transformers`) lives in a child address space. The parent
+ * `SIGKILL`s the child on shutdown so the NAPI finalizer never runs in
+ * either process — that finalizer segfaults Bun on Windows (issue #1606).
+ */
+async function runTinyWorker(): Promise<void> {
+	const { startTinyTitleWorker } = await import("./tiny/worker");
+	await runIpcSubprocessWorker(startTinyTitleWorker);
+}
+
 /** Run the CLI with the given argv (no `process.argv` prefix). */
 export async function runCli(argv: string[]): Promise<void> {
 	if (argv[0] === "--smoke-test") {
 		await runSmokeTest();
 		return;
 	}
-	if (argv[0] === "--tiny-worker") {
+	if (TINY_WORKER_ARGS.has(argv[0] ?? "")) {
 		await runTinyWorker();
 		return;
 	}
+	if (await runWorkerEntrypoint(argv[0])) {
+		return;
+	}
+	const [{ run }, { commands, resolveCliArgv }] = await Promise.all([
+		import("@prometheus-ai/utils/cli"),
+		import("./cli-commands"),
+	]);
 	// --help and --version are handled by run() directly, don't rewrite those.
 	// Everything else that isn't a known subcommand routes to "launch".
-	const first = argv[0];
-	const runArgv =
-		first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help"
-			? argv
-			: isSubcommand(first)
-				? argv
-				: ["launch", ...argv];
-	return run({ bin: APP_NAME, version: VERSION, argv: runArgv, commands, help: showHelp });
+	const resolved = resolveCliArgv(argv);
+	if ("error" in resolved) {
+		process.stderr.write(`error: ${resolved.error}\n`);
+		process.exitCode = 1;
+		return;
+	}
+	return run({ bin: APP_NAME, version: VERSION, argv: resolved.argv, commands, help: showHelp });
 }
 
-await runCli(process.argv.slice(2));
+// Floating call instead of top-level await: TLA forces `--bytecode` (CJS
+// lowering) builds to fail, and the entrypoint needs nothing after this.
+// The catch mirrors what an unhandled TLA rejection produced: error dump to
+// stderr, exit code 1. Success paths resolve without touching the exit code.
+runCli(process.argv.slice(2)).catch((err: unknown) => {
+	process.stderr.write(`${Bun.inspect(err, { colors: process.stderr.isTTY === true })}\n`);
+	process.exit(1);
+});

package/src/collab/crypto.ts

@@ -0,0 +1,63 @@
+/**
+ * AES-256-GCM sealing for collab frames.
+ *
+ * The room key lives only in the link fragment; the relay sees opaque bytes.
+ * Sealed layout: `[12B IV][ciphertext+tag]`.
+ */
+import { ROOM_KEY_BYTES, WRITE_TOKEN_BYTES } from "@prometheus-ai/wire";
+import type { CollabFrame } from "./protocol";
+
+const AES_ALGORITHM = "AES-GCM";
+const IV_LENGTH = 12;
+const TEXT_ENCODER = new TextEncoder();
+const TEXT_DECODER = new TextDecoder();
+
+export function generateRoomKey(): Uint8Array {
+	const key = new Uint8Array(ROOM_KEY_BYTES);
+	crypto.getRandomValues(key);
+	return key;
+}
+
+export function generateWriteToken(): Uint8Array {
+	const token = new Uint8Array(WRITE_TOKEN_BYTES);
+	crypto.getRandomValues(token);
+	return token;
+}
+
+export function importRoomKey(raw: Uint8Array): Promise<CryptoKey> {
+	if (raw.byteLength !== ROOM_KEY_BYTES) {
+		throw new Error(`Room key must be ${ROOM_KEY_BYTES} bytes, got ${raw.byteLength}`);
+	}
+	return crypto.subtle.importKey("raw", asStrict(raw), AES_ALGORITHM, false, ["encrypt", "decrypt"]);
+}
+
+export async function seal(key: CryptoKey, frame: CollabFrame): Promise<Uint8Array> {
+	const iv = new Uint8Array(IV_LENGTH);
+	crypto.getRandomValues(iv);
+	const plaintext = TEXT_ENCODER.encode(JSON.stringify(frame));
+	const ciphertext = new Uint8Array(await crypto.subtle.encrypt({ name: AES_ALGORITHM, iv }, key, plaintext));
+	const out = new Uint8Array(IV_LENGTH + ciphertext.byteLength);
+	out.set(iv, 0);
+	out.set(ciphertext, IV_LENGTH);
+	return out;
+}
+
+/** Inverse of {@link seal}. Throws on auth failure or malformed input. */
+export async function open(key: CryptoKey, data: Uint8Array): Promise<CollabFrame> {
+	if (data.byteLength <= IV_LENGTH) {
+		throw new Error("Sealed frame too short");
+	}
+	const iv = asStrict(data.subarray(0, IV_LENGTH));
+	const ciphertext = asStrict(data.subarray(IV_LENGTH));
+	const plaintext = new Uint8Array(await crypto.subtle.decrypt({ name: AES_ALGORITHM, iv }, key, ciphertext));
+	return JSON.parse(TEXT_DECODER.decode(plaintext)) as CollabFrame;
+}
+
+function asStrict(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
+	if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+		return bytes as Uint8Array<ArrayBuffer>;
+	}
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy;
+}