@spacebar_ai/moldclaw-core 2026.3.14 → 2026.3.16

package/dist/rpc-D3KMxG4J.js

@@ -0,0 +1,67 @@
+import { _ as GATEWAY_CLIENT_MODES, v as GATEWAY_CLIENT_NAMES } from "./message-channel-CKeDAoOT.js";
+import { i as parsePairingList, r as parseNodeList, t as resolveNodeFromNodeList } from "./node-resolve-CupmrA0Y.js";
+import { n as callGateway, s as randomIdempotencyKey } from "./call-DYFR7oGy.js";
+import { n as withProgress } from "./progress-BQSTKUhd.js";
+//#region src/cli/nodes-cli/format.ts
+function formatPermissions(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const entries = Object.entries(raw).map(([key, value]) => [String(key).trim(), value === true]).filter(([key]) => key.length > 0).toSorted((a, b) => a[0].localeCompare(b[0]));
+	if (entries.length === 0) return null;
+	return `[${entries.map(([key, granted]) => `${key}=${granted ? "yes" : "no"}`).join(", ")}]`;
+}
+//#endregion
+//#region src/cli/nodes-cli/rpc.ts
+const nodesCallOpts = (cmd, defaults) => cmd.option("--url <url>", "Gateway WebSocket URL (defaults to gateway.remote.url when configured)").option("--token <token>", "Gateway token (if required)").option("--timeout <ms>", "Timeout in ms", String(defaults?.timeoutMs ?? 1e4)).option("--json", "Output JSON", false);
+const callGatewayCli = async (method, opts, params, callOpts) => withProgress({
+	label: `Nodes ${method}`,
+	indeterminate: true,
+	enabled: opts.json !== true
+}, async () => await callGateway({
+	url: opts.url,
+	token: opts.token,
+	method,
+	params,
+	timeoutMs: callOpts?.transportTimeoutMs ?? Number(opts.timeout ?? 1e4),
+	clientName: GATEWAY_CLIENT_NAMES.CLI,
+	mode: GATEWAY_CLIENT_MODES.CLI
+}));
+function buildNodeInvokeParams(params) {
+	const invokeParams = {
+		nodeId: params.nodeId,
+		command: params.command,
+		params: params.params,
+		idempotencyKey: params.idempotencyKey ?? randomIdempotencyKey()
+	};
+	if (typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs)) invokeParams.timeoutMs = params.timeoutMs;
+	return invokeParams;
+}
+function unauthorizedHintForMessage(message) {
+	const haystack = message.toLowerCase();
+	if (haystack.includes("unauthorizedclient") || haystack.includes("bridge client is not authorized") || haystack.includes("unsigned bridge clients are not allowed")) return [
+		"peekaboo bridge rejected the client.",
+		"sign the peekaboo CLI (TeamID Y5PE65HELJ) or launch the host with",
+		"PEEKABOO_ALLOW_UNSIGNED_SOCKET_CLIENTS=1 for local dev."
+	].join(" ");
+	return null;
+}
+async function resolveNodeId(opts, query) {
+	return (await resolveNode(opts, query)).nodeId;
+}
+async function resolveNode(opts, query) {
+	let nodes = [];
+	try {
+		nodes = parseNodeList(await callGatewayCli("node.list", opts, {}));
+	} catch {
+		const { paired } = parsePairingList(await callGatewayCli("node.pair.list", opts, {}));
+		nodes = paired.map((n) => ({
+			nodeId: n.nodeId,
+			displayName: n.displayName,
+			platform: n.platform,
+			version: n.version,
+			remoteIp: n.remoteIp
+		}));
+	}
+	return resolveNodeFromNodeList(nodes, query);
+}
+//#endregion
+export { resolveNodeId as a, resolveNode as i, callGatewayCli as n, unauthorizedHintForMessage as o, nodesCallOpts as r, formatPermissions as s, buildNodeInvokeParams as t };

package/dist/run-command-C8b3dCZV.d.ts

@@ -0,0 +1,16 @@
+//#region src/plugin-sdk/run-command.d.ts
+type PluginCommandRunResult = {
+  code: number;
+  stdout: string;
+  stderr: string;
+};
+type PluginCommandRunOptions = {
+  argv: string[];
+  timeoutMs: number;
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+};
+/** Run a plugin-managed command with timeout handling and normalized stdout/stderr results. */
+declare function runPluginCommandWithTimeout(options: PluginCommandRunOptions): Promise<PluginCommandRunResult>;
+//#endregion
+export { PluginCommandRunResult as n, runPluginCommandWithTimeout as r, PluginCommandRunOptions as t };

package/dist/run-main-BlWJVotF.js

@@ -0,0 +1,423 @@
+import "./redact-fatrROh9.js";
+import { i as formatUncaughtError } from "./errors-DOJWZqNo.js";
+import { t as isMainModule } from "./is-main-DRn0Pf7d.js";
+import { C as getCommandPositionalsWithRootOptions, D as getVerboseFlag, E as getPrimaryCommand, F as isValueToken, O as hasFlag, S as getCommandPathWithRootOptions, T as getPositiveIntFlagValue, j as isRootHelpInvocation, k as hasHelpOrVersion, w as getFlagValue } from "./logger-BFfIIIKH.js";
+import { _ as resolveStateDir } from "./paths-D6AgsMTU.js";
+import { n as applyCliProfileEnv, r as parseCliProfileArgs, t as normalizeWindowsArgv } from "./windows-argv-CSkPIbuV.js";
+import "./tmp-moldclaw-dir-DWF-d8qD.js";
+import "./theme-BSXzMzAA.js";
+import "./globals-DESrFYmC.js";
+import { a as enableConsoleCapture, m as defaultRuntime } from "./subsystem-S4LNMNHd.js";
+import "./ansi-BPhP6LBZ.js";
+import "./boolean-D8Ha5nYV.js";
+import { r as normalizeEnv, t as isTruthyEnvValue } from "./env-Dgex_t9p.js";
+import { n as VERSION } from "./version-rW_3ob2o.js";
+import "./logging-BdFqMomc.js";
+import { t as assertSupportedRuntime } from "./runtime-guard-CcWejJVQ.js";
+import { t as ensuremoldClawCliOnPath } from "./path-env-JKt31Dxc.js";
+import { t as emitCliBanner } from "./banner-CpUXun7i.js";
+import process$1 from "node:process";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+import dotenv from "dotenv";
+//#region src/cli/dotenv.ts
+function loadCliDotEnv(opts) {
+	const quiet = opts?.quiet ?? true;
+	dotenv.config({ quiet });
+	const globalEnvPath = path.join(resolveStateDir(process.env), ".env");
+	if (!fs.existsSync(globalEnvPath)) return;
+	dotenv.config({
+		quiet,
+		path: globalEnvPath,
+		override: false
+	});
+}
+//#endregion
+//#region src/cli/program/routes.ts
+const routeHealth = {
+	match: (path) => path[0] === "health",
+	loadPlugins: (argv) => !hasFlag(argv, "--json"),
+	run: async (argv) => {
+		const json = hasFlag(argv, "--json");
+		const verbose = getVerboseFlag(argv, { includeDebug: true });
+		const timeoutMs = getPositiveIntFlagValue(argv, "--timeout");
+		if (timeoutMs === null) return false;
+		const { healthCommand } = await import("./health-CAlJydXv.js");
+		await healthCommand({
+			json,
+			timeoutMs,
+			verbose
+		}, defaultRuntime);
+		return true;
+	}
+};
+const routeStatus = {
+	match: (path) => path[0] === "status",
+	loadPlugins: (argv) => !hasFlag(argv, "--json"),
+	run: async (argv) => {
+		const json = hasFlag(argv, "--json");
+		const deep = hasFlag(argv, "--deep");
+		const all = hasFlag(argv, "--all");
+		const usage = hasFlag(argv, "--usage");
+		const verbose = getVerboseFlag(argv, { includeDebug: true });
+		const timeoutMs = getPositiveIntFlagValue(argv, "--timeout");
+		if (timeoutMs === null) return false;
+		if (json) {
+			const { statusJsonCommand } = await import("./status-json-Da0hR-1Z.js");
+			await statusJsonCommand({
+				deep,
+				all,
+				usage,
+				timeoutMs
+			}, defaultRuntime);
+			return true;
+		}
+		const { statusCommand } = await import("./status-D_oHA9yO.js");
+		await statusCommand({
+			json,
+			deep,
+			all,
+			usage,
+			timeoutMs,
+			verbose
+		}, defaultRuntime);
+		return true;
+	}
+};
+const routeGatewayStatus = {
+	match: (path) => path[0] === "gateway" && path[1] === "status",
+	run: async (argv) => {
+		const url = getFlagValue(argv, "--url");
+		if (url === null) return false;
+		const token = getFlagValue(argv, "--token");
+		if (token === null) return false;
+		const password = getFlagValue(argv, "--password");
+		if (password === null) return false;
+		const timeout = getFlagValue(argv, "--timeout");
+		if (timeout === null) return false;
+		const ssh = getFlagValue(argv, "--ssh");
+		if (ssh === null) return false;
+		if (ssh !== void 0) return false;
+		const sshIdentity = getFlagValue(argv, "--ssh-identity");
+		if (sshIdentity === null) return false;
+		if (sshIdentity !== void 0) return false;
+		if (hasFlag(argv, "--ssh-auto")) return false;
+		const deep = hasFlag(argv, "--deep");
+		const json = hasFlag(argv, "--json");
+		const requireRpc = hasFlag(argv, "--require-rpc");
+		const probe = !hasFlag(argv, "--no-probe");
+		const { runDaemonStatus } = await import("./status-5oR_gqv_.js");
+		await runDaemonStatus({
+			rpc: {
+				url: url ?? void 0,
+				token: token ?? void 0,
+				password: password ?? void 0,
+				timeout: timeout ?? void 0
+			},
+			probe,
+			requireRpc,
+			deep,
+			json
+		});
+		return true;
+	}
+};
+const routeSessions = {
+	match: (path) => path[0] === "sessions" && !path[1],
+	run: async (argv) => {
+		const json = hasFlag(argv, "--json");
+		const allAgents = hasFlag(argv, "--all-agents");
+		const agent = getFlagValue(argv, "--agent");
+		if (agent === null) return false;
+		const store = getFlagValue(argv, "--store");
+		if (store === null) return false;
+		const active = getFlagValue(argv, "--active");
+		if (active === null) return false;
+		const { sessionsCommand } = await import("./sessions-Cef4dZNP.js");
+		await sessionsCommand({
+			json,
+			store,
+			agent,
+			allAgents,
+			active
+		}, defaultRuntime);
+		return true;
+	}
+};
+const routeAgentsList = {
+	match: (path) => path[0] === "agents" && path[1] === "list",
+	run: async (argv) => {
+		const json = hasFlag(argv, "--json");
+		const bindings = hasFlag(argv, "--bindings");
+		const { agentsListCommand } = await import("./agents-BrLr08L3.js");
+		await agentsListCommand({
+			json,
+			bindings
+		}, defaultRuntime);
+		return true;
+	}
+};
+const routeMemoryStatus = {
+	match: (path) => path[0] === "memory" && path[1] === "status",
+	run: async (argv) => {
+		const agent = getFlagValue(argv, "--agent");
+		if (agent === null) return false;
+		const json = hasFlag(argv, "--json");
+		const deep = hasFlag(argv, "--deep");
+		const index = hasFlag(argv, "--index");
+		const verbose = hasFlag(argv, "--verbose");
+		const { runMemoryStatus } = await import("./memory-cli-CTp2cYrf.js");
+		await runMemoryStatus({
+			agent,
+			json,
+			deep,
+			index,
+			verbose
+		});
+		return true;
+	}
+};
+function getFlagValues(argv, name) {
+	const values = [];
+	const args = argv.slice(2);
+	for (let i = 0; i < args.length; i += 1) {
+		const arg = args[i];
+		if (!arg || arg === "--") break;
+		if (arg === name) {
+			const next = args[i + 1];
+			if (!isValueToken(next)) return null;
+			values.push(next);
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith(`${name}=`)) {
+			const value = arg.slice(name.length + 1).trim();
+			if (!value) return null;
+			values.push(value);
+		}
+	}
+	return values;
+}
+const routes = [
+	routeHealth,
+	routeStatus,
+	routeGatewayStatus,
+	routeSessions,
+	routeAgentsList,
+	routeMemoryStatus,
+	{
+		match: (path) => path[0] === "config" && path[1] === "get",
+		run: async (argv) => {
+			const positionals = getCommandPositionalsWithRootOptions(argv, {
+				commandPath: ["config", "get"],
+				booleanFlags: ["--json"]
+			});
+			if (!positionals || positionals.length !== 1) return false;
+			const pathArg = positionals[0];
+			if (!pathArg) return false;
+			const json = hasFlag(argv, "--json");
+			const { runConfigGet } = await import("./config-cli-C41d88_c.js");
+			await runConfigGet({
+				path: pathArg,
+				json
+			});
+			return true;
+		}
+	},
+	{
+		match: (path) => path[0] === "config" && path[1] === "unset",
+		run: async (argv) => {
+			const positionals = getCommandPositionalsWithRootOptions(argv, { commandPath: ["config", "unset"] });
+			if (!positionals || positionals.length !== 1) return false;
+			const pathArg = positionals[0];
+			if (!pathArg) return false;
+			const { runConfigUnset } = await import("./config-cli-C41d88_c.js");
+			await runConfigUnset({ path: pathArg });
+			return true;
+		}
+	},
+	{
+		match: (path) => path[0] === "models" && path[1] === "list",
+		run: async (argv) => {
+			const provider = getFlagValue(argv, "--provider");
+			if (provider === null) return false;
+			const all = hasFlag(argv, "--all");
+			const local = hasFlag(argv, "--local");
+			const json = hasFlag(argv, "--json");
+			const plain = hasFlag(argv, "--plain");
+			const { modelsListCommand } = await import("./models-BK1eanuP.js");
+			await modelsListCommand({
+				all,
+				local,
+				provider,
+				json,
+				plain
+			}, defaultRuntime);
+			return true;
+		}
+	},
+	{
+		match: (path) => path[0] === "models" && path[1] === "status",
+		run: async (argv) => {
+			const probeProvider = getFlagValue(argv, "--probe-provider");
+			if (probeProvider === null) return false;
+			const probeTimeout = getFlagValue(argv, "--probe-timeout");
+			if (probeTimeout === null) return false;
+			const probeConcurrency = getFlagValue(argv, "--probe-concurrency");
+			if (probeConcurrency === null) return false;
+			const probeMaxTokens = getFlagValue(argv, "--probe-max-tokens");
+			if (probeMaxTokens === null) return false;
+			const agent = getFlagValue(argv, "--agent");
+			if (agent === null) return false;
+			const probeProfileValues = getFlagValues(argv, "--probe-profile");
+			if (probeProfileValues === null) return false;
+			const probeProfile = probeProfileValues.length === 0 ? void 0 : probeProfileValues.length === 1 ? probeProfileValues[0] : probeProfileValues;
+			const json = hasFlag(argv, "--json");
+			const plain = hasFlag(argv, "--plain");
+			const check = hasFlag(argv, "--check");
+			const probe = hasFlag(argv, "--probe");
+			const { modelsStatusCommand } = await import("./models-BK1eanuP.js");
+			await modelsStatusCommand({
+				json,
+				plain,
+				check,
+				probe,
+				probeProvider,
+				probeProfile,
+				probeTimeout,
+				probeConcurrency,
+				probeMaxTokens,
+				agent
+			}, defaultRuntime);
+			return true;
+		}
+	}
+];
+function findRoutedCommand(path) {
+	for (const route of routes) if (route.match(path)) return route;
+	return null;
+}
+//#endregion
+//#region src/cli/route.ts
+async function prepareRoutedCommand(params) {
+	const suppressDoctorStdout = hasFlag(params.argv, "--json");
+	emitCliBanner(VERSION, { argv: params.argv });
+	const { ensureConfigReady } = await import("./config-guard-B_vjkXCQ.js");
+	await ensureConfigReady({
+		runtime: defaultRuntime,
+		commandPath: params.commandPath,
+		...suppressDoctorStdout ? { suppressDoctorStdout: true } : {}
+	});
+	if (typeof params.loadPlugins === "function" ? params.loadPlugins(params.argv) : params.loadPlugins) {
+		const { ensurePluginRegistryLoaded } = await import("./plugin-registry-XRswugE9.js");
+		ensurePluginRegistryLoaded({ scope: params.commandPath[0] === "status" || params.commandPath[0] === "health" ? "channels" : "all" });
+	}
+}
+async function tryRouteCli(argv) {
+	if (isTruthyEnvValue(process.env.MOLDCLAW_DISABLE_ROUTE_FIRST)) return false;
+	if (hasHelpOrVersion(argv)) return false;
+	const path = getCommandPathWithRootOptions(argv, 2);
+	if (!path[0]) return false;
+	const route = findRoutedCommand(path);
+	if (!route) return false;
+	await prepareRoutedCommand({
+		argv,
+		commandPath: path,
+		loadPlugins: route.loadPlugins
+	});
+	return route.run(argv);
+}
+//#endregion
+//#region src/cli/run-main.ts
+async function closeCliMemoryManagers() {
+	try {
+		const { closeAllMemorySearchManagers } = await import("./search-manager-BJoRxOaf.js");
+		await closeAllMemorySearchManagers();
+	} catch {}
+}
+function rewriteUpdateFlagArgv(argv) {
+	const index = argv.indexOf("--update");
+	if (index === -1) return argv;
+	const next = [...argv];
+	next.splice(index, 1, "update");
+	return next;
+}
+function shouldRegisterPrimarySubcommand(argv) {
+	return !hasHelpOrVersion(argv);
+}
+function shouldSkipPluginCommandRegistration(params) {
+	if (params.hasBuiltinPrimary) return true;
+	if (!params.primary) return hasHelpOrVersion(params.argv);
+	return false;
+}
+function shouldEnsureCliPath(argv) {
+	if (hasHelpOrVersion(argv)) return false;
+	const [primary, secondary] = getCommandPathWithRootOptions(argv, 2);
+	if (!primary) return true;
+	if (primary === "status" || primary === "health" || primary === "sessions") return false;
+	if (primary === "config" && (secondary === "get" || secondary === "unset")) return false;
+	if (primary === "models" && (secondary === "list" || secondary === "status")) return false;
+	return true;
+}
+function shouldUseRootHelpFastPath(argv) {
+	return isRootHelpInvocation(argv);
+}
+async function runCli(argv = process$1.argv) {
+	let normalizedArgv = normalizeWindowsArgv(argv);
+	const parsedProfile = parseCliProfileArgs(normalizedArgv);
+	if (!parsedProfile.ok) throw new Error(parsedProfile.error);
+	if (parsedProfile.profile) applyCliProfileEnv({ profile: parsedProfile.profile });
+	normalizedArgv = parsedProfile.argv;
+	loadCliDotEnv({ quiet: true });
+	normalizeEnv();
+	if (shouldEnsureCliPath(normalizedArgv)) ensuremoldClawCliOnPath();
+	assertSupportedRuntime();
+	try {
+		if (shouldUseRootHelpFastPath(normalizedArgv)) {
+			const { outputRootHelp } = await import("./root-help-C72ZBmy9.js");
+			outputRootHelp();
+			return;
+		}
+		if (await tryRouteCli(normalizedArgv)) return;
+		enableConsoleCapture();
+		const { buildProgram } = await import("./program-8enYYBsc.js");
+		const program = buildProgram();
+		const { installUnhandledRejectionHandler } = await import("./unhandled-rejections-B7FvbZ2_.js");
+		installUnhandledRejectionHandler();
+		process$1.on("uncaughtException", (error) => {
+			console.error("[moldclaw] Uncaught exception:", formatUncaughtError(error));
+			process$1.exit(1);
+		});
+		const parseArgv = rewriteUpdateFlagArgv(normalizedArgv);
+		const primary = getPrimaryCommand(parseArgv);
+		if (primary) {
+			const { getProgramContext } = await import("./program-context-BH7eUu_3.js");
+			const ctx = getProgramContext(program);
+			if (ctx) {
+				const { registerCoreCliByName } = await import("./command-registry-CDkp__KH.js");
+				await registerCoreCliByName(program, ctx, primary, parseArgv);
+			}
+			const { registerSubCliByName } = await import("./register.subclis-gJX_Pbub.js");
+			await registerSubCliByName(program, primary);
+		}
+		if (!shouldSkipPluginCommandRegistration({
+			argv: parseArgv,
+			primary,
+			hasBuiltinPrimary: primary !== null && program.commands.some((command) => command.name() === primary)
+		})) {
+			const { registerPluginCliCommands } = await import("./cli-CIm7d5Id.js");
+			const { loadValidatedConfigForPluginRegistration } = await import("./register.subclis-gJX_Pbub.js");
+			const config = await loadValidatedConfigForPluginRegistration();
+			if (config) registerPluginCliCommands(program, config);
+		}
+		await program.parseAsync(parseArgv);
+	} finally {
+		await closeCliMemoryManagers();
+	}
+}
+function isCliMainModule() {
+	return isMainModule({ currentFile: fileURLToPath(import.meta.url) });
+}
+//#endregion
+export { isCliMainModule, rewriteUpdateFlagArgv, runCli, shouldEnsureCliPath, shouldRegisterPrimarySubcommand, shouldSkipPluginCommandRegistration, shouldUseRootHelpFastPath };

package/dist/runtime-RWGbO5Qy.d.ts

@@ -0,0 +1,26 @@
+import { tP as RuntimeEnv } from "./types-DBhDdMQd.js";
+
+//#region src/plugin-sdk/runtime.d.ts
+type LoggerLike = {
+  info: (message: string) => void;
+  error: (message: string) => void;
+};
+/** Adapt a simple logger into the RuntimeEnv contract used by shared plugin SDK helpers. */
+declare function createLoggerBackedRuntime(params: {
+  logger: LoggerLike;
+  exitError?: (code: number) => Error;
+}): RuntimeEnv;
+/** Reuse an existing runtime when present, otherwise synthesize one from the provided logger. */
+declare function resolveRuntimeEnv(params: {
+  runtime?: RuntimeEnv;
+  logger: LoggerLike;
+  exitError?: (code: number) => Error;
+}): RuntimeEnv;
+/** Resolve a runtime that treats exit requests as unsupported errors instead of process termination. */
+declare function resolveRuntimeEnvWithUnavailableExit(params: {
+  runtime?: RuntimeEnv;
+  logger: LoggerLike;
+  unavailableMessage?: string;
+}): RuntimeEnv;
+//#endregion
+export { resolveRuntimeEnv as n, resolveRuntimeEnvWithUnavailableExit as r, createLoggerBackedRuntime as t };