@spacebar_ai/moldclaw-core 2026.3.14 → 2026.3.16

package/dist/enable-VYzv8b2z.js

@@ -0,0 +1,24 @@
+import { Hn as ensurePluginAllowlisted, zs as setPluginEnabledInConfig } from "./auth-profiles-9zZdaXJK.js";
+import { c as normalizeChatChannelId } from "./registry-DcDGl2X7.js";
+//#region src/plugins/enable.ts
+function enablePluginInConfig(cfg, pluginId) {
+	const resolvedId = normalizeChatChannelId(pluginId) ?? pluginId;
+	if (cfg.plugins?.enabled === false) return {
+		config: cfg,
+		enabled: false,
+		reason: "plugins disabled"
+	};
+	if (cfg.plugins?.deny?.includes(pluginId) || cfg.plugins?.deny?.includes(resolvedId)) return {
+		config: cfg,
+		enabled: false,
+		reason: "blocked by denylist"
+	};
+	let next = setPluginEnabledInConfig(cfg, resolvedId, true);
+	next = ensurePluginAllowlisted(next, resolvedId);
+	return {
+		config: next,
+		enabled: true
+	};
+}
+//#endregion
+export { enablePluginInConfig as t };

package/dist/entry.d.ts

@@ -0,0 +1,7 @@
+//#region src/entry.d.ts
+declare function tryHandleRootHelpFastPath(argv: string[], deps?: {
+  outputRootHelp?: () => void;
+  onError?: (error: unknown) => void;
+}): boolean;
+//#endregion
+export { tryHandleRootHelpFastPath };

package/dist/entry.js

@@ -168,7 +168,7 @@ function tryHandleRootHelpFastPath(argv, deps = {}) {
 }
 function runMainOrRootHelp(argv) {
 	if (tryHandleRootHelpFastPath(argv)) return;
-	import("./run-main-COAE4GlI.js").then(({ runCli }) => runCli(argv)).catch((error) => {
+	import("./run-main-BlWJVotF.js").then(({ runCli }) => runCli(argv)).catch((error) => {
 		console.error("[moldclaw] Failed to start CLI:", error instanceof Error ? error.stack ?? error.message : error);
 		process.exitCode = 1;
 	});

package/dist/env-overrides-DYVIkuvN.js

@@ -0,0 +1,434 @@
+import { t as createSubsystemLogger } from "./subsystem-S4LNMNHd.js";
+import { r as normalizeStringEntries } from "./string-normalization-CkadSYwL.js";
+import { n as isDangerousHostEnvVarName } from "./host-env-security-xy11yVnm.js";
+import { c as normalizeResolvedSecretInputString } from "./types.secrets-Bojc4omL.js";
+import { a as parsemoldClawManifestInstallBase, c as resolvemoldClawManifestOs, d as evaluateRuntimeEligibility, f as hasBinary, i as parseFrontmatterBool, l as resolvemoldClawManifestRequires, n as getFrontmatterString, o as resolvemoldClawManifestBlock, p as isConfigPathTruthyWithDefaults, r as normalizeStringList, s as resolvemoldClawManifestInstall, t as applymoldClawManifestInstallCommonFields, u as parseFrontmatterBlock } from "./frontmatter-BTDAgsA3.js";
+import { n as validateEnvVarValue, t as sanitizeEnvVars } from "./sanitize-env-vars-Cgaa5oYm.js";
+//#region src/infra/npm-registry-spec.ts
+const EXACT_SEMVER_VERSION_RE = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/;
+const DIST_TAG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function parseRegistryNpmSpecInternal(rawSpec) {
+	const spec = rawSpec.trim();
+	if (!spec) return {
+		ok: false,
+		error: "missing npm spec"
+	};
+	if (/\s/.test(spec)) return {
+		ok: false,
+		error: "unsupported npm spec: whitespace is not allowed"
+	};
+	if (spec.includes("://")) return {
+		ok: false,
+		error: "unsupported npm spec: URLs are not allowed"
+	};
+	if (spec.includes("#")) return {
+		ok: false,
+		error: "unsupported npm spec: git refs are not allowed"
+	};
+	if (spec.includes(":")) return {
+		ok: false,
+		error: "unsupported npm spec: protocol specs are not allowed"
+	};
+	const at = spec.lastIndexOf("@");
+	const hasSelector = at > 0;
+	const name = hasSelector ? spec.slice(0, at) : spec;
+	const selector = hasSelector ? spec.slice(at + 1) : "";
+	if (!(name.startsWith("@") ? /^@[a-z0-9][a-z0-9-._~]*\/[a-z0-9][a-z0-9-._~]*$/.test(name) : /^[a-z0-9][a-z0-9-._~]*$/.test(name))) return {
+		ok: false,
+		error: "unsupported npm spec: expected <name> or <name>@<version> from the npm registry"
+	};
+	if (!hasSelector) return {
+		ok: true,
+		parsed: {
+			name,
+			raw: spec,
+			selectorKind: "none",
+			selectorIsPrerelease: false
+		}
+	};
+	if (!selector) return {
+		ok: false,
+		error: "unsupported npm spec: missing version/tag after @"
+	};
+	if (/[\\/]/.test(selector)) return {
+		ok: false,
+		error: "unsupported npm spec: invalid version/tag"
+	};
+	const exactVersionMatch = EXACT_SEMVER_VERSION_RE.exec(selector);
+	if (exactVersionMatch) return {
+		ok: true,
+		parsed: {
+			name,
+			raw: spec,
+			selector,
+			selectorKind: "exact-version",
+			selectorIsPrerelease: Boolean(exactVersionMatch[4])
+		}
+	};
+	if (!DIST_TAG_RE.test(selector)) return {
+		ok: false,
+		error: "unsupported npm spec: use an exact version or dist-tag (ranges are not allowed)"
+	};
+	return {
+		ok: true,
+		parsed: {
+			name,
+			raw: spec,
+			selector,
+			selectorKind: "tag",
+			selectorIsPrerelease: false
+		}
+	};
+}
+function parseRegistryNpmSpec(rawSpec) {
+	const parsed = parseRegistryNpmSpecInternal(rawSpec);
+	return parsed.ok ? parsed.parsed : null;
+}
+function validateRegistryNpmSpec(rawSpec) {
+	const parsed = parseRegistryNpmSpecInternal(rawSpec);
+	return parsed.ok ? null : parsed.error;
+}
+function isPrereleaseSemverVersion(value) {
+	const match = EXACT_SEMVER_VERSION_RE.exec(value.trim());
+	return Boolean(match?.[4]);
+}
+function isPrereleaseResolutionAllowed(params) {
+	if (!params.resolvedVersion || !isPrereleaseSemverVersion(params.resolvedVersion)) return true;
+	if (params.spec.selectorKind === "none") return false;
+	if (params.spec.selectorKind === "exact-version") return params.spec.selectorIsPrerelease;
+	return params.spec.selector?.toLowerCase() !== "latest";
+}
+function formatPrereleaseResolutionError(params) {
+	const selectorHint = params.spec.selectorKind === "none" || params.spec.selector?.toLowerCase() === "latest" ? `Use "${params.spec.name}@beta" (or another prerelease tag) or an exact prerelease version to opt in explicitly.` : `Use an explicit prerelease tag or exact prerelease version if you want prerelease installs.`;
+	return `Resolved ${params.spec.raw} to prerelease version ${params.resolvedVersion}, but prereleases are only installed when explicitly requested. ${selectorHint}`;
+}
+//#endregion
+//#region src/agents/skills/frontmatter.ts
+function parseFrontmatter(content) {
+	return parseFrontmatterBlock(content);
+}
+const BREW_FORMULA_PATTERN = /^[A-Za-z0-9][A-Za-z0-9@+._/-]*$/;
+const GO_MODULE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~+\-/]*(?:@[A-Za-z0-9][A-Za-z0-9._~+\-/]*)?$/;
+const UV_PACKAGE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._\-[\]=<>!~+,]*$/;
+function normalizeSafeBrewFormula(raw) {
+	if (typeof raw !== "string") return;
+	const formula = raw.trim();
+	if (!formula || formula.startsWith("-") || formula.includes("\\") || formula.includes("..")) return;
+	if (!BREW_FORMULA_PATTERN.test(formula)) return;
+	return formula;
+}
+function normalizeSafeNpmSpec(raw) {
+	if (typeof raw !== "string") return;
+	const spec = raw.trim();
+	if (!spec || spec.startsWith("-")) return;
+	if (validateRegistryNpmSpec(spec) !== null) return;
+	return spec;
+}
+function normalizeSafeGoModule(raw) {
+	if (typeof raw !== "string") return;
+	const moduleSpec = raw.trim();
+	if (!moduleSpec || moduleSpec.startsWith("-") || moduleSpec.includes("\\") || moduleSpec.includes("://")) return;
+	if (!GO_MODULE_PATTERN.test(moduleSpec)) return;
+	return moduleSpec;
+}
+function normalizeSafeUvPackage(raw) {
+	if (typeof raw !== "string") return;
+	const pkg = raw.trim();
+	if (!pkg || pkg.startsWith("-") || pkg.includes("\\") || pkg.includes("://")) return;
+	if (!UV_PACKAGE_PATTERN.test(pkg)) return;
+	return pkg;
+}
+function normalizeSafeDownloadUrl(raw) {
+	if (typeof raw !== "string") return;
+	const value = raw.trim();
+	if (!value || /\s/.test(value)) return;
+	try {
+		const parsed = new URL(value);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
+		return parsed.toString();
+	} catch {
+		return;
+	}
+}
+function parseInstallSpec(input) {
+	const parsed = parsemoldClawManifestInstallBase(input, [
+		"brew",
+		"node",
+		"go",
+		"uv",
+		"download"
+	]);
+	if (!parsed) return;
+	const { raw } = parsed;
+	const spec = applymoldClawManifestInstallCommonFields({ kind: parsed.kind }, parsed);
+	const osList = normalizeStringList(raw.os);
+	if (osList.length > 0) spec.os = osList;
+	const formula = normalizeSafeBrewFormula(raw.formula);
+	if (formula) spec.formula = formula;
+	const cask = normalizeSafeBrewFormula(raw.cask);
+	if (!spec.formula && cask) spec.formula = cask;
+	if (spec.kind === "node") {
+		const pkg = normalizeSafeNpmSpec(raw.package);
+		if (pkg) spec.package = pkg;
+	} else if (spec.kind === "uv") {
+		const pkg = normalizeSafeUvPackage(raw.package);
+		if (pkg) spec.package = pkg;
+	}
+	const moduleSpec = normalizeSafeGoModule(raw.module);
+	if (moduleSpec) spec.module = moduleSpec;
+	const downloadUrl = normalizeSafeDownloadUrl(raw.url);
+	if (downloadUrl) spec.url = downloadUrl;
+	if (typeof raw.archive === "string") spec.archive = raw.archive;
+	if (typeof raw.extract === "boolean") spec.extract = raw.extract;
+	if (typeof raw.stripComponents === "number") spec.stripComponents = raw.stripComponents;
+	if (typeof raw.targetDir === "string") spec.targetDir = raw.targetDir;
+	if (spec.kind === "brew" && !spec.formula) return;
+	if (spec.kind === "node" && !spec.package) return;
+	if (spec.kind === "go" && !spec.module) return;
+	if (spec.kind === "uv" && !spec.package) return;
+	if (spec.kind === "download" && !spec.url) return;
+	return spec;
+}
+function resolvemoldClawMetadata(frontmatter) {
+	const metadataObj = resolvemoldClawManifestBlock({ frontmatter });
+	if (!metadataObj) return;
+	const requires = resolvemoldClawManifestRequires(metadataObj);
+	const install = resolvemoldClawManifestInstall(metadataObj, parseInstallSpec);
+	const osRaw = resolvemoldClawManifestOs(metadataObj);
+	return {
+		always: typeof metadataObj.always === "boolean" ? metadataObj.always : void 0,
+		emoji: typeof metadataObj.emoji === "string" ? metadataObj.emoji : void 0,
+		homepage: typeof metadataObj.homepage === "string" ? metadataObj.homepage : void 0,
+		skillKey: typeof metadataObj.skillKey === "string" ? metadataObj.skillKey : void 0,
+		primaryEnv: typeof metadataObj.primaryEnv === "string" ? metadataObj.primaryEnv : void 0,
+		os: osRaw.length > 0 ? osRaw : void 0,
+		requires,
+		install: install.length > 0 ? install : void 0
+	};
+}
+function resolveSkillInvocationPolicy(frontmatter) {
+	return {
+		userInvocable: parseFrontmatterBool(getFrontmatterString(frontmatter, "user-invocable"), true),
+		disableModelInvocation: parseFrontmatterBool(getFrontmatterString(frontmatter, "disable-model-invocation"), false)
+	};
+}
+function resolveSkillKey(skill, entry) {
+	return entry?.metadata?.skillKey ?? skill.name;
+}
+//#endregion
+//#region src/agents/skills/config.ts
+const DEFAULT_CONFIG_VALUES = {
+	"browser.enabled": true,
+	"browser.evaluateEnabled": true
+};
+function isConfigPathTruthy(config, pathStr) {
+	return isConfigPathTruthyWithDefaults(config, pathStr, DEFAULT_CONFIG_VALUES);
+}
+function resolveSkillConfig(config, skillKey) {
+	const skills = config?.skills?.entries;
+	if (!skills || typeof skills !== "object") return;
+	const entry = skills[skillKey];
+	if (!entry || typeof entry !== "object") return;
+	return entry;
+}
+function normalizeAllowlist(input) {
+	if (!input) return;
+	if (!Array.isArray(input)) return;
+	const normalized = normalizeStringEntries(input);
+	return normalized.length > 0 ? normalized : void 0;
+}
+const BUNDLED_SOURCES = new Set(["moldclaw-bundled"]);
+function isBundledSkill(entry) {
+	return BUNDLED_SOURCES.has(entry.skill.source);
+}
+function resolveBundledAllowlist(config) {
+	return normalizeAllowlist(config?.skills?.allowBundled);
+}
+function isBundledSkillAllowed(entry, allowlist) {
+	if (!allowlist || allowlist.length === 0) return true;
+	if (!isBundledSkill(entry)) return true;
+	const key = resolveSkillKey(entry.skill, entry);
+	return allowlist.includes(key) || allowlist.includes(entry.skill.name);
+}
+function shouldIncludeSkill(params) {
+	const { entry, config, eligibility } = params;
+	const skillConfig = resolveSkillConfig(config, resolveSkillKey(entry.skill, entry));
+	const allowBundled = normalizeAllowlist(config?.skills?.allowBundled);
+	if (skillConfig?.enabled === false) return false;
+	if (!isBundledSkillAllowed(entry, allowBundled)) return false;
+	return evaluateRuntimeEligibility({
+		os: entry.metadata?.os,
+		remotePlatforms: eligibility?.remote?.platforms,
+		always: entry.metadata?.always,
+		requires: entry.metadata?.requires,
+		hasBin: hasBinary,
+		hasRemoteBin: eligibility?.remote?.hasBin,
+		hasAnyRemoteBin: eligibility?.remote?.hasAnyBin,
+		hasEnv: (envName) => Boolean(process.env[envName] || skillConfig?.env?.[envName] || skillConfig?.apiKey && entry.metadata?.primaryEnv === envName),
+		isConfigPathTruthy: (configPath) => isConfigPathTruthy(config, configPath)
+	});
+}
+//#endregion
+//#region src/agents/skills/env-overrides.ts
+const log = createSubsystemLogger("env-overrides");
+/**
+* Tracks env var keys that are currently injected by skill overrides.
+* Used by ACP harness spawn to strip skill-injected keys so they don't
+* leak to child processes (e.g., OPENAI_API_KEY leaking to Codex CLI).
+* @see https://github.com/moldclaw/moldclaw/issues/36280
+*/
+const activeSkillEnvEntries = /* @__PURE__ */ new Map();
+/** Returns a snapshot of env var keys currently injected by skill overrides. */
+function getActiveSkillEnvKeys() {
+	return new Set(activeSkillEnvEntries.keys());
+}
+function acquireActiveSkillEnvKey(key, value) {
+	const active = activeSkillEnvEntries.get(key);
+	if (active) {
+		active.count += 1;
+		if (process.env[key] === void 0) process.env[key] = active.value;
+		return true;
+	}
+	if (process.env[key] !== void 0) return false;
+	activeSkillEnvEntries.set(key, {
+		baseline: process.env[key],
+		value,
+		count: 1
+	});
+	return true;
+}
+function releaseActiveSkillEnvKey(key) {
+	const active = activeSkillEnvEntries.get(key);
+	if (!active) return;
+	active.count -= 1;
+	if (active.count > 0) {
+		if (process.env[key] === void 0) process.env[key] = active.value;
+		return;
+	}
+	activeSkillEnvEntries.delete(key);
+	if (active.baseline === void 0) delete process.env[key];
+	else process.env[key] = active.baseline;
+}
+const SKILL_ALWAYS_BLOCKED_ENV_PATTERNS = [/^OPENSSL_CONF$/i];
+function matchesAnyPattern(value, patterns) {
+	return patterns.some((pattern) => pattern.test(value));
+}
+function isAlwaysBlockedSkillEnvKey(key) {
+	return isDangerousHostEnvVarName(key) || matchesAnyPattern(key, SKILL_ALWAYS_BLOCKED_ENV_PATTERNS);
+}
+function sanitizeSkillEnvOverrides(params) {
+	if (Object.keys(params.overrides).length === 0) return {
+		allowed: {},
+		blocked: [],
+		warnings: []
+	};
+	const result = sanitizeEnvVars(params.overrides);
+	const allowed = {};
+	const blocked = /* @__PURE__ */ new Set();
+	const warnings = [...result.warnings];
+	for (const [key, value] of Object.entries(result.allowed)) {
+		if (isAlwaysBlockedSkillEnvKey(key)) {
+			blocked.add(key);
+			continue;
+		}
+		allowed[key] = value;
+	}
+	for (const key of result.blocked) {
+		if (isAlwaysBlockedSkillEnvKey(key) || !params.allowedSensitiveKeys.has(key)) {
+			blocked.add(key);
+			continue;
+		}
+		const value = params.overrides[key];
+		if (!value) continue;
+		const warning = validateEnvVarValue(value);
+		if (warning) {
+			if (warning === "Contains null bytes") {
+				blocked.add(key);
+				continue;
+			}
+			warnings.push(`${key}: ${warning}`);
+		}
+		allowed[key] = value;
+	}
+	return {
+		allowed,
+		blocked: [...blocked],
+		warnings
+	};
+}
+function applySkillConfigEnvOverrides(params) {
+	const { updates, skillConfig, primaryEnv, requiredEnv, skillKey } = params;
+	const allowedSensitiveKeys = /* @__PURE__ */ new Set();
+	const normalizedPrimaryEnv = primaryEnv?.trim();
+	if (normalizedPrimaryEnv) allowedSensitiveKeys.add(normalizedPrimaryEnv);
+	for (const envName of requiredEnv ?? []) {
+		const trimmedEnv = envName.trim();
+		if (trimmedEnv) allowedSensitiveKeys.add(trimmedEnv);
+	}
+	const pendingOverrides = {};
+	if (skillConfig.env) for (const [rawKey, envValue] of Object.entries(skillConfig.env)) {
+		const envKey = rawKey.trim();
+		const hasExternallyManagedValue = process.env[envKey] !== void 0 && !activeSkillEnvEntries.has(envKey);
+		if (!envKey || !envValue || hasExternallyManagedValue) continue;
+		pendingOverrides[envKey] = envValue;
+	}
+	const resolvedApiKey = normalizeResolvedSecretInputString({
+		value: skillConfig.apiKey,
+		path: `skills.entries.${skillKey}.apiKey`
+	}) ?? "";
+	if (normalizedPrimaryEnv && (process.env[normalizedPrimaryEnv] === void 0 || activeSkillEnvEntries.has(normalizedPrimaryEnv)) && resolvedApiKey) {
+		if (!pendingOverrides[normalizedPrimaryEnv]) pendingOverrides[normalizedPrimaryEnv] = resolvedApiKey;
+	}
+	const sanitized = sanitizeSkillEnvOverrides({
+		overrides: pendingOverrides,
+		allowedSensitiveKeys
+	});
+	if (sanitized.blocked.length > 0) log.warn(`Blocked skill env overrides for ${skillKey}: ${sanitized.blocked.join(", ")}`);
+	if (sanitized.warnings.length > 0) log.warn(`Suspicious skill env overrides for ${skillKey}: ${sanitized.warnings.join(", ")}`);
+	for (const [envKey, envValue] of Object.entries(sanitized.allowed)) {
+		if (!acquireActiveSkillEnvKey(envKey, envValue)) continue;
+		updates.push({ key: envKey });
+		process.env[envKey] = activeSkillEnvEntries.get(envKey)?.value ?? envValue;
+	}
+}
+function createEnvReverter(updates) {
+	return () => {
+		for (const update of updates) releaseActiveSkillEnvKey(update.key);
+	};
+}
+function applySkillEnvOverrides(params) {
+	const { skills, config } = params;
+	const updates = [];
+	for (const entry of skills) {
+		const skillKey = resolveSkillKey(entry.skill, entry);
+		const skillConfig = resolveSkillConfig(config, skillKey);
+		if (!skillConfig) continue;
+		applySkillConfigEnvOverrides({
+			updates,
+			skillConfig,
+			primaryEnv: entry.metadata?.primaryEnv,
+			requiredEnv: entry.metadata?.requires?.env,
+			skillKey
+		});
+	}
+	return createEnvReverter(updates);
+}
+function applySkillEnvOverridesFromSnapshot(params) {
+	const { snapshot, config } = params;
+	if (!snapshot) return () => {};
+	const updates = [];
+	for (const skill of snapshot.skills) {
+		const skillConfig = resolveSkillConfig(config, skill.name);
+		if (!skillConfig) continue;
+		applySkillConfigEnvOverrides({
+			updates,
+			skillConfig,
+			primaryEnv: skill.primaryEnv,
+			requiredEnv: skill.requiredEnv,
+			skillKey: skill.name
+		});
+	}
+	return createEnvReverter(updates);
+}
+//#endregion
+export { isConfigPathTruthy as a, shouldIncludeSkill as c, resolveSkillKey as d, resolvemoldClawMetadata as f, validateRegistryNpmSpec as g, parseRegistryNpmSpec as h, isBundledSkillAllowed as i, parseFrontmatter as l, isPrereleaseResolutionAllowed as m, applySkillEnvOverridesFromSnapshot as n, resolveBundledAllowlist as o, formatPrereleaseResolutionError as p, getActiveSkillEnvKeys as r, resolveSkillConfig as s, applySkillEnvOverrides as t, resolveSkillInvocationPolicy as u };

package/dist/env-overrides.runtime-6kijpIuu.js

@@ -0,0 +1,17 @@
+import "./logger-BFfIIIKH.js";
+import "./paths-D6AgsMTU.js";
+import "./tmp-moldclaw-dir-DWF-d8qD.js";
+import "./theme-BSXzMzAA.js";
+import "./globals-DESrFYmC.js";
+import "./subsystem-S4LNMNHd.js";
+import "./ansi-BPhP6LBZ.js";
+import "./boolean-D8Ha5nYV.js";
+import "./host-env-security-xy11yVnm.js";
+import "./frontmatter-BTDAgsA3.js";
+import { r as getActiveSkillEnvKeys$1 } from "./env-overrides-DYVIkuvN.js";
+//#region src/agents/skills/env-overrides.runtime.ts
+function getActiveSkillEnvKeys(...args) {
+	return getActiveSkillEnvKeys$1(...args);
+}
+//#endregion
+export { getActiveSkillEnvKeys };