@bike4mind/cli 0.18.5 → 0.20.0

package/dist/{ImageStore-BVmEG1xc.mjs → ImageStore-kVo-oHoS.mjs}

@@ -24,10 +24,10 @@ var ImageStore = class ImageStore {
 		this.RETENTION_DAYS = 7;
 	}
 	static {
-		this.MAX_RAW_SIZE = 750 * 1024;
+		this.MAX_RAW_SIZE = 768e3;
 	}
 	static {
-		this.MAX_PRECOMPRESS_SIZE = 50 * 1024 * 1024;
+		this.MAX_PRECOMPRESS_SIZE = 52428800;
 	}
 	constructor() {
 		this.ensureDirectories();

package/dist/PluginStore-DwvOJ-G3.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import { promises } from "fs";
+import { homedir } from "os";
+import path from "path";
+import { z as z$1 } from "zod";
+//#region src/plugins/PluginStore.ts
+/**
+* Discovery for externally-installed CLI plugins.
+*
+* Plugins are npm packages installed under ~/.bike4mind/plugins (via
+* `b4m plugin add`, which runs `npm install --prefix` there) that declare a
+* `b4m-plugin` field in their package.json:
+*
+*   { "b4m-plugin": { "entry": "./dist/index.js", "configKey": "my-plugin" } }
+*
+* This module is read-only: it enumerates installed packages and validates
+* manifests, producing descriptors the loader (src/features/loadPlugin.ts),
+* `b4m plugin list`, and the /config editor all consume. It never imports
+* plugin code and never throws from discover() - a broken package becomes an
+* invalid descriptor with a reason.
+*/
+/** Feature keys owned by built-in modules; plugins may not claim them. */
+const RESERVED_BUILTIN_KEYS = ["tavern"];
+const PROTOTYPE_POLLUTING_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"prototype",
+	"constructor",
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable",
+	"toLocaleString",
+	"toString",
+	"valueOf",
+	"__defineGetter__",
+	"__defineSetter__",
+	"__lookupGetter__",
+	"__lookupSetter__"
+]);
+const B4mPluginManifestSchema = z$1.object({
+	entry: z$1.string().min(1),
+	configKey: z$1.string().min(1).optional()
+});
+const PluginPackageJsonSchema = z$1.looseObject({
+	name: z$1.string().min(1),
+	version: z$1.string().optional(),
+	description: z$1.string().optional(),
+	"b4m-plugin": B4mPluginManifestSchema.optional()
+});
+function getDefaultPluginsDir() {
+	return path.join(homedir(), ".bike4mind", "plugins");
+}
+/**
+* A plugin is enabled only by an OWN features key set to exactly true. The
+* own-property + strict check guards against a configKey that names an
+* Object.prototype member (e.g. 'constructor') reading back truthy through the
+* prototype chain. Single source of truth for the loader gate, the config
+* editor toggle, and `b4m plugin list`.
+*/
+function isFeatureEnabled(features, configKey) {
+	if (!features || !Object.prototype.hasOwnProperty.call(features, configKey)) return false;
+	return features[configKey] === true;
+}
+function formatZodIssues(error) {
+	return error.issues.map((issue) => issue.path.length ? `${issue.path.join(".")}: ${issue.message}` : issue.message).join("; ");
+}
+var PluginStore = class {
+	constructor(options) {
+		this.pluginsDir = options?.pluginsDir ?? getDefaultPluginsDir();
+	}
+	getPluginsDir() {
+		return this.pluginsDir;
+	}
+	/**
+	* Scan the plugins tree and return a descriptor per plugin package, valid or
+	* not. Packages without a b4m-plugin field (a plugin's own transitive deps
+	* land in the same node_modules) are skipped silently. First-wins dedup by
+	* package name across roots and by configKey across plugins.
+	*/
+	async discover() {
+		const packageDirs = [];
+		for (const root of this.candidateRoots()) packageDirs.push(...await this.enumeratePackageDirs(root));
+		const parsed = await Promise.all(packageDirs.map((dir) => this.parseManifest(dir)));
+		const descriptors = [];
+		const seenPackages = /* @__PURE__ */ new Set();
+		for (const descriptor of parsed) {
+			if (!descriptor || seenPackages.has(descriptor.name)) continue;
+			seenPackages.add(descriptor.name);
+			descriptors.push(descriptor);
+		}
+		return this.dedupeConfigKeys(descriptors);
+	}
+	getValid(descriptors) {
+		return descriptors.filter((d) => d.valid);
+	}
+	getInvalid(descriptors) {
+		return descriptors.filter((d) => !d.valid);
+	}
+	/** node_modules is what `npm install --prefix` produces; lib/node_modules covers a `-g --prefix` install. */
+	candidateRoots() {
+		return [path.join(this.pluginsDir, "node_modules"), path.join(this.pluginsDir, "lib", "node_modules")];
+	}
+	async enumeratePackageDirs(root) {
+		const dirs = [];
+		for (const entry of await this.readDirEntries(root)) {
+			if (entry.startsWith(".")) continue;
+			if (entry.startsWith("@")) {
+				for (const scoped of await this.readDirEntries(path.join(root, entry))) if (!scoped.startsWith(".")) dirs.push(path.join(root, entry, scoped));
+			} else dirs.push(path.join(root, entry));
+		}
+		return dirs;
+	}
+	async readDirEntries(dir) {
+		try {
+			return (await promises.readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
+		} catch {
+			return [];
+		}
+	}
+	/** Returns null for "not a plugin package" (skipped), a descriptor otherwise. */
+	async parseManifest(packageDir) {
+		const parent = path.basename(path.dirname(packageDir));
+		const dirName = parent.startsWith("@") ? `${parent}/${path.basename(packageDir)}` : path.basename(packageDir);
+		let rawJson;
+		try {
+			rawJson = await promises.readFile(path.join(packageDir, "package.json"), "utf-8");
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			return {
+				valid: false,
+				name: dirName,
+				packageDir,
+				reason: "package.json is unreadable"
+			};
+		}
+		let parsedJson;
+		try {
+			parsedJson = JSON.parse(rawJson);
+		} catch {
+			return {
+				valid: false,
+				name: dirName,
+				packageDir,
+				reason: "package.json is not valid JSON"
+			};
+		}
+		const pkg = PluginPackageJsonSchema.safeParse(parsedJson);
+		if (!pkg.success) {
+			const declaredName = parsedJson?.name;
+			return {
+				valid: false,
+				name: typeof declaredName === "string" && declaredName.length > 0 ? declaredName : dirName,
+				packageDir,
+				reason: formatZodIssues(pkg.error)
+			};
+		}
+		if (!pkg.data["b4m-plugin"]) return null;
+		const manifest = pkg.data["b4m-plugin"];
+		const name = pkg.data.name;
+		const entryAbsPath = path.resolve(packageDir, manifest.entry);
+		if (!entryAbsPath.startsWith(packageDir + path.sep)) return {
+			valid: false,
+			name,
+			packageDir,
+			reason: `b4m-plugin.entry must resolve to a file inside the package: ${manifest.entry}`
+		};
+		const configKey = manifest.configKey ?? name;
+		if (RESERVED_BUILTIN_KEYS.includes(configKey)) return {
+			valid: false,
+			name,
+			packageDir,
+			reason: `configKey '${configKey}' is reserved for a built-in feature`
+		};
+		if (PROTOTYPE_POLLUTING_KEYS.has(configKey)) return {
+			valid: false,
+			name,
+			packageDir,
+			reason: `configKey '${configKey}' is not allowed`
+		};
+		return {
+			valid: true,
+			name,
+			version: pkg.data.version ?? "0.0.0",
+			description: pkg.data.description ?? "",
+			packageDir,
+			entryAbsPath,
+			configKey
+		};
+	}
+	dedupeConfigKeys(descriptors) {
+		const claimed = /* @__PURE__ */ new Map();
+		return descriptors.map((descriptor) => {
+			if (!descriptor.valid) return descriptor;
+			const owner = claimed.get(descriptor.configKey);
+			if (owner) return {
+				valid: false,
+				name: descriptor.name,
+				packageDir: descriptor.packageDir,
+				reason: `duplicate configKey '${descriptor.configKey}' already claimed by ${owner}`
+			};
+			claimed.set(descriptor.configKey, descriptor.name);
+			return descriptor;
+		});
+	}
+};
+//#endregion
+export { getDefaultPluginsDir as n, isFeatureEnabled as r, PluginStore as t };

package/dist/ProxyManager-Bqr7Lmsd.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { t as ProxyManager } from "./ProxyManager-C5H0pUyK.mjs";
+export { ProxyManager };

package/dist/{ProxyManager-CV94yZUW.mjs → ProxyManager-C5H0pUyK.mjs}

@@ -50,8 +50,8 @@ function isDomainAllowed(domain, allowedDomains) {
 * Intercepts outbound HTTP/HTTPS connections from sandboxed commands
 * and filters by domain allowlist. Uses only Node.js built-ins.
 *
-* - CONNECT handler (HTTPS): Parse domain → check allowlist → tunnel or 403
-* - HTTP handler (forward proxy): Parse host → check allowlist → forward or 403
+* - CONNECT handler (HTTPS): Parse domain -> check allowlist -> tunnel or 403
+* - HTTP handler (forward proxy): Parse host -> check allowlist -> forward or 403
 */
 var HttpConnectProxy = class extends EventEmitter {
 	constructor(options) {

package/dist/{SandboxOrchestrator-BS6gALNq.mjs → SandboxOrchestrator-BFPVpmB5.mjs}

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { t as SandboxOrchestrator } from "./SandboxOrchestrator-BoINxbX4.mjs";
+import { t as SandboxOrchestrator } from "./SandboxOrchestrator-C8uleDn2.mjs";
 export { SandboxOrchestrator };

package/dist/{SandboxOrchestrator-BoINxbX4.mjs → SandboxOrchestrator-C8uleDn2.mjs}

@@ -18,10 +18,10 @@ var SandboxOrchestrator = class {
 	* Determine whether a command should be sandboxed.
 	*
 	* Decision logic:
-	* 1. If sandbox is disabled → unsandboxed (no permission change)
-	* 2. If command matches an excluded command → unsandboxed (requires permission)
-	* 3. If runtime is not available → unsandboxed with warning
-	* 4. Otherwise → sandbox the command
+	* 1. If sandbox is disabled -> unsandboxed (no permission change)
+	* 2. If command matches an excluded command -> unsandboxed (requires permission)
+	* 3. If runtime is not available -> unsandboxed with warning
+	* 4. Otherwise -> sandbox the command
 	*/
 	shouldSandbox(command, cwd) {
 		if (!this.config.enabled || this.config.mode === "disabled") return {
@@ -61,7 +61,7 @@ var SandboxOrchestrator = class {
 	getMode() {
 		return this.config.mode;
 	}
-	/** Set the sandbox mode (does not persist — caller must save config) */
+	/** Set the sandbox mode (does not persist - caller must save config) */
 	setMode(mode) {
 		this.config.mode = mode;
 		this.config.enabled = mode !== "disabled";
@@ -78,7 +78,7 @@ var SandboxOrchestrator = class {
 	getConfig() {
 		return this.config;
 	}
-	/** Update config (does not persist — caller must save) */
+	/** Update config (does not persist - caller must save) */
 	updateConfig(config) {
 		this.config = config;
 	}
@@ -144,7 +144,7 @@ var SandboxOrchestrator = class {
 	}
 	/**
 	* Extract the base command name from a full command string.
-	* e.g., "docker compose up -d" → "docker"
+	* e.g., "docker compose up -d" -> "docker"
 	*/
 	getBaseCommand(command) {
 		const first = command.trim().replace(/^(\w+=\S+\s+)*/, "").split(/\s+/)[0] || "";

package/dist/ShellSessionManager-6o8KZzl1-vrbPAUTq.mjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import { StringDecoder } from "string_decoder";
+//#region ../../b4m-core/services/dist/ShellSessionManager-6o8KZzl1.mjs
+/** Thrown by spawn() when the concurrent-running-session cap is reached. */
+var TooManyShellSessionsError = class extends Error {
+	constructor(limit) {
+		super(`Too many background shell sessions already running (limit ${limit}). Stop one with kill_background_shell before starting another.`);
+		this.limit = limit;
+		this.name = "TooManyShellSessionsError";
+	}
+};
+const DEFAULT_MAX_OUTPUT_CHARS = 262144;
+const DEFAULT_MAX_SESSIONS = 50;
+const DEFAULT_MAX_RUNNING = 10;
+const DEFAULT_RETENTION_MS = 18e5;
+const SIGKILL_ESCALATION_MS = 5e3;
+const INTERRUPT_CHAR = "";
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"exited",
+	"killed",
+	"timed_out"
+]);
+/** True once a session has finished (exited, killed, or timed out) and won't change. */
+function isTerminalShellStatus(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+function isTerminal(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+/**
+* Process-global manager for backgroundable shell sessions.
+*
+* `bash_execute` is a CLI-only tool (see cliTools.ts), so a single in-process
+* registry is safe - there is no Lambda cross-invocation reuse to worry about.
+*
+* Responsibilities:
+* - spawn children *detached* so we can signal the whole process group and never
+*   orphan a `pnpm dev` / watcher;
+* - retain a bounded, offset-addressable output buffer per session for polling;
+* - expose stdin writes and interrupts to running children;
+* - bound memory via an LRU cap + a retention window for terminal sessions;
+* - emit lifecycle changes so the CLI (issue #310) can render live indicators.
+*/
+var ShellSessionManager = class {
+	constructor(options = {}) {
+		this.sessions = /* @__PURE__ */ new Map();
+		this.listeners = /* @__PURE__ */ new Set();
+		this.sequence = 0;
+		this.maxOutputChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+		this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
+		this.maxRunning = options.maxRunning ?? DEFAULT_MAX_RUNNING;
+		this.retentionMs = options.retentionMs ?? DEFAULT_RETENTION_MS;
+		this.now = options.now ?? Date.now;
+		this.spawnFn = options.spawnFn ?? spawn;
+	}
+	/**
+	* Subscribe to lifecycle changes (create + every status transition).
+	* Returns an unsubscribe function.
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	/**
+	* Spawn a command as a background session and return its snapshot immediately.
+	* The child is detached so its process group can be signalled as a unit.
+	*/
+	spawn(command, cwd, env) {
+		this.evictIfNeeded();
+		if (this.runningCount() >= this.maxRunning) throw new TooManyShellSessionsError(this.maxRunning);
+		const id = `sh-${(++this.sequence).toString(36)}-${this.now().toString(36)}`;
+		const child = this.spawnFn("bash", ["-c", command], {
+			cwd,
+			env,
+			detached: true,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		const snapshot = {
+			id,
+			command,
+			cwd,
+			status: "running",
+			exitCode: null,
+			startTime: this.now(),
+			pid: child.pid,
+			totalOutputChars: 0
+		};
+		const session = {
+			snapshot,
+			child,
+			buffer: "",
+			stdoutDecoder: new StringDecoder("utf8"),
+			stderrDecoder: new StringDecoder("utf8")
+		};
+		this.sessions.set(id, session);
+		child.stdout.on("data", (data) => this.append(session, session.stdoutDecoder.write(data)));
+		child.stderr.on("data", (data) => this.append(session, session.stderrDecoder.write(data)));
+		child.on("close", (exitCode) => {
+			const tail = session.stdoutDecoder.end() + session.stderrDecoder.end();
+			if (tail) this.append(session, tail);
+			if (isTerminal(session.snapshot.status)) return;
+			this.transition(session, "exited", exitCode);
+		});
+		child.on("error", (error) => {
+			this.append(session, `\n[shell error] ${error.message}\n`);
+			if (!isTerminal(session.snapshot.status)) this.transition(session, "killed", null);
+		});
+		child.stdin.on("error", (error) => {
+			if (error.code !== "EPIPE") this.append(session, `\n[stdin error] ${error.message}\n`);
+		});
+		this.emit(session);
+		return { ...snapshot };
+	}
+	/** Public snapshot for a session, or undefined if unknown. */
+	get(id) {
+		const session = this.sessions.get(id);
+		return session ? { ...session.snapshot } : void 0;
+	}
+	/** Snapshots of all retained sessions, oldest first. */
+	list() {
+		return Array.from(this.sessions.values()).map((s) => ({ ...s.snapshot }));
+	}
+	/**
+	* Read output produced since `sinceOffset` (absolute char cursor).
+	* Omit `sinceOffset` to read the entire retained buffer.
+	*/
+	getOutput(id, sinceOffset) {
+		const session = this.sessions.get(id);
+		if (!session) return void 0;
+		const { snapshot, buffer } = session;
+		const bufferStart = snapshot.totalOutputChars - buffer.length;
+		const requested = sinceOffset ?? bufferStart;
+		const clamped = Math.max(requested, bufferStart);
+		return {
+			output: buffer.slice(clamped - bufferStart),
+			offset: snapshot.totalOutputChars,
+			truncated: requested < bufferStart,
+			status: snapshot.status,
+			exitCode: snapshot.exitCode
+		};
+	}
+	/**
+	* Write to a running child's stdin. A lone INTERRUPT_CHAR (Ctrl-C) is treated
+	* as an interrupt (SIGINT) rather than literal input. Returns false if the
+	* session is unknown or already terminal.
+	*/
+	writeStdin(id, chars) {
+		const session = this.sessions.get(id);
+		if (!session || isTerminal(session.snapshot.status)) return false;
+		if (chars.includes(INTERRUPT_CHAR)) {
+			this.signalGroup(session, "SIGINT");
+			const rest = chars.split(INTERRUPT_CHAR).join("");
+			if (rest.length > 0) session.child.stdin.write(rest);
+			return true;
+		}
+		session.child.stdin.write(chars);
+		return true;
+	}
+	/**
+	* Terminate a running session's process group (SIGTERM, escalating to SIGKILL).
+	* Returns false if the session is unknown or already terminal.
+	*/
+	kill(id) {
+		const session = this.sessions.get(id);
+		if (!session || isTerminal(session.snapshot.status)) return false;
+		this.terminate(session, "killed");
+		return true;
+	}
+	/** Mark a session as timed out and terminate its group. */
+	markTimedOut(id) {
+		const session = this.sessions.get(id);
+		if (!session || isTerminal(session.snapshot.status)) return false;
+		this.terminate(session, "timed_out");
+		return true;
+	}
+	/** Terminate every running session. Call on CLI shutdown to avoid orphans. */
+	killAll() {
+		for (const session of this.sessions.values()) if (!isTerminal(session.snapshot.status)) this.terminate(session, "killed");
+	}
+	/** Number of retained sessions (for tests/monitoring). */
+	get size() {
+		return this.sessions.size;
+	}
+	/** Number of sessions currently running (non-terminal). */
+	runningCount() {
+		let count = 0;
+		for (const session of this.sessions.values()) if (!isTerminal(session.snapshot.status)) count++;
+		return count;
+	}
+	terminate(session, status) {
+		this.transition(session, status, null);
+		this.signalGroup(session, "SIGTERM");
+		setTimeout(() => {
+			if (session.child.exitCode === null && session.child.signalCode === null) this.signalGroup(session, "SIGKILL");
+		}, SIGKILL_ESCALATION_MS).unref?.();
+	}
+	/** Send a signal to the child's whole process group; ignore already-dead. */
+	signalGroup(session, signal) {
+		const { pid } = session.child;
+		if (pid === void 0) return;
+		try {
+			process.kill(-pid, signal);
+		} catch {}
+	}
+	append(session, chunk) {
+		session.snapshot.totalOutputChars += chunk.length;
+		const combined = session.buffer + chunk;
+		session.buffer = combined.length > this.maxOutputChars ? combined.slice(combined.length - this.maxOutputChars) : combined;
+	}
+	transition(session, status, exitCode) {
+		session.snapshot.status = status;
+		session.snapshot.exitCode = exitCode;
+		if (isTerminal(status)) session.snapshot.endTime = this.now();
+		this.emit(session);
+	}
+	emit(session) {
+		const snapshot = { ...session.snapshot };
+		for (const listener of this.listeners) try {
+			listener(snapshot);
+		} catch {}
+	}
+	/**
+	* Evict terminal sessions to keep memory bounded: first drop any past the
+	* retention window, then, if still at the cap, drop the oldest terminal ones.
+	*/
+	evictIfNeeded() {
+		const cutoff = this.now() - this.retentionMs;
+		for (const [id, session] of this.sessions) if (isTerminal(session.snapshot.status) && (session.snapshot.endTime ?? 0) < cutoff) this.sessions.delete(id);
+		if (this.sessions.size < this.maxSessions) return;
+		const terminalOldestFirst = Array.from(this.sessions.entries()).filter(([, s]) => isTerminal(s.snapshot.status)).sort((a, b) => (a[1].snapshot.endTime ?? 0) - (b[1].snapshot.endTime ?? 0));
+		for (const [id] of terminalOldestFirst) {
+			if (this.sessions.size < this.maxSessions) break;
+			this.sessions.delete(id);
+		}
+	}
+};
+const SINGLETON_KEY = Symbol.for("@bike4mind/services:ShellSessionManager");
+/** Lazily-created process-global manager used by the bash_execute tool family. */
+function getShellSessionManager() {
+	const host = globalThis;
+	if (!host[SINGLETON_KEY]) host[SINGLETON_KEY] = new ShellSessionManager();
+	return host[SINGLETON_KEY];
+}
+//#endregion
+export { isTerminalShellStatus as n, getShellSessionManager as t };

package/dist/{ViolationLogStore-B-plqJfn.mjs → ViolationLogStore-byEhxa2A.mjs}

@@ -41,7 +41,7 @@ var ViolationLogStore = class {
 			throw error;
 		}
 	}
-	/** Record a new violation (converts Date → epoch ms, appends JSONL) */
+	/** Record a new violation (converts Date -> epoch ms, appends JSONL) */
 	async record(violation) {
 		const entry = {
 			type: violation.type,