File: //lib/node_modules/openclaw/dist/config-DWx3SXRc.js
import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
import { Bt as isNixMode, C as CHANNEL_IDS, Gt as resolveGatewayLockDir, Ht as resolveConfigPath, Jt as resolveLegacyStateDirs, Kt as resolveGatewayPort, Lt as CONFIG_PATH, Q as isRecord, Qt as resolveStateDir, Rt as DEFAULT_GATEWAY_PORT, Ut as resolveConfigPathCandidate, Vt as resolveCanonicalConfigPath, Wt as resolveDefaultConfigCandidates, Xt as resolveOAuthDir, Yt as resolveNewStateDir, Zt as resolveOAuthPath, gn as resolveRequiredHomeDir, hn as expandHomePrefix, j as normalizeChatChannelId, mt as isPlainObject$2, ot as resolveUserPath, qt as resolveIsNixMode, rt as resolveConfigDir, zt as STATE_DIR } from "./entry.js";
import { Ft as shouldEnableShellEnvFallback, Kt as DEFAULT_CONTEXT_TOKENS, Mt as loadShellEnvFallback, Nt as resolveShellEnvFallbackTimeoutMs, Pt as shouldDeferShellEnvFallback, R as normalizeProviderId, z as parseModelRef } from "./auth-profiles-BLqWs5Ho.js";
import { j as resolveAgentModelPrimaryValue, l as resolveAgentWorkspaceDir, u as resolveDefaultAgentId } from "./agent-scope-BUKPOSoo.js";
import { _ as isBlockedObjectKey, s as normalizeAgentId, t as DEFAULT_AGENT_ID } from "./session-key-DIABCrXz.js";
import { n as isPathInside } from "./scan-paths-DkMlwCU-.js";
import { d as resolveEffectiveEnableState, f as resolveMemorySlotDecision, n as loadPluginManifestRegistry, u as normalizePluginsConfig } from "./manifest-registry-BPlNBgie.js";
import { r as VERSION, t as applyConfigEnvVars } from "./env-vars-iFkEK4MO.js";
import { d as TOOLS_BY_SENDER_KEY_TYPES, f as parseToolsBySenderTypedKey } from "./dock-DE75y38s.js";
import os from "node:os";
import path from "node:path";
import fs from "node:fs";
import JSON5 from "json5";
import { isDeepStrictEqual } from "node:util";
import crypto from "node:crypto";
import dotenv from "dotenv";
import AjvPkg from "ajv";
import { z } from "zod";
//#region src/agents/owner-display.ts
function trimToUndefined(value) {
const trimmed = value?.trim();
return trimmed ? trimmed : void 0;
}
/**
* Resolve owner display settings for prompt rendering.
* Keep auth secrets decoupled from owner hash secrets.
*/
function resolveOwnerDisplaySetting(config) {
const ownerDisplay = config?.commands?.ownerDisplay;
if (ownerDisplay !== "hash") return {
ownerDisplay,
ownerDisplaySecret: void 0
};
return {
ownerDisplay: "hash",
ownerDisplaySecret: trimToUndefined(config?.commands?.ownerDisplaySecret)
};
}
/**
* Ensure hash mode has a dedicated secret.
* Returns updated config and generated secret when autofill was needed.
*/
function ensureOwnerDisplaySecret(config, generateSecret = () => crypto.randomBytes(32).toString("hex")) {
const settings = resolveOwnerDisplaySetting(config);
if (settings.ownerDisplay !== "hash" || settings.ownerDisplaySecret) return { config };
const generatedSecret = generateSecret();
return {
config: {
...config,
commands: {
...config.commands,
ownerDisplay: "hash",
ownerDisplaySecret: generatedSecret
}
},
generatedSecret
};
}
//#endregion
//#region src/infra/dotenv.ts
function loadDotEnv(opts) {
const quiet = opts?.quiet ?? true;
dotenv.config({ quiet });
const globalEnvPath = path.join(resolveConfigDir(process.env), ".env");
if (!fs.existsSync(globalEnvPath)) return;
dotenv.config({
quiet,
path: globalEnvPath,
override: false
});
}
//#endregion
//#region src/config/agent-dirs.ts
var DuplicateAgentDirError = class extends Error {
constructor(duplicates) {
super(formatDuplicateAgentDirError(duplicates));
this.name = "DuplicateAgentDirError";
this.duplicates = duplicates;
}
};
function canonicalizeAgentDir(agentDir) {
const resolved = path.resolve(agentDir);
if (process.platform === "darwin" || process.platform === "win32") return resolved.toLowerCase();
return resolved;
}
function collectReferencedAgentIds(cfg) {
const ids = /* @__PURE__ */ new Set();
const agents = Array.isArray(cfg.agents?.list) ? cfg.agents?.list : [];
const defaultAgentId = agents.find((agent) => agent?.default)?.id ?? agents[0]?.id ?? DEFAULT_AGENT_ID;
ids.add(normalizeAgentId(defaultAgentId));
for (const entry of agents) if (entry?.id) ids.add(normalizeAgentId(entry.id));
const bindings = cfg.bindings;
if (Array.isArray(bindings)) for (const binding of bindings) {
const id = binding?.agentId;
if (typeof id === "string" && id.trim()) ids.add(normalizeAgentId(id));
}
return [...ids];
}
function resolveEffectiveAgentDir(cfg, agentId, deps) {
const id = normalizeAgentId(agentId);
const trimmed = (Array.isArray(cfg.agents?.list) ? cfg.agents?.list.find((agent) => normalizeAgentId(agent.id) === id)?.agentDir : void 0)?.trim();
if (trimmed) return resolveUserPath(trimmed);
const env = deps?.env ?? process.env;
const root = resolveStateDir(env, deps?.homedir ?? (() => resolveRequiredHomeDir(env, os.homedir)));
return path.join(root, "agents", id, "agent");
}
function findDuplicateAgentDirs(cfg, deps) {
const byDir = /* @__PURE__ */ new Map();
for (const agentId of collectReferencedAgentIds(cfg)) {
const agentDir = resolveEffectiveAgentDir(cfg, agentId, deps);
const key = canonicalizeAgentDir(agentDir);
const entry = byDir.get(key);
if (entry) entry.agentIds.push(agentId);
else byDir.set(key, {
agentDir,
agentIds: [agentId]
});
}
return [...byDir.values()].filter((v) => v.agentIds.length > 1);
}
function formatDuplicateAgentDirError(dups) {
return [
"Duplicate agentDir detected (multi-agent config).",
"Each agent must have a unique agentDir; sharing it causes auth/session state collisions and token invalidation.",
"",
"Conflicts:",
...dups.map((d) => `- ${d.agentDir}: ${d.agentIds.map((id) => `"${id}"`).join(", ")}`),
"",
"Fix: remove the shared agents.list[].agentDir override (or give each agent its own directory).",
"If you want to share credentials, copy auth-profiles.json instead of sharing the entire agentDir."
].join("\n");
}
//#endregion
//#region src/config/backup-rotation.ts
const CONFIG_BACKUP_COUNT = 5;
async function rotateConfigBackups(configPath, ioFs) {
if (CONFIG_BACKUP_COUNT <= 1) return;
const backupBase = `${configPath}.bak`;
const maxIndex = CONFIG_BACKUP_COUNT - 1;
await ioFs.unlink(`${backupBase}.${maxIndex}`).catch(() => {});
for (let index = maxIndex - 1; index >= 1; index -= 1) await ioFs.rename(`${backupBase}.${index}`, `${backupBase}.${index + 1}`).catch(() => {});
await ioFs.rename(backupBase, `${backupBase}.1`).catch(() => {});
}
//#endregion
//#region src/config/agent-limits.ts
const DEFAULT_AGENT_MAX_CONCURRENT = 4;
const DEFAULT_SUBAGENT_MAX_CONCURRENT = 8;
const DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH = 1;
function resolveAgentMaxConcurrent(cfg) {
const raw = cfg?.agents?.defaults?.maxConcurrent;
if (typeof raw === "number" && Number.isFinite(raw)) return Math.max(1, Math.floor(raw));
return DEFAULT_AGENT_MAX_CONCURRENT;
}
function resolveSubagentMaxConcurrent(cfg) {
const raw = cfg?.agents?.defaults?.subagents?.maxConcurrent;
if (typeof raw === "number" && Number.isFinite(raw)) return Math.max(1, Math.floor(raw));
return DEFAULT_SUBAGENT_MAX_CONCURRENT;
}
//#endregion
//#region src/config/talk.ts
const DEFAULT_TALK_PROVIDER = "elevenlabs";
function isPlainObject$1(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function normalizeString(value) {
if (typeof value !== "string") return;
const trimmed = value.trim();
return trimmed.length > 0 ? trimmed : void 0;
}
function normalizeVoiceAliases(value) {
if (!isPlainObject$1(value)) return;
const aliases = {};
for (const [alias, rawId] of Object.entries(value)) {
if (typeof rawId !== "string") continue;
aliases[alias] = rawId;
}
return Object.keys(aliases).length > 0 ? aliases : void 0;
}
function normalizeTalkProviderConfig(value) {
if (!isPlainObject$1(value)) return;
const provider = {};
for (const [key, raw] of Object.entries(value)) {
if (raw === void 0) continue;
if (key === "voiceAliases") {
const aliases = normalizeVoiceAliases(raw);
if (aliases) provider.voiceAliases = aliases;
continue;
}
if (key === "voiceId" || key === "modelId" || key === "outputFormat" || key === "apiKey") {
const normalized = normalizeString(raw);
if (normalized) provider[key] = normalized;
continue;
}
provider[key] = raw;
}
return Object.keys(provider).length > 0 ? provider : void 0;
}
function normalizeTalkProviders(value) {
if (!isPlainObject$1(value)) return;
const providers = {};
for (const [rawProviderId, providerConfig] of Object.entries(value)) {
const providerId = normalizeString(rawProviderId);
if (!providerId) continue;
const normalizedProvider = normalizeTalkProviderConfig(providerConfig);
if (!normalizedProvider) continue;
providers[providerId] = normalizedProvider;
}
return Object.keys(providers).length > 0 ? providers : void 0;
}
function normalizedLegacyTalkFields(source) {
const legacy = {};
const voiceId = normalizeString(source.voiceId);
if (voiceId) legacy.voiceId = voiceId;
const voiceAliases = normalizeVoiceAliases(source.voiceAliases);
if (voiceAliases) legacy.voiceAliases = voiceAliases;
const modelId = normalizeString(source.modelId);
if (modelId) legacy.modelId = modelId;
const outputFormat = normalizeString(source.outputFormat);
if (outputFormat) legacy.outputFormat = outputFormat;
const apiKey = normalizeString(source.apiKey);
if (apiKey) legacy.apiKey = apiKey;
return legacy;
}
function legacyProviderConfigFromTalk(source) {
return normalizeTalkProviderConfig({
voiceId: source.voiceId,
voiceAliases: source.voiceAliases,
modelId: source.modelId,
outputFormat: source.outputFormat,
apiKey: source.apiKey
});
}
function activeProviderFromTalk(talk) {
const provider = normalizeString(talk.provider);
if (provider) return provider;
const providerIds = talk.providers ? Object.keys(talk.providers) : [];
return providerIds.length === 1 ? providerIds[0] : void 0;
}
function legacyTalkFieldsFromProviderConfig(config) {
if (!config) return {};
const legacy = {};
if (typeof config.voiceId === "string") legacy.voiceId = config.voiceId;
if (config.voiceAliases && typeof config.voiceAliases === "object" && !Array.isArray(config.voiceAliases)) {
const aliases = normalizeVoiceAliases(config.voiceAliases);
if (aliases) legacy.voiceAliases = aliases;
}
if (typeof config.modelId === "string") legacy.modelId = config.modelId;
if (typeof config.outputFormat === "string") legacy.outputFormat = config.outputFormat;
if (typeof config.apiKey === "string") legacy.apiKey = config.apiKey;
return legacy;
}
function normalizeTalkSection(value) {
if (!isPlainObject$1(value)) return;
const source = value;
const hasNormalizedShape = typeof source.provider === "string" || isPlainObject$1(source.providers);
const normalized = {};
const legacy = normalizedLegacyTalkFields(source);
if (Object.keys(legacy).length > 0) Object.assign(normalized, legacy);
if (typeof source.interruptOnSpeech === "boolean") normalized.interruptOnSpeech = source.interruptOnSpeech;
if (hasNormalizedShape) {
const providers = normalizeTalkProviders(source.providers);
const provider = normalizeString(source.provider);
if (providers) normalized.providers = providers;
if (provider) normalized.provider = provider;
else if (providers) {
const ids = Object.keys(providers);
if (ids.length === 1) normalized.provider = ids[0];
}
return Object.keys(normalized).length > 0 ? normalized : void 0;
}
const legacyProviderConfig = legacyProviderConfigFromTalk(source);
if (legacyProviderConfig) {
normalized.provider = DEFAULT_TALK_PROVIDER;
normalized.providers = { [DEFAULT_TALK_PROVIDER]: legacyProviderConfig };
}
return Object.keys(normalized).length > 0 ? normalized : void 0;
}
function normalizeTalkConfig(config) {
if (!config.talk) return config;
const normalizedTalk = normalizeTalkSection(config.talk);
if (!normalizedTalk) return config;
return {
...config,
talk: normalizedTalk
};
}
function resolveActiveTalkProviderConfig(talk) {
const normalizedTalk = normalizeTalkSection(talk);
if (!normalizedTalk) return {};
const provider = activeProviderFromTalk(normalizedTalk);
if (!provider) return {};
return {
provider,
config: normalizedTalk.providers?.[provider]
};
}
function buildTalkConfigResponse(value) {
if (!isPlainObject$1(value)) return;
const normalized = normalizeTalkSection(value);
if (!normalized) return;
const payload = {};
if (typeof normalized.interruptOnSpeech === "boolean") payload.interruptOnSpeech = normalized.interruptOnSpeech;
if (normalized.providers && Object.keys(normalized.providers).length > 0) payload.providers = normalized.providers;
if (typeof normalized.provider === "string") payload.provider = normalized.provider;
const activeProvider = activeProviderFromTalk(normalized);
const providerCompatibilityLegacy = legacyTalkFieldsFromProviderConfig(activeProvider ? normalized.providers?.[activeProvider] : void 0);
const compatibilityLegacy = Object.keys(providerCompatibilityLegacy).length > 0 ? providerCompatibilityLegacy : normalizedLegacyTalkFields(normalized);
Object.assign(payload, compatibilityLegacy);
return Object.keys(payload).length > 0 ? payload : void 0;
}
function readTalkApiKeyFromProfile(deps = {}) {
const fsImpl = deps.fs ?? fs;
const osImpl = deps.os ?? os;
const pathImpl = deps.path ?? path;
const home = osImpl.homedir();
const candidates = [
".profile",
".zprofile",
".zshrc",
".bashrc"
].map((name) => pathImpl.join(home, name));
for (const candidate of candidates) {
if (!fsImpl.existsSync(candidate)) continue;
try {
const value = fsImpl.readFileSync(candidate, "utf-8").match(/(?:^|\n)\s*(?:export\s+)?ELEVENLABS_API_KEY\s*=\s*["']?([^\n"']+)["']?/)?.[1]?.trim();
if (value) return value;
} catch {}
}
return null;
}
function resolveTalkApiKey(env = process.env, deps = {}) {
const envValue = (env.ELEVENLABS_API_KEY ?? "").trim();
if (envValue) return envValue;
return readTalkApiKeyFromProfile(deps);
}
//#endregion
//#region src/config/defaults.ts
let defaultWarnState = { warned: false };
const DEFAULT_MODEL_ALIASES = {
opus: "anthropic/claude-opus-4-6",
sonnet: "anthropic/claude-sonnet-4-6",
gpt: "openai/gpt-5.2",
"gpt-mini": "openai/gpt-5-mini",
gemini: "google/gemini-3-pro-preview",
"gemini-flash": "google/gemini-3-flash-preview"
};
const DEFAULT_MODEL_COST = {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0
};
const DEFAULT_MODEL_INPUT = ["text"];
const DEFAULT_MODEL_MAX_TOKENS = 8192;
function resolveDefaultProviderApi(providerId, providerApi) {
if (providerApi) return providerApi;
return normalizeProviderId(providerId) === "anthropic" ? "anthropic-messages" : void 0;
}
function isPositiveNumber(value) {
return typeof value === "number" && Number.isFinite(value) && value > 0;
}
function resolveModelCost(raw) {
return {
input: typeof raw?.input === "number" ? raw.input : DEFAULT_MODEL_COST.input,
output: typeof raw?.output === "number" ? raw.output : DEFAULT_MODEL_COST.output,
cacheRead: typeof raw?.cacheRead === "number" ? raw.cacheRead : DEFAULT_MODEL_COST.cacheRead,
cacheWrite: typeof raw?.cacheWrite === "number" ? raw.cacheWrite : DEFAULT_MODEL_COST.cacheWrite
};
}
function resolveAnthropicDefaultAuthMode(cfg) {
const profiles = cfg.auth?.profiles ?? {};
const anthropicProfiles = Object.entries(profiles).filter(([, profile]) => profile?.provider === "anthropic");
const order = cfg.auth?.order?.anthropic ?? [];
for (const profileId of order) {
const entry = profiles[profileId];
if (!entry || entry.provider !== "anthropic") continue;
if (entry.mode === "api_key") return "api_key";
if (entry.mode === "oauth" || entry.mode === "token") return "oauth";
}
const hasApiKey = anthropicProfiles.some(([, profile]) => profile?.mode === "api_key");
const hasOauth = anthropicProfiles.some(([, profile]) => profile?.mode === "oauth" || profile?.mode === "token");
if (hasApiKey && !hasOauth) return "api_key";
if (hasOauth && !hasApiKey) return "oauth";
if (process.env.ANTHROPIC_OAUTH_TOKEN?.trim()) return "oauth";
if (process.env.ANTHROPIC_API_KEY?.trim()) return "api_key";
return null;
}
function resolvePrimaryModelRef(raw) {
if (!raw || typeof raw !== "string") return null;
const trimmed = raw.trim();
if (!trimmed) return null;
return DEFAULT_MODEL_ALIASES[trimmed.toLowerCase()] ?? trimmed;
}
function applyMessageDefaults(cfg) {
const messages = cfg.messages;
if (messages?.ackReactionScope !== void 0) return cfg;
const nextMessages = messages ? { ...messages } : {};
nextMessages.ackReactionScope = "group-mentions";
return {
...cfg,
messages: nextMessages
};
}
function applySessionDefaults(cfg, options = {}) {
const session = cfg.session;
if (!session || session.mainKey === void 0) return cfg;
const trimmed = session.mainKey.trim();
const warn = options.warn ?? console.warn;
const warnState = options.warnState ?? defaultWarnState;
const next = {
...cfg,
session: {
...session,
mainKey: "main"
}
};
if (trimmed && trimmed !== "main" && !warnState.warned) {
warnState.warned = true;
warn("session.mainKey is ignored; main session is always \"main\".");
}
return next;
}
function applyTalkApiKey(config) {
const normalized = normalizeTalkConfig(config);
const resolved = resolveTalkApiKey();
if (!resolved) return normalized;
const talk = normalized.talk;
const active = resolveActiveTalkProviderConfig(talk);
if (active.provider && active.provider !== DEFAULT_TALK_PROVIDER) return normalized;
const existingProviderApiKey = typeof active.config?.apiKey === "string" ? active.config.apiKey.trim() : "";
const existingLegacyApiKey = typeof talk?.apiKey === "string" ? talk.apiKey.trim() : "";
if (existingProviderApiKey || existingLegacyApiKey) return normalized;
const providerId = active.provider ?? DEFAULT_TALK_PROVIDER;
const providers = { ...talk?.providers };
providers[providerId] = {
...providers[providerId],
apiKey: resolved
};
const nextTalk = {
...talk,
provider: talk?.provider ?? providerId,
providers,
apiKey: resolved
};
return {
...normalized,
talk: nextTalk
};
}
function applyTalkConfigNormalization(config) {
return normalizeTalkConfig(config);
}
function applyModelDefaults(cfg) {
let mutated = false;
let nextCfg = cfg;
const providerConfig = nextCfg.models?.providers;
if (providerConfig) {
const nextProviders = { ...providerConfig };
for (const [providerId, provider] of Object.entries(providerConfig)) {
const models = provider.models;
if (!Array.isArray(models) || models.length === 0) continue;
const providerApi = resolveDefaultProviderApi(providerId, provider.api);
let nextProvider = provider;
if (providerApi && provider.api !== providerApi) {
mutated = true;
nextProvider = {
...nextProvider,
api: providerApi
};
}
let providerMutated = false;
const nextModels = models.map((model) => {
const raw = model;
let modelMutated = false;
const reasoning = typeof raw.reasoning === "boolean" ? raw.reasoning : false;
if (raw.reasoning !== reasoning) modelMutated = true;
const input = raw.input ?? [...DEFAULT_MODEL_INPUT];
if (raw.input === void 0) modelMutated = true;
const cost = resolveModelCost(raw.cost);
if (!raw.cost || raw.cost.input !== cost.input || raw.cost.output !== cost.output || raw.cost.cacheRead !== cost.cacheRead || raw.cost.cacheWrite !== cost.cacheWrite) modelMutated = true;
const contextWindow = isPositiveNumber(raw.contextWindow) ? raw.contextWindow : DEFAULT_CONTEXT_TOKENS;
if (raw.contextWindow !== contextWindow) modelMutated = true;
const defaultMaxTokens = Math.min(DEFAULT_MODEL_MAX_TOKENS, contextWindow);
const rawMaxTokens = isPositiveNumber(raw.maxTokens) ? raw.maxTokens : defaultMaxTokens;
const maxTokens = Math.min(rawMaxTokens, contextWindow);
if (raw.maxTokens !== maxTokens) modelMutated = true;
const api = raw.api ?? providerApi;
if (raw.api !== api) modelMutated = true;
if (!modelMutated) return model;
providerMutated = true;
return {
...raw,
reasoning,
input,
cost,
contextWindow,
maxTokens,
api
};
});
if (!providerMutated) {
if (nextProvider !== provider) nextProviders[providerId] = nextProvider;
continue;
}
nextProviders[providerId] = {
...nextProvider,
models: nextModels
};
mutated = true;
}
if (mutated) nextCfg = {
...nextCfg,
models: {
...nextCfg.models,
providers: nextProviders
}
};
}
const existingAgent = nextCfg.agents?.defaults;
if (!existingAgent) return mutated ? nextCfg : cfg;
const existingModels = existingAgent.models ?? {};
if (Object.keys(existingModels).length === 0) return mutated ? nextCfg : cfg;
const nextModels = { ...existingModels };
for (const [alias, target] of Object.entries(DEFAULT_MODEL_ALIASES)) {
const entry = nextModels[target];
if (!entry) continue;
if (entry.alias !== void 0) continue;
nextModels[target] = {
...entry,
alias
};
mutated = true;
}
if (!mutated) return cfg;
return {
...nextCfg,
agents: {
...nextCfg.agents,
defaults: {
...existingAgent,
models: nextModels
}
}
};
}
function applyAgentDefaults(cfg) {
const agents = cfg.agents;
const defaults = agents?.defaults;
const hasMax = typeof defaults?.maxConcurrent === "number" && Number.isFinite(defaults.maxConcurrent);
const hasSubMax = typeof defaults?.subagents?.maxConcurrent === "number" && Number.isFinite(defaults.subagents.maxConcurrent);
if (hasMax && hasSubMax) return cfg;
let mutated = false;
const nextDefaults = defaults ? { ...defaults } : {};
if (!hasMax) {
nextDefaults.maxConcurrent = DEFAULT_AGENT_MAX_CONCURRENT;
mutated = true;
}
const nextSubagents = defaults?.subagents ? { ...defaults.subagents } : {};
if (!hasSubMax) {
nextSubagents.maxConcurrent = DEFAULT_SUBAGENT_MAX_CONCURRENT;
mutated = true;
}
if (!mutated) return cfg;
return {
...cfg,
agents: {
...agents,
defaults: {
...nextDefaults,
subagents: nextSubagents
}
}
};
}
function applyLoggingDefaults(cfg) {
const logging = cfg.logging;
if (!logging) return cfg;
if (logging.redactSensitive) return cfg;
return {
...cfg,
logging: {
...logging,
redactSensitive: "tools"
}
};
}
function applyContextPruningDefaults(cfg) {
const defaults = cfg.agents?.defaults;
if (!defaults) return cfg;
const authMode = resolveAnthropicDefaultAuthMode(cfg);
if (!authMode) return cfg;
let mutated = false;
const nextDefaults = { ...defaults };
const contextPruning = defaults.contextPruning ?? {};
const heartbeat = defaults.heartbeat ?? {};
if (defaults.contextPruning?.mode === void 0) {
nextDefaults.contextPruning = {
...contextPruning,
mode: "cache-ttl",
ttl: defaults.contextPruning?.ttl ?? "1h"
};
mutated = true;
}
if (defaults.heartbeat?.every === void 0) {
nextDefaults.heartbeat = {
...heartbeat,
every: authMode === "oauth" ? "1h" : "30m"
};
mutated = true;
}
if (authMode === "api_key") {
const nextModels = defaults.models ? { ...defaults.models } : {};
let modelsMutated = false;
const isAnthropicCacheRetentionTarget = (parsed) => Boolean(parsed && (parsed.provider === "anthropic" || parsed.provider === "amazon-bedrock" && parsed.model.toLowerCase().includes("anthropic.claude")));
for (const [key, entry] of Object.entries(nextModels)) {
if (!isAnthropicCacheRetentionTarget(parseModelRef(key, "anthropic"))) continue;
const current = entry ?? {};
const params = current.params ?? {};
if (typeof params.cacheRetention === "string") continue;
nextModels[key] = {
...current,
params: {
...params,
cacheRetention: "short"
}
};
modelsMutated = true;
}
const primary = resolvePrimaryModelRef(resolveAgentModelPrimaryValue(defaults.model) ?? void 0);
if (primary) {
const parsedPrimary = parseModelRef(primary, "anthropic");
if (isAnthropicCacheRetentionTarget(parsedPrimary)) {
const key = `${parsedPrimary.provider}/${parsedPrimary.model}`;
const current = nextModels[key] ?? {};
const params = current.params ?? {};
if (typeof params.cacheRetention !== "string") {
nextModels[key] = {
...current,
params: {
...params,
cacheRetention: "short"
}
};
modelsMutated = true;
}
}
}
if (modelsMutated) {
nextDefaults.models = nextModels;
mutated = true;
}
}
if (!mutated) return cfg;
return {
...cfg,
agents: {
...cfg.agents,
defaults: nextDefaults
}
};
}
function applyCompactionDefaults(cfg) {
const defaults = cfg.agents?.defaults;
if (!defaults) return cfg;
const compaction = defaults?.compaction;
if (compaction?.mode) return cfg;
return {
...cfg,
agents: {
...cfg.agents,
defaults: {
...defaults,
compaction: {
...compaction,
mode: "safeguard"
}
}
}
};
}
//#endregion
//#region src/config/env-preserve.ts
/**
* Preserves `${VAR}` environment variable references during config write-back.
*
* When config is read, `${VAR}` references are resolved to their values.
* When writing back, callers pass the resolved config. This module detects
* values that match what a `${VAR}` reference would resolve to and restores
* the original reference, so env var references survive config round-trips.
*
* A value is restored only if:
* 1. The pre-substitution value contained a `${VAR}` pattern
* 2. Resolving that pattern with current env vars produces the incoming value
*
* If a caller intentionally set a new value (different from what the env var
* resolves to), the new value is kept as-is.
*/
const ENV_VAR_PATTERN = /\$\{[A-Z_][A-Z0-9_]*\}/;
/**
* Check if a string contains any `${VAR}` env var references.
*/
function hasEnvVarRef(value) {
return ENV_VAR_PATTERN.test(value);
}
/**
* Resolve `${VAR}` references in a single string using the given env.
* Returns null if any referenced var is missing (instead of throwing).
*
* Mirrors the substitution semantics of `substituteString` in env-substitution.ts:
* - `${VAR}` → env value (returns null if missing)
* - `$${VAR}` → literal `${VAR}` (escape sequence)
*/
function tryResolveString(template, env) {
const ENV_VAR_NAME = /^[A-Z_][A-Z0-9_]*$/;
const chunks = [];
for (let i = 0; i < template.length; i++) {
if (template[i] === "$") {
if (template[i + 1] === "$" && template[i + 2] === "{") {
const start = i + 3;
const end = template.indexOf("}", start);
if (end !== -1) {
const name = template.slice(start, end);
if (ENV_VAR_NAME.test(name)) {
chunks.push(`\${${name}}`);
i = end;
continue;
}
}
}
if (template[i + 1] === "{") {
const start = i + 2;
const end = template.indexOf("}", start);
if (end !== -1) {
const name = template.slice(start, end);
if (ENV_VAR_NAME.test(name)) {
const val = env[name];
if (val === void 0 || val === "") return null;
chunks.push(val);
i = end;
continue;
}
}
}
}
chunks.push(template[i]);
}
return chunks.join("");
}
/**
* Deep-walk the incoming config and restore `${VAR}` references from the
* pre-substitution parsed config wherever the resolved value matches.
*
* @param incoming - The resolved config about to be written
* @param parsed - The pre-substitution parsed config (from the current file on disk)
* @param env - Environment variables for verification
* @returns A new config object with env var references restored where appropriate
*/
function restoreEnvVarRefs(incoming, parsed, env = process.env) {
if (parsed === null || parsed === void 0) return incoming;
if (typeof incoming === "string" && typeof parsed === "string") {
if (hasEnvVarRef(parsed)) {
if (tryResolveString(parsed, env) === incoming) return parsed;
}
return incoming;
}
if (Array.isArray(incoming) && Array.isArray(parsed)) return incoming.map((item, i) => i < parsed.length ? restoreEnvVarRefs(item, parsed[i], env) : item);
if (isPlainObject$2(incoming) && isPlainObject$2(parsed)) {
const result = {};
for (const [key, value] of Object.entries(incoming)) if (key in parsed) result[key] = restoreEnvVarRefs(value, parsed[key], env);
else result[key] = value;
return result;
}
return incoming;
}
//#endregion
//#region src/config/env-substitution.ts
/**
* Environment variable substitution for config values.
*
* Supports `${VAR_NAME}` syntax in string values, substituted at config load time.
* - Only uppercase env vars are matched: `[A-Z_][A-Z0-9_]*`
* - Escape with `$${}` to output literal `${}`
* - Missing env vars throw `MissingEnvVarError` with context
*
* @example
* ```json5
* {
* models: {
* providers: {
* "vercel-gateway": {
* apiKey: "${VERCEL_GATEWAY_API_KEY}"
* }
* }
* }
* }
* ```
*/
const ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
var MissingEnvVarError = class extends Error {
constructor(varName, configPath) {
super(`Missing env var "${varName}" referenced at config path: ${configPath}`);
this.varName = varName;
this.configPath = configPath;
this.name = "MissingEnvVarError";
}
};
function parseEnvTokenAt(value, index) {
if (value[index] !== "$") return null;
const next = value[index + 1];
const afterNext = value[index + 2];
if (next === "$" && afterNext === "{") {
const start = index + 3;
const end = value.indexOf("}", start);
if (end !== -1) {
const name = value.slice(start, end);
if (ENV_VAR_NAME_PATTERN.test(name)) return {
kind: "escaped",
name,
end
};
}
}
if (next === "{") {
const start = index + 2;
const end = value.indexOf("}", start);
if (end !== -1) {
const name = value.slice(start, end);
if (ENV_VAR_NAME_PATTERN.test(name)) return {
kind: "substitution",
name,
end
};
}
}
return null;
}
function substituteString(value, env, configPath) {
if (!value.includes("$")) return value;
const chunks = [];
for (let i = 0; i < value.length; i += 1) {
const char = value[i];
if (char !== "$") {
chunks.push(char);
continue;
}
const token = parseEnvTokenAt(value, i);
if (token?.kind === "escaped") {
chunks.push(`\${${token.name}}`);
i = token.end;
continue;
}
if (token?.kind === "substitution") {
const envValue = env[token.name];
if (envValue === void 0 || envValue === "") throw new MissingEnvVarError(token.name, configPath);
chunks.push(envValue);
i = token.end;
continue;
}
chunks.push(char);
}
return chunks.join("");
}
function containsEnvVarReference(value) {
if (!value.includes("$")) return false;
for (let i = 0; i < value.length; i += 1) {
if (value[i] !== "$") continue;
const token = parseEnvTokenAt(value, i);
if (token?.kind === "escaped") {
i = token.end;
continue;
}
if (token?.kind === "substitution") return true;
}
return false;
}
function substituteAny(value, env, path) {
if (typeof value === "string") return substituteString(value, env, path);
if (Array.isArray(value)) return value.map((item, index) => substituteAny(item, env, `${path}[${index}]`));
if (isPlainObject$2(value)) {
const result = {};
for (const [key, val] of Object.entries(value)) result[key] = substituteAny(val, env, path ? `${path}.${key}` : key);
return result;
}
return value;
}
/**
* Resolves `${VAR_NAME}` environment variable references in config values.
*
* @param obj - The parsed config object (after JSON5 parse and $include resolution)
* @param env - Environment variables to use for substitution (defaults to process.env)
* @returns The config object with env vars substituted
* @throws {MissingEnvVarError} If a referenced env var is not set or empty
*/
function resolveConfigEnvVars(obj, env = process.env) {
return substituteAny(obj, env, "");
}
//#endregion
//#region src/config/includes.ts
/**
* Config includes: $include directive for modular configs
*
* @example
* ```json5
* {
* "$include": "./base.json5", // single file
* "$include": ["./a.json5", "./b.json5"] // merge multiple
* }
* ```
*/
const INCLUDE_KEY = "$include";
const MAX_INCLUDE_DEPTH = 10;
var ConfigIncludeError = class extends Error {
constructor(message, includePath, cause) {
super(message);
this.includePath = includePath;
this.cause = cause;
this.name = "ConfigIncludeError";
}
};
var CircularIncludeError = class extends ConfigIncludeError {
constructor(chain) {
super(`Circular include detected: ${chain.join(" -> ")}`, chain[chain.length - 1]);
this.chain = chain;
this.name = "CircularIncludeError";
}
};
/** Deep merge: arrays concatenate, objects merge recursively, primitives: source wins */
function deepMerge(target, source) {
if (Array.isArray(target) && Array.isArray(source)) return [...target, ...source];
if (isPlainObject$2(target) && isPlainObject$2(source)) {
const result = { ...target };
for (const key of Object.keys(source)) {
if (isBlockedObjectKey(key)) continue;
result[key] = key in result ? deepMerge(result[key], source[key]) : source[key];
}
return result;
}
return source;
}
var IncludeProcessor = class IncludeProcessor {
constructor(basePath, resolver, rootDir) {
this.basePath = basePath;
this.resolver = resolver;
this.visited = /* @__PURE__ */ new Set();
this.depth = 0;
this.visited.add(path.normalize(basePath));
this.rootDir = path.normalize(rootDir ?? path.dirname(basePath));
this.rootRealDir = path.normalize(safeRealpath(this.rootDir));
}
process(obj) {
if (Array.isArray(obj)) return obj.map((item) => this.process(item));
if (!isPlainObject$2(obj)) return obj;
if (!(INCLUDE_KEY in obj)) return this.processObject(obj);
return this.processInclude(obj);
}
processObject(obj) {
const result = {};
for (const [key, value] of Object.entries(obj)) result[key] = this.process(value);
return result;
}
processInclude(obj) {
const includeValue = obj[INCLUDE_KEY];
const otherKeys = Object.keys(obj).filter((k) => k !== INCLUDE_KEY);
const included = this.resolveInclude(includeValue);
if (otherKeys.length === 0) return included;
if (!isPlainObject$2(included)) throw new ConfigIncludeError("Sibling keys require included content to be an object", typeof includeValue === "string" ? includeValue : INCLUDE_KEY);
const rest = {};
for (const key of otherKeys) rest[key] = this.process(obj[key]);
return deepMerge(included, rest);
}
resolveInclude(value) {
if (typeof value === "string") return this.loadFile(value);
if (Array.isArray(value)) return value.reduce((merged, item) => {
if (typeof item !== "string") throw new ConfigIncludeError(`Invalid $include array item: expected string, got ${typeof item}`, String(item));
return deepMerge(merged, this.loadFile(item));
}, {});
throw new ConfigIncludeError(`Invalid $include value: expected string or array of strings, got ${typeof value}`, String(value));
}
loadFile(includePath) {
const resolvedPath = this.resolvePath(includePath);
this.checkCircular(resolvedPath);
this.checkDepth(includePath);
const raw = this.readFile(includePath, resolvedPath);
const parsed = this.parseFile(includePath, resolvedPath, raw);
return this.processNested(resolvedPath, parsed);
}
resolvePath(includePath) {
const configDir = path.dirname(this.basePath);
const resolved = path.isAbsolute(includePath) ? includePath : path.resolve(configDir, includePath);
const normalized = path.normalize(resolved);
if (!isPathInside(this.rootDir, normalized)) throw new ConfigIncludeError(`Include path escapes config directory: ${includePath} (root: ${this.rootDir})`, includePath);
try {
const real = fs.realpathSync(normalized);
if (!isPathInside(this.rootRealDir, real)) throw new ConfigIncludeError(`Include path resolves outside config directory (symlink): ${includePath} (root: ${this.rootDir})`, includePath);
} catch (err) {
if (err instanceof ConfigIncludeError) throw err;
}
return normalized;
}
checkCircular(resolvedPath) {
if (this.visited.has(resolvedPath)) throw new CircularIncludeError([...this.visited, resolvedPath]);
}
checkDepth(includePath) {
if (this.depth >= MAX_INCLUDE_DEPTH) throw new ConfigIncludeError(`Maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded at: ${includePath}`, includePath);
}
readFile(includePath, resolvedPath) {
try {
return this.resolver.readFile(resolvedPath);
} catch (err) {
throw new ConfigIncludeError(`Failed to read include file: ${includePath} (resolved: ${resolvedPath})`, includePath, err instanceof Error ? err : void 0);
}
}
parseFile(includePath, resolvedPath, raw) {
try {
return this.resolver.parseJson(raw);
} catch (err) {
throw new ConfigIncludeError(`Failed to parse include file: ${includePath} (resolved: ${resolvedPath})`, includePath, err instanceof Error ? err : void 0);
}
}
processNested(resolvedPath, parsed) {
const nested = new IncludeProcessor(resolvedPath, this.resolver, this.rootDir);
nested.visited = new Set([...this.visited, resolvedPath]);
nested.depth = this.depth + 1;
return nested.process(parsed);
}
};
function safeRealpath(target) {
try {
return fs.realpathSync(target);
} catch {
return target;
}
}
const defaultResolver = {
readFile: (p) => fs.readFileSync(p, "utf-8"),
parseJson: (raw) => JSON5.parse(raw)
};
/**
* Resolves all $include directives in a parsed config object.
*/
function resolveConfigIncludes(obj, configPath, resolver = defaultResolver) {
return new IncludeProcessor(configPath, resolver).process(obj);
}
//#endregion
//#region src/config/discord-preview-streaming.ts
function normalizeStreamingMode(value) {
if (typeof value !== "string") return null;
return value.trim().toLowerCase() || null;
}
function parseStreamingMode(value) {
const normalized = normalizeStreamingMode(value);
if (normalized === "off" || normalized === "partial" || normalized === "block" || normalized === "progress") return normalized;
return null;
}
function parseDiscordPreviewStreamMode(value) {
const parsed = parseStreamingMode(value);
if (!parsed) return null;
return parsed === "progress" ? "partial" : parsed;
}
function parseSlackLegacyDraftStreamMode(value) {
const normalized = normalizeStreamingMode(value);
if (normalized === "replace" || normalized === "status_final" || normalized === "append") return normalized;
return null;
}
function mapSlackLegacyDraftStreamModeToStreaming(mode) {
if (mode === "append") return "block";
if (mode === "status_final") return "progress";
return "partial";
}
function mapStreamingModeToSlackLegacyDraftStreamMode(mode) {
if (mode === "block") return "append";
if (mode === "progress") return "status_final";
return "replace";
}
function resolveTelegramPreviewStreamMode(params = {}) {
const parsedStreaming = parseStreamingMode(params.streaming);
if (parsedStreaming) {
if (parsedStreaming === "progress") return "partial";
return parsedStreaming;
}
const legacy = parseDiscordPreviewStreamMode(params.streamMode);
if (legacy) return legacy;
if (typeof params.streaming === "boolean") return params.streaming ? "partial" : "off";
return "off";
}
function resolveDiscordPreviewStreamMode(params = {}) {
const parsedStreaming = parseDiscordPreviewStreamMode(params.streaming);
if (parsedStreaming) return parsedStreaming;
const legacy = parseDiscordPreviewStreamMode(params.streamMode);
if (legacy) return legacy;
if (typeof params.streaming === "boolean") return params.streaming ? "partial" : "off";
return "off";
}
function resolveSlackStreamingMode(params = {}) {
const parsedStreaming = parseStreamingMode(params.streaming);
if (parsedStreaming) return parsedStreaming;
const legacyStreamMode = parseSlackLegacyDraftStreamMode(params.streamMode);
if (legacyStreamMode) return mapSlackLegacyDraftStreamModeToStreaming(legacyStreamMode);
if (typeof params.streaming === "boolean") return "partial";
return "partial";
}
function resolveSlackNativeStreaming(params = {}) {
if (typeof params.nativeStreaming === "boolean") return params.nativeStreaming;
if (typeof params.streaming === "boolean") return params.streaming;
return true;
}
//#endregion
//#region src/infra/exec-safety.ts
const SHELL_METACHARS = /[;&|`$<>]/;
const CONTROL_CHARS = /[\r\n]/;
const QUOTE_CHARS = /["']/;
const BARE_NAME_PATTERN = /^[A-Za-z0-9._+-]+$/;
function isLikelyPath(value) {
if (value.startsWith(".") || value.startsWith("~")) return true;
if (value.includes("/") || value.includes("\\")) return true;
return /^[A-Za-z]:[\\/]/.test(value);
}
function isSafeExecutableValue(value) {
if (!value) return false;
const trimmed = value.trim();
if (!trimmed) return false;
if (trimmed.includes("\0")) return false;
if (CONTROL_CHARS.test(trimmed)) return false;
if (SHELL_METACHARS.test(trimmed)) return false;
if (QUOTE_CHARS.test(trimmed)) return false;
if (isLikelyPath(trimmed)) return true;
if (trimmed.startsWith("-")) return false;
return BARE_NAME_PATTERN.test(trimmed);
}
//#endregion
//#region src/config/legacy.shared.ts
const getRecord = (value) => isRecord(value) ? value : null;
const ensureRecord = (root, key) => {
const existing = root[key];
if (isRecord(existing)) return existing;
const next = {};
root[key] = next;
return next;
};
const mergeMissing = (target, source) => {
for (const [key, value] of Object.entries(source)) {
if (value === void 0 || isBlockedObjectKey(key)) continue;
const existing = target[key];
if (existing === void 0) {
target[key] = value;
continue;
}
if (isRecord(existing) && isRecord(value)) mergeMissing(existing, value);
}
};
const mapLegacyAudioTranscription = (value) => {
const transcriber = getRecord(value);
const command = Array.isArray(transcriber?.command) ? transcriber?.command : null;
if (!command || command.length === 0) return null;
if (typeof command[0] !== "string") return null;
if (!command.every((part) => typeof part === "string")) return null;
const rawExecutable = command[0].trim();
if (!rawExecutable) return null;
if (!isSafeExecutableValue(rawExecutable)) return null;
const args = command.slice(1);
const timeoutSeconds = typeof transcriber?.timeoutSeconds === "number" ? transcriber?.timeoutSeconds : void 0;
const result = {
command: rawExecutable,
type: "cli"
};
if (args.length > 0) result.args = args;
if (timeoutSeconds !== void 0) result.timeoutSeconds = timeoutSeconds;
return result;
};
const getAgentsList = (agents) => {
const list = agents?.list;
return Array.isArray(list) ? list : [];
};
const resolveDefaultAgentIdFromRaw = (raw) => {
const list = getAgentsList(getRecord(raw.agents));
const defaultEntry = list.find((entry) => isRecord(entry) && entry.default === true && typeof entry.id === "string" && entry.id.trim() !== "");
if (defaultEntry) return defaultEntry.id.trim();
const routing = getRecord(raw.routing);
const routingDefault = typeof routing?.defaultAgentId === "string" ? routing.defaultAgentId.trim() : "";
if (routingDefault) return routingDefault;
const firstEntry = list.find((entry) => isRecord(entry) && typeof entry.id === "string" && entry.id.trim() !== "");
if (firstEntry) return firstEntry.id.trim();
return "main";
};
const ensureAgentEntry = (list, id) => {
const normalized = id.trim();
const existing = list.find((entry) => isRecord(entry) && typeof entry.id === "string" && entry.id.trim() === normalized);
if (existing) return existing;
const created = { id: normalized };
list.push(created);
return created;
};
//#endregion
//#region src/config/legacy.migrations.part-1.ts
function migrateBindings(raw, changes, changeNote, mutator) {
const bindings = Array.isArray(raw.bindings) ? raw.bindings : null;
if (!bindings) return;
let touched = false;
for (const entry of bindings) {
if (!isRecord(entry)) continue;
const match = getRecord(entry.match);
if (!match) continue;
if (!mutator(match)) continue;
entry.match = match;
touched = true;
}
if (touched) {
raw.bindings = bindings;
changes.push(changeNote);
}
}
function ensureDefaultGroupEntry(section) {
const groups = isRecord(section.groups) ? section.groups : {};
const defaultKey = "*";
return {
groups,
entry: isRecord(groups[defaultKey]) ? groups[defaultKey] : {}
};
}
const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
{
id: "bindings.match.provider->bindings.match.channel",
describe: "Move bindings[].match.provider to bindings[].match.channel",
apply: (raw, changes) => {
migrateBindings(raw, changes, "Moved bindings[].match.provider → bindings[].match.channel.", (match) => {
if (typeof match.channel === "string" && match.channel.trim()) return false;
const provider = typeof match.provider === "string" ? match.provider.trim() : "";
if (!provider) return false;
match.channel = provider;
delete match.provider;
return true;
});
}
},
{
id: "bindings.match.accountID->bindings.match.accountId",
describe: "Move bindings[].match.accountID to bindings[].match.accountId",
apply: (raw, changes) => {
migrateBindings(raw, changes, "Moved bindings[].match.accountID → bindings[].match.accountId.", (match) => {
if (match.accountId !== void 0) return false;
const accountID = typeof match.accountID === "string" ? match.accountID.trim() : match.accountID;
if (!accountID) return false;
match.accountId = accountID;
delete match.accountID;
return true;
});
}
},
{
id: "session.sendPolicy.rules.match.provider->match.channel",
describe: "Move session.sendPolicy.rules[].match.provider to match.channel",
apply: (raw, changes) => {
const session = getRecord(raw.session);
if (!session) return;
const sendPolicy = getRecord(session.sendPolicy);
if (!sendPolicy) return;
const rules = Array.isArray(sendPolicy.rules) ? sendPolicy.rules : null;
if (!rules) return;
let touched = false;
for (const rule of rules) {
if (!isRecord(rule)) continue;
const match = getRecord(rule.match);
if (!match) continue;
if (typeof match.channel === "string" && match.channel.trim()) continue;
const provider = typeof match.provider === "string" ? match.provider.trim() : "";
if (!provider) continue;
match.channel = provider;
delete match.provider;
rule.match = match;
touched = true;
}
if (touched) {
sendPolicy.rules = rules;
session.sendPolicy = sendPolicy;
raw.session = session;
changes.push("Moved session.sendPolicy.rules[].match.provider → match.channel.");
}
}
},
{
id: "messages.queue.byProvider->byChannel",
describe: "Move messages.queue.byProvider to messages.queue.byChannel",
apply: (raw, changes) => {
const messages = getRecord(raw.messages);
if (!messages) return;
const queue = getRecord(messages.queue);
if (!queue) return;
if (queue.byProvider === void 0) return;
if (queue.byChannel === void 0) {
queue.byChannel = queue.byProvider;
changes.push("Moved messages.queue.byProvider → messages.queue.byChannel.");
} else changes.push("Removed messages.queue.byProvider (messages.queue.byChannel already set).");
delete queue.byProvider;
messages.queue = queue;
raw.messages = messages;
}
},
{
id: "providers->channels",
describe: "Move provider config sections to channels.*",
apply: (raw, changes) => {
const legacyEntries = [
"whatsapp",
"telegram",
"discord",
"slack",
"signal",
"imessage",
"msteams"
].filter((key) => isRecord(raw[key]));
if (legacyEntries.length === 0) return;
const channels = ensureRecord(raw, "channels");
for (const key of legacyEntries) {
const legacy = getRecord(raw[key]);
if (!legacy) continue;
const channelEntry = ensureRecord(channels, key);
const hadEntries = Object.keys(channelEntry).length > 0;
mergeMissing(channelEntry, legacy);
channels[key] = channelEntry;
delete raw[key];
changes.push(hadEntries ? `Merged ${key} → channels.${key}.` : `Moved ${key} → channels.${key}.`);
}
raw.channels = channels;
}
},
{
id: "channels.streaming-keys->channels.streaming",
describe: "Normalize legacy streaming keys to channels.<provider>.streaming (Telegram/Discord/Slack)",
apply: (raw, changes) => {
const channels = getRecord(raw.channels);
if (!channels) return;
const migrateProviderEntry = (params) => {
const migrateCommonStreamingMode = (resolveMode) => {
const hasLegacyStreamMode = params.entry.streamMode !== void 0;
const legacyStreaming = params.entry.streaming;
if (!hasLegacyStreamMode && typeof legacyStreaming !== "boolean") return false;
const resolved = resolveMode(params.entry);
params.entry.streaming = resolved;
if (hasLegacyStreamMode) {
delete params.entry.streamMode;
changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolved}).`);
}
if (typeof legacyStreaming === "boolean") changes.push(`Normalized ${params.pathPrefix}.streaming boolean → enum (${resolved}).`);
return true;
};
const hasLegacyStreamMode = params.entry.streamMode !== void 0;
const legacyStreaming = params.entry.streaming;
const legacyNativeStreaming = params.entry.nativeStreaming;
if (params.provider === "telegram") {
migrateCommonStreamingMode(resolveTelegramPreviewStreamMode);
return;
}
if (params.provider === "discord") {
migrateCommonStreamingMode(resolveDiscordPreviewStreamMode);
return;
}
if (!hasLegacyStreamMode && typeof legacyStreaming !== "boolean") return;
const resolvedStreaming = resolveSlackStreamingMode(params.entry);
const resolvedNativeStreaming = resolveSlackNativeStreaming(params.entry);
params.entry.streaming = resolvedStreaming;
params.entry.nativeStreaming = resolvedNativeStreaming;
if (hasLegacyStreamMode) {
delete params.entry.streamMode;
changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolvedStreaming}).`);
}
if (typeof legacyStreaming === "boolean") changes.push(`Moved ${params.pathPrefix}.streaming (boolean) → ${params.pathPrefix}.nativeStreaming (${resolvedNativeStreaming}).`);
else if (typeof legacyNativeStreaming !== "boolean" && hasLegacyStreamMode) changes.push(`Set ${params.pathPrefix}.nativeStreaming → ${resolvedNativeStreaming}.`);
};
const migrateProvider = (provider) => {
const providerEntry = getRecord(channels[provider]);
if (!providerEntry) return;
migrateProviderEntry({
provider,
entry: providerEntry,
pathPrefix: `channels.${provider}`
});
const accounts = getRecord(providerEntry.accounts);
if (!accounts) return;
for (const [accountId, accountValue] of Object.entries(accounts)) {
const account = getRecord(accountValue);
if (!account) continue;
migrateProviderEntry({
provider,
entry: account,
pathPrefix: `channels.${provider}.accounts.${accountId}`
});
}
};
migrateProvider("telegram");
migrateProvider("discord");
migrateProvider("slack");
}
},
{
id: "routing.allowFrom->channels.whatsapp.allowFrom",
describe: "Move routing.allowFrom to channels.whatsapp.allowFrom",
apply: (raw, changes) => {
const routing = raw.routing;
if (!routing || typeof routing !== "object") return;
const allowFrom = routing.allowFrom;
if (allowFrom === void 0) return;
const channels = getRecord(raw.channels);
const whatsapp = channels ? getRecord(channels.whatsapp) : null;
if (!whatsapp) {
delete routing.allowFrom;
if (Object.keys(routing).length === 0) delete raw.routing;
changes.push("Removed routing.allowFrom (channels.whatsapp not configured).");
return;
}
if (whatsapp.allowFrom === void 0) {
whatsapp.allowFrom = allowFrom;
changes.push("Moved routing.allowFrom → channels.whatsapp.allowFrom.");
} else changes.push("Removed routing.allowFrom (channels.whatsapp.allowFrom already set).");
delete routing.allowFrom;
if (Object.keys(routing).length === 0) delete raw.routing;
channels.whatsapp = whatsapp;
raw.channels = channels;
}
},
{
id: "routing.groupChat.requireMention->groups.*.requireMention",
describe: "Move routing.groupChat.requireMention to channels.whatsapp/telegram/imessage groups",
apply: (raw, changes) => {
const routing = raw.routing;
if (!routing || typeof routing !== "object") return;
const groupChat = routing.groupChat && typeof routing.groupChat === "object" ? routing.groupChat : null;
if (!groupChat) return;
const requireMention = groupChat.requireMention;
if (requireMention === void 0) return;
const channels = ensureRecord(raw, "channels");
const applyTo = (key, options) => {
if (options?.requireExisting && !isRecord(channels[key])) return;
const section = channels[key] && typeof channels[key] === "object" ? channels[key] : {};
const { groups, entry } = ensureDefaultGroupEntry(section);
const defaultKey = "*";
if (entry.requireMention === void 0) {
entry.requireMention = requireMention;
groups[defaultKey] = entry;
section.groups = groups;
channels[key] = section;
changes.push(`Moved routing.groupChat.requireMention → channels.${key}.groups."*".requireMention.`);
} else changes.push(`Removed routing.groupChat.requireMention (channels.${key}.groups."*" already set).`);
};
applyTo("whatsapp", { requireExisting: true });
applyTo("telegram");
applyTo("imessage");
delete groupChat.requireMention;
if (Object.keys(groupChat).length === 0) delete routing.groupChat;
if (Object.keys(routing).length === 0) delete raw.routing;
raw.channels = channels;
}
},
{
id: "gateway.token->gateway.auth.token",
describe: "Move gateway.token to gateway.auth.token",
apply: (raw, changes) => {
const gateway = raw.gateway;
if (!gateway || typeof gateway !== "object") return;
const token = gateway.token;
if (token === void 0) return;
const gatewayObj = gateway;
const auth = gatewayObj.auth && typeof gatewayObj.auth === "object" ? gatewayObj.auth : {};
if (auth.token === void 0) {
auth.token = token;
if (!auth.mode) auth.mode = "token";
changes.push("Moved gateway.token → gateway.auth.token.");
} else changes.push("Removed gateway.token (gateway.auth.token already set).");
delete gatewayObj.token;
if (Object.keys(auth).length > 0) gatewayObj.auth = auth;
raw.gateway = gatewayObj;
}
},
{
id: "telegram.requireMention->channels.telegram.groups.*.requireMention",
describe: "Move telegram.requireMention to channels.telegram.groups.*.requireMention",
apply: (raw, changes) => {
const channels = ensureRecord(raw, "channels");
const telegram = channels.telegram;
if (!telegram || typeof telegram !== "object") return;
const requireMention = telegram.requireMention;
if (requireMention === void 0) return;
const { groups, entry } = ensureDefaultGroupEntry(telegram);
const defaultKey = "*";
if (entry.requireMention === void 0) {
entry.requireMention = requireMention;
groups[defaultKey] = entry;
telegram.groups = groups;
changes.push("Moved telegram.requireMention → channels.telegram.groups.\"*\".requireMention.");
} else changes.push("Removed telegram.requireMention (channels.telegram.groups.\"*\" already set).");
delete telegram.requireMention;
channels.telegram = telegram;
raw.channels = channels;
}
}
];
//#endregion
//#region src/config/legacy.migrations.part-2.ts
function applyLegacyAudioTranscriptionModel(params) {
const mapped = mapLegacyAudioTranscription(params.source);
if (!mapped) {
params.changes.push(params.invalidMessage);
return;
}
const mediaAudio = ensureRecord(ensureRecord(ensureRecord(params.raw, "tools"), "media"), "audio");
if ((Array.isArray(mediaAudio.models) ? mediaAudio.models : []).length === 0) {
mediaAudio.enabled = true;
mediaAudio.models = [mapped];
params.changes.push(params.movedMessage);
return;
}
params.changes.push(params.alreadySetMessage);
}
const LEGACY_CONFIG_MIGRATIONS_PART_2 = [
{
id: "agent.model-config-v2",
describe: "Migrate legacy agent.model/allowedModels/modelAliases/modelFallbacks/imageModelFallbacks to agent.models + model lists",
apply: (raw, changes) => {
const agentRoot = getRecord(raw.agent);
const defaults = getRecord(getRecord(raw.agents)?.defaults);
const agent = agentRoot ?? defaults;
if (!agent) return;
const label = agentRoot ? "agent" : "agents.defaults";
const legacyModel = typeof agent.model === "string" ? String(agent.model) : void 0;
const legacyImageModel = typeof agent.imageModel === "string" ? String(agent.imageModel) : void 0;
const legacyAllowed = Array.isArray(agent.allowedModels) ? agent.allowedModels.map(String) : [];
const legacyModelFallbacks = Array.isArray(agent.modelFallbacks) ? agent.modelFallbacks.map(String) : [];
const legacyImageModelFallbacks = Array.isArray(agent.imageModelFallbacks) ? agent.imageModelFallbacks.map(String) : [];
const legacyAliases = agent.modelAliases && typeof agent.modelAliases === "object" ? agent.modelAliases : {};
if (!(legacyModel || legacyImageModel || legacyAllowed.length > 0 || legacyModelFallbacks.length > 0 || legacyImageModelFallbacks.length > 0 || Object.keys(legacyAliases).length > 0)) return;
const models = agent.models && typeof agent.models === "object" ? agent.models : {};
const ensureModel = (rawKey) => {
if (typeof rawKey !== "string") return;
const key = rawKey.trim();
if (!key) return;
if (!models[key]) models[key] = {};
};
ensureModel(legacyModel);
ensureModel(legacyImageModel);
for (const key of legacyAllowed) ensureModel(key);
for (const key of legacyModelFallbacks) ensureModel(key);
for (const key of legacyImageModelFallbacks) ensureModel(key);
for (const target of Object.values(legacyAliases)) {
if (typeof target !== "string") continue;
ensureModel(target);
}
for (const [alias, targetRaw] of Object.entries(legacyAliases)) {
if (typeof targetRaw !== "string") continue;
const target = targetRaw.trim();
if (!target) continue;
const entry = models[target] && typeof models[target] === "object" ? models[target] : {};
if (!("alias" in entry)) {
entry.alias = alias;
models[target] = entry;
}
}
const currentModel = agent.model && typeof agent.model === "object" ? agent.model : null;
if (currentModel) {
if (!currentModel.primary && legacyModel) currentModel.primary = legacyModel;
if (legacyModelFallbacks.length > 0 && (!Array.isArray(currentModel.fallbacks) || currentModel.fallbacks.length === 0)) currentModel.fallbacks = legacyModelFallbacks;
agent.model = currentModel;
} else if (legacyModel || legacyModelFallbacks.length > 0) agent.model = {
primary: legacyModel,
fallbacks: legacyModelFallbacks.length ? legacyModelFallbacks : []
};
const currentImageModel = agent.imageModel && typeof agent.imageModel === "object" ? agent.imageModel : null;
if (currentImageModel) {
if (!currentImageModel.primary && legacyImageModel) currentImageModel.primary = legacyImageModel;
if (legacyImageModelFallbacks.length > 0 && (!Array.isArray(currentImageModel.fallbacks) || currentImageModel.fallbacks.length === 0)) currentImageModel.fallbacks = legacyImageModelFallbacks;
agent.imageModel = currentImageModel;
} else if (legacyImageModel || legacyImageModelFallbacks.length > 0) agent.imageModel = {
primary: legacyImageModel,
fallbacks: legacyImageModelFallbacks.length ? legacyImageModelFallbacks : []
};
agent.models = models;
if (legacyModel !== void 0) changes.push(`Migrated ${label}.model string → ${label}.model.primary.`);
if (legacyModelFallbacks.length > 0) changes.push(`Migrated ${label}.modelFallbacks → ${label}.model.fallbacks.`);
if (legacyImageModel !== void 0) changes.push(`Migrated ${label}.imageModel string → ${label}.imageModel.primary.`);
if (legacyImageModelFallbacks.length > 0) changes.push(`Migrated ${label}.imageModelFallbacks → ${label}.imageModel.fallbacks.`);
if (legacyAllowed.length > 0) changes.push(`Migrated ${label}.allowedModels → ${label}.models.`);
if (Object.keys(legacyAliases).length > 0) changes.push(`Migrated ${label}.modelAliases → ${label}.models.*.alias.`);
delete agent.allowedModels;
delete agent.modelAliases;
delete agent.modelFallbacks;
delete agent.imageModelFallbacks;
}
},
{
id: "routing.agents-v2",
describe: "Move routing.agents/defaultAgentId to agents.list",
apply: (raw, changes) => {
const routing = getRecord(raw.routing);
if (!routing) return;
const routingAgents = getRecord(routing.agents);
const agents = ensureRecord(raw, "agents");
const list = getAgentsList(agents);
if (routingAgents) {
for (const [rawId, entryRaw] of Object.entries(routingAgents)) {
const agentId = String(rawId ?? "").trim();
const entry = getRecord(entryRaw);
if (!agentId || !entry) continue;
const target = ensureAgentEntry(list, agentId);
const entryCopy = { ...entry };
if ("mentionPatterns" in entryCopy) {
const mentionPatterns = entryCopy.mentionPatterns;
const groupChat = ensureRecord(target, "groupChat");
if (groupChat.mentionPatterns === void 0) {
groupChat.mentionPatterns = mentionPatterns;
changes.push(`Moved routing.agents.${agentId}.mentionPatterns → agents.list (id "${agentId}").groupChat.mentionPatterns.`);
} else changes.push(`Removed routing.agents.${agentId}.mentionPatterns (agents.list groupChat mentionPatterns already set).`);
delete entryCopy.mentionPatterns;
}
const legacyGroupChat = getRecord(entryCopy.groupChat);
if (legacyGroupChat) {
mergeMissing(ensureRecord(target, "groupChat"), legacyGroupChat);
delete entryCopy.groupChat;
}
const legacySandbox = getRecord(entryCopy.sandbox);
if (legacySandbox) {
const sandboxTools = getRecord(legacySandbox.tools);
if (sandboxTools) {
mergeMissing(ensureRecord(ensureRecord(ensureRecord(target, "tools"), "sandbox"), "tools"), sandboxTools);
delete legacySandbox.tools;
changes.push(`Moved routing.agents.${agentId}.sandbox.tools → agents.list (id "${agentId}").tools.sandbox.tools.`);
}
entryCopy.sandbox = legacySandbox;
}
mergeMissing(target, entryCopy);
}
delete routing.agents;
changes.push("Moved routing.agents → agents.list.");
}
const defaultAgentId = typeof routing.defaultAgentId === "string" ? routing.defaultAgentId.trim() : "";
if (defaultAgentId) {
if (!list.some((entry) => isRecord(entry) && entry.default === true)) {
const entry = ensureAgentEntry(list, defaultAgentId);
entry.default = true;
changes.push(`Moved routing.defaultAgentId → agents.list (id "${defaultAgentId}").default.`);
} else changes.push("Removed routing.defaultAgentId (agents.list default already set).");
delete routing.defaultAgentId;
}
if (list.length > 0) agents.list = list;
if (Object.keys(routing).length === 0) delete raw.routing;
}
},
{
id: "routing.config-v2",
describe: "Move routing bindings/groupChat/queue/agentToAgent/transcribeAudio",
apply: (raw, changes) => {
const routing = getRecord(raw.routing);
if (!routing) return;
if (routing.bindings !== void 0) {
if (raw.bindings === void 0) {
raw.bindings = routing.bindings;
changes.push("Moved routing.bindings → bindings.");
} else changes.push("Removed routing.bindings (bindings already set).");
delete routing.bindings;
}
if (routing.agentToAgent !== void 0) {
const tools = ensureRecord(raw, "tools");
if (tools.agentToAgent === void 0) {
tools.agentToAgent = routing.agentToAgent;
changes.push("Moved routing.agentToAgent → tools.agentToAgent.");
} else changes.push("Removed routing.agentToAgent (tools.agentToAgent already set).");
delete routing.agentToAgent;
}
if (routing.queue !== void 0) {
const messages = ensureRecord(raw, "messages");
if (messages.queue === void 0) {
messages.queue = routing.queue;
changes.push("Moved routing.queue → messages.queue.");
} else changes.push("Removed routing.queue (messages.queue already set).");
delete routing.queue;
}
const groupChat = getRecord(routing.groupChat);
if (groupChat) {
const historyLimit = groupChat.historyLimit;
if (historyLimit !== void 0) {
const messagesGroup = ensureRecord(ensureRecord(raw, "messages"), "groupChat");
if (messagesGroup.historyLimit === void 0) {
messagesGroup.historyLimit = historyLimit;
changes.push("Moved routing.groupChat.historyLimit → messages.groupChat.historyLimit.");
} else changes.push("Removed routing.groupChat.historyLimit (messages.groupChat.historyLimit already set).");
delete groupChat.historyLimit;
}
const mentionPatterns = groupChat.mentionPatterns;
if (mentionPatterns !== void 0) {
const messagesGroup = ensureRecord(ensureRecord(raw, "messages"), "groupChat");
if (messagesGroup.mentionPatterns === void 0) {
messagesGroup.mentionPatterns = mentionPatterns;
changes.push("Moved routing.groupChat.mentionPatterns → messages.groupChat.mentionPatterns.");
} else changes.push("Removed routing.groupChat.mentionPatterns (messages.groupChat.mentionPatterns already set).");
delete groupChat.mentionPatterns;
}
if (Object.keys(groupChat).length === 0) delete routing.groupChat;
else routing.groupChat = groupChat;
}
if (routing.transcribeAudio !== void 0) {
applyLegacyAudioTranscriptionModel({
raw,
source: routing.transcribeAudio,
changes,
movedMessage: "Moved routing.transcribeAudio → tools.media.audio.models.",
alreadySetMessage: "Removed routing.transcribeAudio (tools.media.audio.models already set).",
invalidMessage: "Removed routing.transcribeAudio (invalid or empty command)."
});
delete routing.transcribeAudio;
}
if (Object.keys(routing).length === 0) delete raw.routing;
}
},
{
id: "audio.transcription-v2",
describe: "Move audio.transcription to tools.media.audio.models",
apply: (raw, changes) => {
const audio = getRecord(raw.audio);
if (audio?.transcription === void 0) return;
applyLegacyAudioTranscriptionModel({
raw,
source: audio.transcription,
changes,
movedMessage: "Moved audio.transcription → tools.media.audio.models.",
alreadySetMessage: "Removed audio.transcription (tools.media.audio.models already set).",
invalidMessage: "Removed audio.transcription (invalid or empty command)."
});
delete audio.transcription;
if (Object.keys(audio).length === 0) delete raw.audio;
else raw.audio = audio;
}
}
];
//#endregion
//#region src/config/legacy.migrations.part-3.ts
const LEGACY_CONFIG_MIGRATIONS_PART_3 = [
{
id: "memorySearch->agents.defaults.memorySearch",
describe: "Move top-level memorySearch to agents.defaults.memorySearch",
apply: (raw, changes) => {
const legacyMemorySearch = getRecord(raw.memorySearch);
if (!legacyMemorySearch) return;
const agents = ensureRecord(raw, "agents");
const defaults = ensureRecord(agents, "defaults");
const existing = getRecord(defaults.memorySearch);
if (!existing) {
defaults.memorySearch = legacyMemorySearch;
changes.push("Moved memorySearch → agents.defaults.memorySearch.");
} else {
const merged = structuredClone(existing);
mergeMissing(merged, legacyMemorySearch);
defaults.memorySearch = merged;
changes.push("Merged memorySearch → agents.defaults.memorySearch (filled missing fields from legacy; kept explicit agents.defaults values).");
}
agents.defaults = defaults;
raw.agents = agents;
delete raw.memorySearch;
}
},
{
id: "auth.anthropic-claude-cli-mode-oauth",
describe: "Switch anthropic:claude-cli auth profile mode to oauth",
apply: (raw, changes) => {
const profiles = getRecord(getRecord(raw.auth)?.profiles);
if (!profiles) return;
const claudeCli = getRecord(profiles["anthropic:claude-cli"]);
if (!claudeCli) return;
if (claudeCli.mode !== "token") return;
claudeCli.mode = "oauth";
changes.push("Updated auth.profiles[\"anthropic:claude-cli\"].mode → \"oauth\".");
}
},
{
id: "tools.bash->tools.exec",
describe: "Move tools.bash to tools.exec",
apply: (raw, changes) => {
const tools = ensureRecord(raw, "tools");
const bash = getRecord(tools.bash);
if (!bash) return;
if (tools.exec === void 0) {
tools.exec = bash;
changes.push("Moved tools.bash → tools.exec.");
} else changes.push("Removed tools.bash (tools.exec already set).");
delete tools.bash;
}
},
{
id: "messages.tts.enabled->auto",
describe: "Move messages.tts.enabled to messages.tts.auto",
apply: (raw, changes) => {
const tts = getRecord(getRecord(raw.messages)?.tts);
if (!tts) return;
if (tts.auto !== void 0) {
if ("enabled" in tts) {
delete tts.enabled;
changes.push("Removed messages.tts.enabled (messages.tts.auto already set).");
}
return;
}
if (typeof tts.enabled !== "boolean") return;
tts.auto = tts.enabled ? "always" : "off";
delete tts.enabled;
changes.push(`Moved messages.tts.enabled → messages.tts.auto (${String(tts.auto)}).`);
}
},
{
id: "agent.defaults-v2",
describe: "Move agent config to agents.defaults and tools",
apply: (raw, changes) => {
const agent = getRecord(raw.agent);
if (!agent) return;
const agents = ensureRecord(raw, "agents");
const defaults = getRecord(agents.defaults) ?? {};
const tools = ensureRecord(raw, "tools");
const agentTools = getRecord(agent.tools);
if (agentTools) {
if (tools.allow === void 0 && agentTools.allow !== void 0) {
tools.allow = agentTools.allow;
changes.push("Moved agent.tools.allow → tools.allow.");
}
if (tools.deny === void 0 && agentTools.deny !== void 0) {
tools.deny = agentTools.deny;
changes.push("Moved agent.tools.deny → tools.deny.");
}
}
const elevated = getRecord(agent.elevated);
if (elevated) if (tools.elevated === void 0) {
tools.elevated = elevated;
changes.push("Moved agent.elevated → tools.elevated.");
} else changes.push("Removed agent.elevated (tools.elevated already set).");
const bash = getRecord(agent.bash);
if (bash) if (tools.exec === void 0) {
tools.exec = bash;
changes.push("Moved agent.bash → tools.exec.");
} else changes.push("Removed agent.bash (tools.exec already set).");
const sandbox = getRecord(agent.sandbox);
if (sandbox) {
const sandboxTools = getRecord(sandbox.tools);
if (sandboxTools) {
mergeMissing(ensureRecord(ensureRecord(tools, "sandbox"), "tools"), sandboxTools);
delete sandbox.tools;
changes.push("Moved agent.sandbox.tools → tools.sandbox.tools.");
}
}
const subagents = getRecord(agent.subagents);
if (subagents) {
const subagentTools = getRecord(subagents.tools);
if (subagentTools) {
mergeMissing(ensureRecord(ensureRecord(tools, "subagents"), "tools"), subagentTools);
delete subagents.tools;
changes.push("Moved agent.subagents.tools → tools.subagents.tools.");
}
}
const agentCopy = structuredClone(agent);
delete agentCopy.tools;
delete agentCopy.elevated;
delete agentCopy.bash;
if (isRecord(agentCopy.sandbox)) delete agentCopy.sandbox.tools;
if (isRecord(agentCopy.subagents)) delete agentCopy.subagents.tools;
mergeMissing(defaults, agentCopy);
agents.defaults = defaults;
raw.agents = agents;
delete raw.agent;
changes.push("Moved agent → agents.defaults.");
}
},
{
id: "identity->agents.list",
describe: "Move identity to agents.list[].identity",
apply: (raw, changes) => {
const identity = getRecord(raw.identity);
if (!identity) return;
const agents = ensureRecord(raw, "agents");
const list = getAgentsList(agents);
const defaultId = resolveDefaultAgentIdFromRaw(raw);
const entry = ensureAgentEntry(list, defaultId);
if (entry.identity === void 0) {
entry.identity = identity;
changes.push(`Moved identity → agents.list (id "${defaultId}").identity.`);
} else changes.push("Removed identity (agents.list identity already set).");
agents.list = list;
raw.agents = agents;
delete raw.identity;
}
}
];
//#endregion
//#region src/config/legacy.migrations.ts
const LEGACY_CONFIG_MIGRATIONS = [
...LEGACY_CONFIG_MIGRATIONS_PART_1,
...LEGACY_CONFIG_MIGRATIONS_PART_2,
...LEGACY_CONFIG_MIGRATIONS_PART_3
];
//#endregion
//#region src/config/legacy.rules.ts
const LEGACY_CONFIG_RULES = [
{
path: ["whatsapp"],
message: "whatsapp config moved to channels.whatsapp (auto-migrated on load)."
},
{
path: ["telegram"],
message: "telegram config moved to channels.telegram (auto-migrated on load)."
},
{
path: ["discord"],
message: "discord config moved to channels.discord (auto-migrated on load)."
},
{
path: ["slack"],
message: "slack config moved to channels.slack (auto-migrated on load)."
},
{
path: ["signal"],
message: "signal config moved to channels.signal (auto-migrated on load)."
},
{
path: ["imessage"],
message: "imessage config moved to channels.imessage (auto-migrated on load)."
},
{
path: ["msteams"],
message: "msteams config moved to channels.msteams (auto-migrated on load)."
},
{
path: ["routing", "allowFrom"],
message: "routing.allowFrom was removed; use channels.whatsapp.allowFrom instead (auto-migrated on load)."
},
{
path: ["routing", "bindings"],
message: "routing.bindings was moved; use top-level bindings instead (auto-migrated on load)."
},
{
path: ["routing", "agents"],
message: "routing.agents was moved; use agents.list instead (auto-migrated on load)."
},
{
path: ["routing", "defaultAgentId"],
message: "routing.defaultAgentId was moved; use agents.list[].default instead (auto-migrated on load)."
},
{
path: ["routing", "agentToAgent"],
message: "routing.agentToAgent was moved; use tools.agentToAgent instead (auto-migrated on load)."
},
{
path: [
"routing",
"groupChat",
"requireMention"
],
message: "routing.groupChat.requireMention was removed; use channels.whatsapp/telegram/imessage groups defaults (e.g. channels.whatsapp.groups.\"*\".requireMention) instead (auto-migrated on load)."
},
{
path: [
"routing",
"groupChat",
"mentionPatterns"
],
message: "routing.groupChat.mentionPatterns was moved; use agents.list[].groupChat.mentionPatterns or messages.groupChat.mentionPatterns instead (auto-migrated on load)."
},
{
path: ["routing", "queue"],
message: "routing.queue was moved; use messages.queue instead (auto-migrated on load)."
},
{
path: ["routing", "transcribeAudio"],
message: "routing.transcribeAudio was moved; use tools.media.audio.models instead (auto-migrated on load)."
},
{
path: ["telegram", "requireMention"],
message: "telegram.requireMention was removed; use channels.telegram.groups.\"*\".requireMention instead (auto-migrated on load)."
},
{
path: ["identity"],
message: "identity was moved; use agents.list[].identity instead (auto-migrated on load)."
},
{
path: ["agent"],
message: "agent.* was moved; use agents.defaults (and tools.* for tool/elevated/exec settings) instead (auto-migrated on load)."
},
{
path: ["memorySearch"],
message: "top-level memorySearch was moved; use agents.defaults.memorySearch instead (auto-migrated on load)."
},
{
path: ["tools", "bash"],
message: "tools.bash was removed; use tools.exec instead (auto-migrated on load)."
},
{
path: ["agent", "model"],
message: "agent.model string was replaced by agents.defaults.model.primary/fallbacks and agents.defaults.models (auto-migrated on load).",
match: (value) => typeof value === "string"
},
{
path: ["agent", "imageModel"],
message: "agent.imageModel string was replaced by agents.defaults.imageModel.primary/fallbacks (auto-migrated on load).",
match: (value) => typeof value === "string"
},
{
path: ["agent", "allowedModels"],
message: "agent.allowedModels was replaced by agents.defaults.models (auto-migrated on load)."
},
{
path: ["agent", "modelAliases"],
message: "agent.modelAliases was replaced by agents.defaults.models.*.alias (auto-migrated on load)."
},
{
path: ["agent", "modelFallbacks"],
message: "agent.modelFallbacks was replaced by agents.defaults.model.fallbacks (auto-migrated on load)."
},
{
path: ["agent", "imageModelFallbacks"],
message: "agent.imageModelFallbacks was replaced by agents.defaults.imageModel.fallbacks (auto-migrated on load)."
},
{
path: [
"messages",
"tts",
"enabled"
],
message: "messages.tts.enabled was replaced by messages.tts.auto (auto-migrated on load)."
},
{
path: ["gateway", "token"],
message: "gateway.token is ignored; use gateway.auth.token instead (auto-migrated on load)."
}
];
//#endregion
//#region src/config/legacy.ts
function findLegacyConfigIssues(raw) {
if (!raw || typeof raw !== "object") return [];
const root = raw;
const issues = [];
for (const rule of LEGACY_CONFIG_RULES) {
let cursor = root;
for (const key of rule.path) {
if (!cursor || typeof cursor !== "object") {
cursor = void 0;
break;
}
cursor = cursor[key];
}
if (cursor !== void 0 && (!rule.match || rule.match(cursor, root))) issues.push({
path: rule.path.join("."),
message: rule.message
});
}
return issues;
}
function applyLegacyMigrations(raw) {
if (!raw || typeof raw !== "object") return {
next: null,
changes: []
};
const next = structuredClone(raw);
const changes = [];
for (const migration of LEGACY_CONFIG_MIGRATIONS) migration.apply(next, changes);
if (changes.length === 0) return {
next: null,
changes: []
};
return {
next,
changes
};
}
//#endregion
//#region src/config/merge-patch.ts
function isObjectWithStringId(value) {
if (!isPlainObject$2(value)) return false;
return typeof value.id === "string" && value.id.length > 0;
}
/**
* Merge arrays of object-like entries keyed by `id`.
*
* Contract:
* - Base array must be fully id-keyed; otherwise return undefined (caller should replace).
* - Patch entries with valid id merge by id (or append when the id is new).
* - Patch entries without valid id append as-is, avoiding destructive full-array replacement.
*/
function mergeObjectArraysById(base, patch, options) {
if (!base.every(isObjectWithStringId)) return;
const merged = [...base];
const indexById = /* @__PURE__ */ new Map();
for (const [index, entry] of merged.entries()) {
if (!isObjectWithStringId(entry)) return;
indexById.set(entry.id, index);
}
for (const patchEntry of patch) {
if (!isObjectWithStringId(patchEntry)) {
merged.push(structuredClone(patchEntry));
continue;
}
const existingIndex = indexById.get(patchEntry.id);
if (existingIndex === void 0) {
merged.push(structuredClone(patchEntry));
indexById.set(patchEntry.id, merged.length - 1);
continue;
}
merged[existingIndex] = applyMergePatch(merged[existingIndex], patchEntry, options);
}
return merged;
}
function applyMergePatch(base, patch, options = {}) {
if (!isPlainObject$2(patch)) return patch;
const result = isPlainObject$2(base) ? { ...base } : {};
for (const [key, value] of Object.entries(patch)) {
if (isBlockedObjectKey(key)) continue;
if (value === null) {
delete result[key];
continue;
}
if (options.mergeObjectArraysById && Array.isArray(result[key]) && Array.isArray(value)) {
const mergedArray = mergeObjectArraysById(result[key], value, options);
if (mergedArray) {
result[key] = mergedArray;
continue;
}
}
if (isPlainObject$2(value)) {
const baseValue = result[key];
result[key] = applyMergePatch(isPlainObject$2(baseValue) ? baseValue : {}, value, options);
continue;
}
result[key] = value;
}
return result;
}
//#endregion
//#region src/infra/exec-safe-bin-policy-profiles.ts
const NO_FLAGS$1 = /* @__PURE__ */ new Set();
const toFlagSet = (flags) => {
if (!flags || flags.length === 0) return NO_FLAGS$1;
return new Set(flags);
};
function collectKnownLongFlags(allowedValueFlags, deniedFlags) {
const known = /* @__PURE__ */ new Set();
for (const flag of allowedValueFlags) if (flag.startsWith("--")) known.add(flag);
for (const flag of deniedFlags) if (flag.startsWith("--")) known.add(flag);
return Array.from(known);
}
function buildLongFlagPrefixMap(knownLongFlags) {
const prefixMap = /* @__PURE__ */ new Map();
for (const flag of knownLongFlags) {
if (!flag.startsWith("--") || flag.length <= 2) continue;
for (let length = 3; length <= flag.length; length += 1) {
const prefix = flag.slice(0, length);
const existing = prefixMap.get(prefix);
if (existing === void 0) {
prefixMap.set(prefix, flag);
continue;
}
if (existing !== flag) prefixMap.set(prefix, null);
}
}
return prefixMap;
}
function compileSafeBinProfile(fixture) {
const allowedValueFlags = toFlagSet(fixture.allowedValueFlags);
const deniedFlags = toFlagSet(fixture.deniedFlags);
const knownLongFlags = collectKnownLongFlags(allowedValueFlags, deniedFlags);
return {
minPositional: fixture.minPositional,
maxPositional: fixture.maxPositional,
allowedValueFlags,
deniedFlags,
knownLongFlags,
knownLongFlagsSet: new Set(knownLongFlags),
longFlagPrefixMap: buildLongFlagPrefixMap(knownLongFlags)
};
}
function compileSafeBinProfiles(fixtures) {
return Object.fromEntries(Object.entries(fixtures).map(([name, fixture]) => [name, compileSafeBinProfile(fixture)]));
}
const SAFE_BIN_PROFILE_FIXTURES = {
jq: {
maxPositional: 1,
allowedValueFlags: [
"--arg",
"--argjson",
"--argstr"
],
deniedFlags: [
"--argfile",
"--rawfile",
"--slurpfile",
"--from-file",
"--library-path",
"-L",
"-f"
]
},
grep: {
maxPositional: 0,
allowedValueFlags: [
"--regexp",
"--max-count",
"--after-context",
"--before-context",
"--context",
"--devices",
"--binary-files",
"--exclude",
"--include",
"--label",
"-e",
"-m",
"-A",
"-B",
"-C",
"-D"
],
deniedFlags: [
"--file",
"--exclude-from",
"--dereference-recursive",
"--directories",
"--recursive",
"-f",
"-d",
"-r",
"-R"
]
},
cut: {
maxPositional: 0,
allowedValueFlags: [
"--bytes",
"--characters",
"--fields",
"--delimiter",
"--output-delimiter",
"-b",
"-c",
"-f",
"-d"
]
},
sort: {
maxPositional: 0,
allowedValueFlags: [
"--key",
"--field-separator",
"--buffer-size",
"--parallel",
"--batch-size",
"-k",
"-t",
"-S"
],
deniedFlags: [
"--compress-program",
"--files0-from",
"--output",
"--random-source",
"--temporary-directory",
"-T",
"-o"
]
},
uniq: {
maxPositional: 0,
allowedValueFlags: [
"--skip-fields",
"--skip-chars",
"--check-chars",
"--group",
"-f",
"-s",
"-w"
]
},
head: {
maxPositional: 0,
allowedValueFlags: [
"--lines",
"--bytes",
"-n",
"-c"
]
},
tail: {
maxPositional: 0,
allowedValueFlags: [
"--lines",
"--bytes",
"--sleep-interval",
"--max-unchanged-stats",
"--pid",
"-n",
"-c"
]
},
tr: {
minPositional: 1,
maxPositional: 2
},
wc: {
maxPositional: 0,
deniedFlags: ["--files0-from"]
}
};
const SAFE_BIN_PROFILES = compileSafeBinProfiles(SAFE_BIN_PROFILE_FIXTURES);
function normalizeSafeBinProfileName(raw) {
const name = raw.trim().toLowerCase();
return name.length > 0 ? name : null;
}
function normalizeFixtureLimit(raw) {
if (typeof raw !== "number" || !Number.isFinite(raw)) return;
const next = Math.trunc(raw);
return next >= 0 ? next : void 0;
}
function normalizeFixtureFlags(flags) {
if (!Array.isArray(flags) || flags.length === 0) return;
const normalized = Array.from(new Set(flags.map((flag) => flag.trim()).filter((flag) => flag.length > 0))).toSorted((a, b) => a.localeCompare(b));
return normalized.length > 0 ? normalized : void 0;
}
function normalizeSafeBinProfileFixture(fixture) {
const minPositional = normalizeFixtureLimit(fixture.minPositional);
const maxPositionalRaw = normalizeFixtureLimit(fixture.maxPositional);
return {
minPositional,
maxPositional: minPositional !== void 0 && maxPositionalRaw !== void 0 && maxPositionalRaw < minPositional ? minPositional : maxPositionalRaw,
allowedValueFlags: normalizeFixtureFlags(fixture.allowedValueFlags),
deniedFlags: normalizeFixtureFlags(fixture.deniedFlags)
};
}
function normalizeSafeBinProfileFixtures(fixtures) {
const normalized = {};
if (!fixtures) return normalized;
for (const [rawName, fixture] of Object.entries(fixtures)) {
const name = normalizeSafeBinProfileName(rawName);
if (!name) continue;
normalized[name] = normalizeSafeBinProfileFixture(fixture);
}
return normalized;
}
function resolveSafeBinProfiles(fixtures) {
const normalizedFixtures = normalizeSafeBinProfileFixtures(fixtures);
if (Object.keys(normalizedFixtures).length === 0) return SAFE_BIN_PROFILES;
return {
...SAFE_BIN_PROFILES,
...compileSafeBinProfiles(normalizedFixtures)
};
}
//#endregion
//#region src/utils/shell-argv.ts
const DOUBLE_QUOTE_ESCAPES$1 = new Set([
"\\",
"\"",
"$",
"`",
"\n",
"\r"
]);
function isDoubleQuoteEscape$1(next) {
return Boolean(next && DOUBLE_QUOTE_ESCAPES$1.has(next));
}
function splitShellArgs(raw) {
const tokens = [];
let buf = "";
let inSingle = false;
let inDouble = false;
let escaped = false;
const pushToken = () => {
if (buf.length > 0) {
tokens.push(buf);
buf = "";
}
};
for (let i = 0; i < raw.length; i += 1) {
const ch = raw[i];
if (escaped) {
buf += ch;
escaped = false;
continue;
}
if (!inSingle && !inDouble && ch === "\\") {
escaped = true;
continue;
}
if (inSingle) {
if (ch === "'") inSingle = false;
else buf += ch;
continue;
}
if (inDouble) {
const next = raw[i + 1];
if (ch === "\\" && isDoubleQuoteEscape$1(next)) {
buf += next;
i += 1;
continue;
}
if (ch === "\"") inDouble = false;
else buf += ch;
continue;
}
if (ch === "'") {
inSingle = true;
continue;
}
if (ch === "\"") {
inDouble = true;
continue;
}
if (/\s/.test(ch)) {
pushToken();
continue;
}
buf += ch;
}
if (escaped || inSingle || inDouble) return null;
pushToken();
return tokens;
}
//#endregion
//#region src/infra/exec-wrapper-resolution.ts
const MAX_DISPATCH_WRAPPER_DEPTH = 4;
const WINDOWS_EXE_SUFFIX = ".exe";
const POSIX_SHELL_WRAPPER_NAMES = [
"ash",
"bash",
"dash",
"fish",
"ksh",
"sh",
"zsh"
];
const WINDOWS_CMD_WRAPPER_NAMES = ["cmd"];
const POWERSHELL_WRAPPER_NAMES = ["powershell", "pwsh"];
const SHELL_MULTIPLEXER_WRAPPER_NAMES = ["busybox", "toybox"];
const DISPATCH_WRAPPER_NAMES = [
"chrt",
"doas",
"env",
"ionice",
"nice",
"nohup",
"setsid",
"stdbuf",
"sudo",
"taskset",
"timeout"
];
function withWindowsExeAliases(names) {
const expanded = /* @__PURE__ */ new Set();
for (const name of names) {
expanded.add(name);
expanded.add(`${name}${WINDOWS_EXE_SUFFIX}`);
}
return Array.from(expanded);
}
function stripWindowsExeSuffix(value) {
return value.endsWith(WINDOWS_EXE_SUFFIX) ? value.slice(0, -4) : value;
}
const POSIX_SHELL_WRAPPERS = new Set(POSIX_SHELL_WRAPPER_NAMES);
const WINDOWS_CMD_WRAPPERS = new Set(withWindowsExeAliases(WINDOWS_CMD_WRAPPER_NAMES));
const POWERSHELL_WRAPPERS = new Set(withWindowsExeAliases(POWERSHELL_WRAPPER_NAMES));
const DISPATCH_WRAPPER_EXECUTABLES = new Set(withWindowsExeAliases(DISPATCH_WRAPPER_NAMES));
const POSIX_SHELL_WRAPPER_CANONICAL = new Set(POSIX_SHELL_WRAPPER_NAMES);
const WINDOWS_CMD_WRAPPER_CANONICAL = new Set(WINDOWS_CMD_WRAPPER_NAMES);
const POWERSHELL_WRAPPER_CANONICAL = new Set(POWERSHELL_WRAPPER_NAMES);
const SHELL_MULTIPLEXER_WRAPPER_CANONICAL = new Set(SHELL_MULTIPLEXER_WRAPPER_NAMES);
const DISPATCH_WRAPPER_CANONICAL = new Set(DISPATCH_WRAPPER_NAMES);
const SHELL_WRAPPER_CANONICAL = new Set([
...POSIX_SHELL_WRAPPER_NAMES,
...WINDOWS_CMD_WRAPPER_NAMES,
...POWERSHELL_WRAPPER_NAMES
]);
const POSIX_INLINE_COMMAND_FLAGS = new Set([
"-lc",
"-c",
"--command"
]);
const POWERSHELL_INLINE_COMMAND_FLAGS = new Set([
"-c",
"-command",
"--command"
]);
const ENV_OPTIONS_WITH_VALUE = new Set([
"-u",
"--unset",
"-c",
"--chdir",
"-s",
"--split-string",
"--default-signal",
"--ignore-signal",
"--block-signal"
]);
const ENV_INLINE_VALUE_PREFIXES = [
"-u",
"-c",
"-s",
"--unset=",
"--chdir=",
"--split-string=",
"--default-signal=",
"--ignore-signal=",
"--block-signal="
];
const ENV_FLAG_OPTIONS = new Set([
"-i",
"--ignore-environment",
"-0",
"--null"
]);
const NICE_OPTIONS_WITH_VALUE = new Set([
"-n",
"--adjustment",
"--priority"
]);
const STDBUF_OPTIONS_WITH_VALUE = new Set([
"-i",
"--input",
"-o",
"--output",
"-e",
"--error"
]);
const TIMEOUT_FLAG_OPTIONS = new Set([
"--foreground",
"--preserve-status",
"-v",
"--verbose"
]);
const TIMEOUT_OPTIONS_WITH_VALUE = new Set([
"-k",
"--kill-after",
"-s",
"--signal"
]);
const TRANSPARENT_DISPATCH_WRAPPERS = new Set([
"nice",
"nohup",
"stdbuf",
"timeout"
]);
const SHELL_WRAPPER_SPECS = [
{
kind: "posix",
names: POSIX_SHELL_WRAPPER_CANONICAL
},
{
kind: "cmd",
names: WINDOWS_CMD_WRAPPER_CANONICAL
},
{
kind: "powershell",
names: POWERSHELL_WRAPPER_CANONICAL
}
];
function basenameLower(token) {
const win = path.win32.basename(token);
const posix = path.posix.basename(token);
return (win.length < posix.length ? win : posix).trim().toLowerCase();
}
function normalizeExecutableToken(token) {
return stripWindowsExeSuffix(basenameLower(token));
}
function isDispatchWrapperExecutable(token) {
return DISPATCH_WRAPPER_CANONICAL.has(normalizeExecutableToken(token));
}
function isShellWrapperExecutable(token) {
return SHELL_WRAPPER_CANONICAL.has(normalizeExecutableToken(token));
}
function normalizeRawCommand(rawCommand) {
const trimmed = rawCommand?.trim() ?? "";
return trimmed.length > 0 ? trimmed : null;
}
function findShellWrapperSpec(baseExecutable) {
const canonicalBase = stripWindowsExeSuffix(baseExecutable);
for (const spec of SHELL_WRAPPER_SPECS) if (spec.names.has(canonicalBase)) return spec;
return null;
}
function unwrapKnownShellMultiplexerInvocation(argv) {
const token0 = argv[0]?.trim();
if (!token0) return { kind: "not-wrapper" };
const wrapper = normalizeExecutableToken(token0);
if (!SHELL_MULTIPLEXER_WRAPPER_CANONICAL.has(wrapper)) return { kind: "not-wrapper" };
let appletIndex = 1;
if (argv[appletIndex]?.trim() === "--") appletIndex += 1;
const applet = argv[appletIndex]?.trim();
if (!applet || !isShellWrapperExecutable(applet)) return {
kind: "blocked",
wrapper
};
const unwrapped = argv.slice(appletIndex);
if (unwrapped.length === 0) return {
kind: "blocked",
wrapper
};
return {
kind: "unwrapped",
wrapper,
argv: unwrapped
};
}
function isEnvAssignment(token) {
return /^[A-Za-z_][A-Za-z0-9_]*=.*/.test(token);
}
function hasEnvInlineValuePrefix(lower) {
for (const prefix of ENV_INLINE_VALUE_PREFIXES) if (lower.startsWith(prefix)) return true;
return false;
}
function scanWrapperInvocation(argv, params) {
let idx = 1;
let expectsOptionValue = false;
while (idx < argv.length) {
const token = argv[idx]?.trim() ?? "";
if (!token) {
idx += 1;
continue;
}
if (expectsOptionValue) {
expectsOptionValue = false;
idx += 1;
continue;
}
if (params.separators?.has(token)) {
idx += 1;
break;
}
const directive = params.onToken(token, token.toLowerCase());
if (directive === "stop") break;
if (directive === "invalid") return null;
if (directive === "consume-next") expectsOptionValue = true;
idx += 1;
}
if (expectsOptionValue) return null;
const commandIndex = params.adjustCommandIndex ? params.adjustCommandIndex(idx, argv) : idx;
if (commandIndex === null || commandIndex >= argv.length) return null;
return argv.slice(commandIndex);
}
function unwrapEnvInvocation(argv) {
return scanWrapperInvocation(argv, {
separators: new Set(["--", "-"]),
onToken: (token, lower) => {
if (isEnvAssignment(token)) return "continue";
if (!token.startsWith("-") || token === "-") return "stop";
const [flag] = lower.split("=", 2);
if (ENV_FLAG_OPTIONS.has(flag)) return "continue";
if (ENV_OPTIONS_WITH_VALUE.has(flag)) return lower.includes("=") ? "continue" : "consume-next";
if (hasEnvInlineValuePrefix(lower)) return "continue";
return "invalid";
}
});
}
function envInvocationUsesModifiers(argv) {
let idx = 1;
let expectsOptionValue = false;
while (idx < argv.length) {
const token = argv[idx]?.trim() ?? "";
if (!token) {
idx += 1;
continue;
}
if (expectsOptionValue) return true;
if (token === "--" || token === "-") {
idx += 1;
break;
}
if (isEnvAssignment(token)) return true;
if (!token.startsWith("-") || token === "-") break;
const lower = token.toLowerCase();
const [flag] = lower.split("=", 2);
if (ENV_FLAG_OPTIONS.has(flag)) return true;
if (ENV_OPTIONS_WITH_VALUE.has(flag)) {
if (lower.includes("=")) return true;
expectsOptionValue = true;
idx += 1;
continue;
}
if (hasEnvInlineValuePrefix(lower)) return true;
return true;
}
return false;
}
function unwrapNiceInvocation(argv) {
return unwrapDashOptionInvocation(argv, { onFlag: (flag, lower) => {
if (/^-\d+$/.test(lower)) return "continue";
if (NICE_OPTIONS_WITH_VALUE.has(flag)) return lower.includes("=") || lower !== flag ? "continue" : "consume-next";
if (lower.startsWith("-n") && lower.length > 2) return "continue";
return "invalid";
} });
}
function unwrapNohupInvocation(argv) {
return scanWrapperInvocation(argv, {
separators: new Set(["--"]),
onToken: (token, lower) => {
if (!token.startsWith("-") || token === "-") return "stop";
return lower === "--help" || lower === "--version" ? "continue" : "invalid";
}
});
}
function unwrapDashOptionInvocation(argv, params) {
return scanWrapperInvocation(argv, {
separators: new Set(["--"]),
onToken: (token, lower) => {
if (!token.startsWith("-") || token === "-") return "stop";
const [flag] = lower.split("=", 2);
return params.onFlag(flag, lower);
},
adjustCommandIndex: params.adjustCommandIndex
});
}
function unwrapStdbufInvocation(argv) {
return unwrapDashOptionInvocation(argv, { onFlag: (flag, lower) => {
if (!STDBUF_OPTIONS_WITH_VALUE.has(flag)) return "invalid";
return lower.includes("=") ? "continue" : "consume-next";
} });
}
function unwrapTimeoutInvocation(argv) {
return unwrapDashOptionInvocation(argv, {
onFlag: (flag, lower) => {
if (TIMEOUT_FLAG_OPTIONS.has(flag)) return "continue";
if (TIMEOUT_OPTIONS_WITH_VALUE.has(flag)) return lower.includes("=") ? "continue" : "consume-next";
return "invalid";
},
adjustCommandIndex: (commandIndex, currentArgv) => {
const wrappedCommandIndex = commandIndex + 1;
return wrappedCommandIndex < currentArgv.length ? wrappedCommandIndex : null;
}
});
}
function blockDispatchWrapper(wrapper) {
return {
kind: "blocked",
wrapper
};
}
function unwrapDispatchWrapper(wrapper, unwrapped) {
return unwrapped ? {
kind: "unwrapped",
wrapper,
argv: unwrapped
} : blockDispatchWrapper(wrapper);
}
function unwrapKnownDispatchWrapperInvocation(argv) {
const token0 = argv[0]?.trim();
if (!token0) return { kind: "not-wrapper" };
const wrapper = normalizeExecutableToken(token0);
switch (wrapper) {
case "env": return unwrapDispatchWrapper(wrapper, unwrapEnvInvocation(argv));
case "nice": return unwrapDispatchWrapper(wrapper, unwrapNiceInvocation(argv));
case "nohup": return unwrapDispatchWrapper(wrapper, unwrapNohupInvocation(argv));
case "stdbuf": return unwrapDispatchWrapper(wrapper, unwrapStdbufInvocation(argv));
case "timeout": return unwrapDispatchWrapper(wrapper, unwrapTimeoutInvocation(argv));
case "chrt":
case "doas":
case "ionice":
case "setsid":
case "sudo":
case "taskset": return blockDispatchWrapper(wrapper);
default: return { kind: "not-wrapper" };
}
}
function unwrapDispatchWrappersForResolution(argv, maxDepth = MAX_DISPATCH_WRAPPER_DEPTH) {
return resolveDispatchWrapperExecutionPlan(argv, maxDepth).argv;
}
function isSemanticDispatchWrapperUsage(wrapper, argv) {
if (wrapper === "env") return envInvocationUsesModifiers(argv);
return !TRANSPARENT_DISPATCH_WRAPPERS.has(wrapper);
}
function blockedDispatchWrapperPlan(params) {
return {
argv: params.argv,
wrappers: params.wrappers,
policyBlocked: true,
blockedWrapper: params.blockedWrapper
};
}
function resolveDispatchWrapperExecutionPlan(argv, maxDepth = MAX_DISPATCH_WRAPPER_DEPTH) {
let current = argv;
const wrappers = [];
for (let depth = 0; depth < maxDepth; depth += 1) {
const unwrap = unwrapKnownDispatchWrapperInvocation(current);
if (unwrap.kind === "blocked") return blockedDispatchWrapperPlan({
argv: current,
wrappers,
blockedWrapper: unwrap.wrapper
});
if (unwrap.kind !== "unwrapped" || unwrap.argv.length === 0) break;
wrappers.push(unwrap.wrapper);
if (isSemanticDispatchWrapperUsage(unwrap.wrapper, current)) return blockedDispatchWrapperPlan({
argv: current,
wrappers,
blockedWrapper: unwrap.wrapper
});
current = unwrap.argv;
}
if (wrappers.length >= maxDepth) {
const overflow = unwrapKnownDispatchWrapperInvocation(current);
if (overflow.kind === "blocked" || overflow.kind === "unwrapped") return blockedDispatchWrapperPlan({
argv: current,
wrappers,
blockedWrapper: overflow.wrapper
});
}
return {
argv: current,
wrappers,
policyBlocked: false
};
}
function hasEnvManipulationBeforeShellWrapperInternal(argv, depth, envManipulationSeen) {
if (depth >= MAX_DISPATCH_WRAPPER_DEPTH) return false;
const token0 = argv[0]?.trim();
if (!token0) return false;
const dispatchUnwrap = unwrapKnownDispatchWrapperInvocation(argv);
if (dispatchUnwrap.kind === "blocked") return false;
if (dispatchUnwrap.kind === "unwrapped") {
const nextEnvManipulationSeen = envManipulationSeen || dispatchUnwrap.wrapper === "env" && envInvocationUsesModifiers(argv);
return hasEnvManipulationBeforeShellWrapperInternal(dispatchUnwrap.argv, depth + 1, nextEnvManipulationSeen);
}
const shellMultiplexerUnwrap = unwrapKnownShellMultiplexerInvocation(argv);
if (shellMultiplexerUnwrap.kind === "blocked") return false;
if (shellMultiplexerUnwrap.kind === "unwrapped") return hasEnvManipulationBeforeShellWrapperInternal(shellMultiplexerUnwrap.argv, depth + 1, envManipulationSeen);
const wrapper = findShellWrapperSpec(normalizeExecutableToken(token0));
if (!wrapper) return false;
if (!extractShellWrapperPayload(argv, wrapper)) return false;
return envManipulationSeen;
}
function hasEnvManipulationBeforeShellWrapper(argv) {
return hasEnvManipulationBeforeShellWrapperInternal(argv, 0, false);
}
function extractPosixShellInlineCommand(argv) {
return extractInlineCommandByFlags(argv, POSIX_INLINE_COMMAND_FLAGS, { allowCombinedC: true });
}
function extractCmdInlineCommand(argv) {
const idx = argv.findIndex((item) => {
const token = item.trim().toLowerCase();
return token === "/c" || token === "/k";
});
if (idx === -1) return null;
const tail = argv.slice(idx + 1);
if (tail.length === 0) return null;
const cmd = tail.join(" ").trim();
return cmd.length > 0 ? cmd : null;
}
function extractPowerShellInlineCommand(argv) {
return extractInlineCommandByFlags(argv, POWERSHELL_INLINE_COMMAND_FLAGS);
}
function extractInlineCommandByFlags(argv, flags, options = {}) {
for (let i = 1; i < argv.length; i += 1) {
const token = argv[i]?.trim();
if (!token) continue;
const lower = token.toLowerCase();
if (lower === "--") break;
if (flags.has(lower)) {
const cmd = argv[i + 1]?.trim();
return cmd ? cmd : null;
}
if (options.allowCombinedC && /^-[^-]*c[^-]*$/i.test(token)) {
const commandIndex = lower.indexOf("c");
const inline = token.slice(commandIndex + 1).trim();
if (inline) return inline;
const cmd = argv[i + 1]?.trim();
return cmd ? cmd : null;
}
}
return null;
}
function extractShellWrapperPayload(argv, spec) {
switch (spec.kind) {
case "posix": return extractPosixShellInlineCommand(argv);
case "cmd": return extractCmdInlineCommand(argv);
case "powershell": return extractPowerShellInlineCommand(argv);
}
}
function extractShellWrapperCommandInternal(argv, rawCommand, depth) {
if (depth >= MAX_DISPATCH_WRAPPER_DEPTH) return {
isWrapper: false,
command: null
};
const token0 = argv[0]?.trim();
if (!token0) return {
isWrapper: false,
command: null
};
const dispatchUnwrap = unwrapKnownDispatchWrapperInvocation(argv);
if (dispatchUnwrap.kind === "blocked") return {
isWrapper: false,
command: null
};
if (dispatchUnwrap.kind === "unwrapped") return extractShellWrapperCommandInternal(dispatchUnwrap.argv, rawCommand, depth + 1);
const shellMultiplexerUnwrap = unwrapKnownShellMultiplexerInvocation(argv);
if (shellMultiplexerUnwrap.kind === "blocked") return {
isWrapper: false,
command: null
};
if (shellMultiplexerUnwrap.kind === "unwrapped") return extractShellWrapperCommandInternal(shellMultiplexerUnwrap.argv, rawCommand, depth + 1);
const wrapper = findShellWrapperSpec(normalizeExecutableToken(token0));
if (!wrapper) return {
isWrapper: false,
command: null
};
const payload = extractShellWrapperPayload(argv, wrapper);
if (!payload) return {
isWrapper: false,
command: null
};
return {
isWrapper: true,
command: rawCommand ?? payload
};
}
function extractShellWrapperInlineCommand(argv) {
const extracted = extractShellWrapperCommandInternal(argv, null, 0);
return extracted.isWrapper ? extracted.command : null;
}
function extractShellWrapperCommand(argv, rawCommand) {
return extractShellWrapperCommandInternal(argv, normalizeRawCommand(rawCommand), 0);
}
//#endregion
//#region src/infra/exec-command-resolution.ts
const DEFAULT_SAFE_BINS = [
"jq",
"cut",
"uniq",
"head",
"tail",
"tr",
"wc"
];
function isExecutableFile(filePath) {
try {
if (!fs.statSync(filePath).isFile()) return false;
if (process.platform !== "win32") fs.accessSync(filePath, fs.constants.X_OK);
return true;
} catch {
return false;
}
}
function resolveExecutablePath(rawExecutable, cwd, env) {
const expanded = rawExecutable.startsWith("~") ? expandHomePrefix(rawExecutable) : rawExecutable;
if (expanded.includes("/") || expanded.includes("\\")) {
if (path.isAbsolute(expanded)) return isExecutableFile(expanded) ? expanded : void 0;
const base = cwd && cwd.trim() ? cwd.trim() : process.cwd();
const candidate = path.resolve(base, expanded);
return isExecutableFile(candidate) ? candidate : void 0;
}
const entries = (env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? "").split(path.delimiter).filter(Boolean);
const hasExtension = process.platform === "win32" && path.extname(expanded).length > 0;
const extensions = process.platform === "win32" ? hasExtension ? [""] : (env?.PATHEXT ?? env?.Pathext ?? process.env.PATHEXT ?? process.env.Pathext ?? ".EXE;.CMD;.BAT;.COM").split(";").map((ext) => ext.toLowerCase()) : [""];
for (const entry of entries) for (const ext of extensions) {
const candidate = path.join(entry, expanded + ext);
if (isExecutableFile(candidate)) return candidate;
}
}
function resolveCommandResolutionFromArgv(argv, cwd, env) {
const plan = resolveDispatchWrapperExecutionPlan(argv);
const effectiveArgv = plan.argv;
const rawExecutable = effectiveArgv[0]?.trim();
if (!rawExecutable) return null;
const resolvedPath = resolveExecutablePath(rawExecutable, cwd, env);
return {
rawExecutable,
resolvedPath,
executableName: resolvedPath ? path.basename(resolvedPath) : rawExecutable,
effectiveArgv,
wrapperChain: plan.wrappers,
policyBlocked: plan.policyBlocked,
blockedWrapper: plan.blockedWrapper
};
}
function normalizeMatchTarget(value) {
if (process.platform === "win32") return value.replace(/^\\\\[?.]\\/, "").replace(/\\/g, "/").toLowerCase();
return value.replace(/\\\\/g, "/").toLowerCase();
}
function tryRealpath(value) {
try {
return fs.realpathSync(value);
} catch {
return null;
}
}
function globToRegExp(pattern) {
let regex = "^";
let i = 0;
while (i < pattern.length) {
const ch = pattern[i];
if (ch === "*") {
if (pattern[i + 1] === "*") {
regex += ".*";
i += 2;
continue;
}
regex += "[^/]*";
i += 1;
continue;
}
if (ch === "?") {
regex += ".";
i += 1;
continue;
}
regex += ch.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&");
i += 1;
}
regex += "$";
return new RegExp(regex, "i");
}
function matchesPattern(pattern, target) {
const trimmed = pattern.trim();
if (!trimmed) return false;
const expanded = trimmed.startsWith("~") ? expandHomePrefix(trimmed) : trimmed;
const hasWildcard = /[*?]/.test(expanded);
let normalizedPattern = expanded;
let normalizedTarget = target;
if (process.platform === "win32" && !hasWildcard) {
normalizedPattern = tryRealpath(expanded) ?? expanded;
normalizedTarget = tryRealpath(target) ?? target;
}
normalizedPattern = normalizeMatchTarget(normalizedPattern);
normalizedTarget = normalizeMatchTarget(normalizedTarget);
return globToRegExp(normalizedPattern).test(normalizedTarget);
}
function resolveAllowlistCandidatePath(resolution, cwd) {
if (!resolution) return;
if (resolution.resolvedPath) return resolution.resolvedPath;
const raw = resolution.rawExecutable?.trim();
if (!raw) return;
const expanded = raw.startsWith("~") ? expandHomePrefix(raw) : raw;
if (!expanded.includes("/") && !expanded.includes("\\")) return;
if (path.isAbsolute(expanded)) return expanded;
const base = cwd && cwd.trim() ? cwd.trim() : process.cwd();
return path.resolve(base, expanded);
}
function matchAllowlist(entries, resolution) {
if (!entries.length) return null;
const bareWild = entries.find((e) => e.pattern?.trim() === "*");
if (bareWild && resolution) return bareWild;
if (!resolution?.resolvedPath) return null;
const resolvedPath = resolution.resolvedPath;
for (const entry of entries) {
const pattern = entry.pattern?.trim();
if (!pattern) continue;
if (!(pattern.includes("/") || pattern.includes("\\") || pattern.includes("~"))) continue;
if (matchesPattern(pattern, resolvedPath)) return entry;
}
return null;
}
/**
* Tokenizes a single argv entry into a normalized option/positional model.
* Consumers can share this model to keep argv parsing behavior consistent.
*/
function parseExecArgvToken(raw) {
if (!raw) return {
kind: "empty",
raw
};
if (raw === "--") return {
kind: "terminator",
raw
};
if (raw === "-") return {
kind: "stdin",
raw
};
if (!raw.startsWith("-")) return {
kind: "positional",
raw
};
if (raw.startsWith("--")) {
const eqIndex = raw.indexOf("=");
if (eqIndex > 0) return {
kind: "option",
raw,
style: "long",
flag: raw.slice(0, eqIndex),
inlineValue: raw.slice(eqIndex + 1)
};
return {
kind: "option",
raw,
style: "long",
flag: raw
};
}
const cluster = raw.slice(1);
return {
kind: "option",
raw,
style: "short-cluster",
cluster,
flags: cluster.split("").map((entry) => `-${entry}`)
};
}
//#endregion
//#region src/infra/exec-approvals-analysis.ts
const DISALLOWED_PIPELINE_TOKENS = new Set([
">",
"<",
"`",
"\n",
"\r",
"(",
")"
]);
const DOUBLE_QUOTE_ESCAPES = new Set([
"\\",
"\"",
"$",
"`"
]);
const WINDOWS_UNSUPPORTED_TOKENS = new Set([
"&",
"|",
"<",
">",
"^",
"(",
")",
"%",
"!",
"\n",
"\r"
]);
function isDoubleQuoteEscape(next) {
return Boolean(next && DOUBLE_QUOTE_ESCAPES.has(next));
}
function isEscapedLineContinuation(next) {
return next === "\n" || next === "\r";
}
function splitShellPipeline(command) {
const parseHeredocDelimiter = (source, start) => {
let i = start;
while (i < source.length && (source[i] === " " || source[i] === " ")) i += 1;
if (i >= source.length) return null;
const first = source[i];
if (first === "'" || first === "\"") {
const quote = first;
i += 1;
let delimiter = "";
while (i < source.length) {
const ch = source[i];
if (ch === "\n" || ch === "\r") return null;
if (quote === "\"" && ch === "\\" && i + 1 < source.length) {
delimiter += source[i + 1];
i += 2;
continue;
}
if (ch === quote) return {
delimiter,
end: i + 1,
quoted: true
};
delimiter += ch;
i += 1;
}
return null;
}
let delimiter = "";
while (i < source.length) {
const ch = source[i];
if (/\s/.test(ch) || ch === "|" || ch === "&" || ch === ";" || ch === "<" || ch === ">") break;
delimiter += ch;
i += 1;
}
if (!delimiter) return null;
return {
delimiter,
end: i,
quoted: false
};
};
const segments = [];
let buf = "";
let inSingle = false;
let inDouble = false;
let escaped = false;
let emptySegment = false;
const pendingHeredocs = [];
let inHeredocBody = false;
let heredocLine = "";
const pushPart = () => {
const trimmed = buf.trim();
if (trimmed) segments.push(trimmed);
buf = "";
};
const isEscapedInHeredocLine = (line, index) => {
let slashes = 0;
for (let i = index - 1; i >= 0 && line[i] === "\\"; i -= 1) slashes += 1;
return slashes % 2 === 1;
};
const hasUnquotedHeredocExpansionToken = (line) => {
for (let i = 0; i < line.length; i += 1) {
const ch = line[i];
if (ch === "`" && !isEscapedInHeredocLine(line, i)) return true;
if (ch === "$" && !isEscapedInHeredocLine(line, i)) {
const next = line[i + 1];
if (next === "(" || next === "{") return true;
}
}
return false;
};
for (let i = 0; i < command.length; i += 1) {
const ch = command[i];
const next = command[i + 1];
if (inHeredocBody) {
if (ch === "\n" || ch === "\r") {
const current = pendingHeredocs[0];
if (current) {
if ((current.stripTabs ? heredocLine.replace(/^\t+/, "") : heredocLine) === current.delimiter) pendingHeredocs.shift();
else if (!current.quoted && hasUnquotedHeredocExpansionToken(heredocLine)) return {
ok: false,
reason: "command substitution in unquoted heredoc",
segments: []
};
}
heredocLine = "";
if (pendingHeredocs.length === 0) inHeredocBody = false;
if (ch === "\r" && next === "\n") i += 1;
} else heredocLine += ch;
continue;
}
if (escaped) {
buf += ch;
escaped = false;
emptySegment = false;
continue;
}
if (!inSingle && !inDouble && ch === "\\") {
escaped = true;
buf += ch;
emptySegment = false;
continue;
}
if (inSingle) {
if (ch === "'") inSingle = false;
buf += ch;
emptySegment = false;
continue;
}
if (inDouble) {
if (ch === "\\" && isEscapedLineContinuation(next)) return {
ok: false,
reason: "unsupported shell token: newline",
segments: []
};
if (ch === "\\" && isDoubleQuoteEscape(next)) {
buf += ch;
buf += next;
i += 1;
emptySegment = false;
continue;
}
if (ch === "$" && next === "(") return {
ok: false,
reason: "unsupported shell token: $()",
segments: []
};
if (ch === "`") return {
ok: false,
reason: "unsupported shell token: `",
segments: []
};
if (ch === "\n" || ch === "\r") return {
ok: false,
reason: "unsupported shell token: newline",
segments: []
};
if (ch === "\"") inDouble = false;
buf += ch;
emptySegment = false;
continue;
}
if (ch === "'") {
inSingle = true;
buf += ch;
emptySegment = false;
continue;
}
if (ch === "\"") {
inDouble = true;
buf += ch;
emptySegment = false;
continue;
}
if ((ch === "\n" || ch === "\r") && pendingHeredocs.length > 0) {
inHeredocBody = true;
heredocLine = "";
if (ch === "\r" && next === "\n") i += 1;
continue;
}
if (ch === "|" && next === "|") return {
ok: false,
reason: "unsupported shell token: ||",
segments: []
};
if (ch === "|" && next === "&") return {
ok: false,
reason: "unsupported shell token: |&",
segments: []
};
if (ch === "|") {
emptySegment = true;
pushPart();
continue;
}
if (ch === "&" || ch === ";") return {
ok: false,
reason: `unsupported shell token: ${ch}`,
segments: []
};
if (ch === "<" && next === "<") {
buf += "<<";
emptySegment = false;
i += 1;
let scanIndex = i + 1;
let stripTabs = false;
if (command[scanIndex] === "-") {
stripTabs = true;
buf += "-";
scanIndex += 1;
}
const parsed = parseHeredocDelimiter(command, scanIndex);
if (parsed) {
pendingHeredocs.push({
delimiter: parsed.delimiter,
stripTabs,
quoted: parsed.quoted
});
buf += command.slice(scanIndex, parsed.end);
i = parsed.end - 1;
}
continue;
}
if (DISALLOWED_PIPELINE_TOKENS.has(ch)) return {
ok: false,
reason: `unsupported shell token: ${ch}`,
segments: []
};
if (ch === "$" && next === "(") return {
ok: false,
reason: "unsupported shell token: $()",
segments: []
};
buf += ch;
emptySegment = false;
}
if (inHeredocBody && pendingHeredocs.length > 0) {
const current = pendingHeredocs[0];
if ((current.stripTabs ? heredocLine.replace(/^\t+/, "") : heredocLine) === current.delimiter) {
pendingHeredocs.shift();
if (pendingHeredocs.length === 0) inHeredocBody = false;
}
}
if (pendingHeredocs.length > 0 || inHeredocBody) return {
ok: false,
reason: "unterminated heredoc",
segments: []
};
if (escaped || inSingle || inDouble) return {
ok: false,
reason: "unterminated shell quote/escape",
segments: []
};
pushPart();
if (emptySegment || segments.length === 0) return {
ok: false,
reason: segments.length === 0 ? "empty command" : "empty pipeline segment",
segments: []
};
return {
ok: true,
segments
};
}
function findWindowsUnsupportedToken(command) {
for (const ch of command) if (WINDOWS_UNSUPPORTED_TOKENS.has(ch)) {
if (ch === "\n" || ch === "\r") return "newline";
return ch;
}
return null;
}
function tokenizeWindowsSegment(segment) {
const tokens = [];
let buf = "";
let inDouble = false;
const pushToken = () => {
if (buf.length > 0) {
tokens.push(buf);
buf = "";
}
};
for (let i = 0; i < segment.length; i += 1) {
const ch = segment[i];
if (ch === "\"") {
inDouble = !inDouble;
continue;
}
if (!inDouble && /\s/.test(ch)) {
pushToken();
continue;
}
buf += ch;
}
if (inDouble) return null;
pushToken();
return tokens.length > 0 ? tokens : null;
}
function analyzeWindowsShellCommand(params) {
const unsupported = findWindowsUnsupportedToken(params.command);
if (unsupported) return {
ok: false,
reason: `unsupported windows shell token: ${unsupported}`,
segments: []
};
const argv = tokenizeWindowsSegment(params.command);
if (!argv || argv.length === 0) return {
ok: false,
reason: "unable to parse windows command",
segments: []
};
return {
ok: true,
segments: [{
raw: params.command,
argv,
resolution: resolveCommandResolutionFromArgv(argv, params.cwd, params.env)
}]
};
}
function isWindowsPlatform(platform) {
return String(platform ?? "").trim().toLowerCase().startsWith("win");
}
function parseSegmentsFromParts(parts, cwd, env) {
const segments = [];
for (const raw of parts) {
const argv = splitShellArgs(raw);
if (!argv || argv.length === 0) return null;
segments.push({
raw,
argv,
resolution: resolveCommandResolutionFromArgv(argv, cwd, env)
});
}
return segments;
}
/**
* Splits a command string by chain operators (&&, ||, ;) while preserving the operators.
* Returns null when no chain is present or when the chain is malformed.
*/
function splitCommandChainWithOperators(command) {
const parts = [];
let buf = "";
let inSingle = false;
let inDouble = false;
let escaped = false;
let foundChain = false;
let invalidChain = false;
const pushPart = (opToNext) => {
const trimmed = buf.trim();
buf = "";
if (!trimmed) return false;
parts.push({
part: trimmed,
opToNext
});
return true;
};
for (let i = 0; i < command.length; i += 1) {
const ch = command[i];
const next = command[i + 1];
if (escaped) {
buf += ch;
escaped = false;
continue;
}
if (!inSingle && !inDouble && ch === "\\") {
escaped = true;
buf += ch;
continue;
}
if (inSingle) {
if (ch === "'") inSingle = false;
buf += ch;
continue;
}
if (inDouble) {
if (ch === "\\" && isEscapedLineContinuation(next)) {
invalidChain = true;
break;
}
if (ch === "\\" && isDoubleQuoteEscape(next)) {
buf += ch;
buf += next;
i += 1;
continue;
}
if (ch === "\"") inDouble = false;
buf += ch;
continue;
}
if (ch === "'") {
inSingle = true;
buf += ch;
continue;
}
if (ch === "\"") {
inDouble = true;
buf += ch;
continue;
}
if (ch === "&" && next === "&") {
if (!pushPart("&&")) invalidChain = true;
i += 1;
foundChain = true;
continue;
}
if (ch === "|" && next === "|") {
if (!pushPart("||")) invalidChain = true;
i += 1;
foundChain = true;
continue;
}
if (ch === ";") {
if (!pushPart(";")) invalidChain = true;
foundChain = true;
continue;
}
buf += ch;
}
if (!foundChain) return null;
const trimmed = buf.trim();
if (!trimmed) return null;
parts.push({
part: trimmed,
opToNext: null
});
if (invalidChain || parts.length === 0) return null;
return parts;
}
function shellEscapeSingleArg(value) {
return `'${value.replace(/'/g, `'"'"'`)}'`;
}
function rebuildShellCommandFromSource(params) {
if (isWindowsPlatform(params.platform ?? null)) return {
ok: false,
reason: "unsupported platform"
};
const source = params.command.trim();
if (!source) return {
ok: false,
reason: "empty command"
};
const chainParts = splitCommandChainWithOperators(source) ?? [{
part: source,
opToNext: null
}];
let segmentCount = 0;
let out = "";
for (const part of chainParts) {
const pipelineSplit = splitShellPipeline(part.part);
if (!pipelineSplit.ok) return {
ok: false,
reason: pipelineSplit.reason ?? "unable to parse pipeline"
};
const renderedSegments = [];
for (const segmentRaw of pipelineSplit.segments) {
const rendered = params.renderSegment(segmentRaw, segmentCount);
if (!rendered.ok) return {
ok: false,
reason: rendered.reason
};
renderedSegments.push(rendered.rendered);
segmentCount += 1;
}
out += renderedSegments.join(" | ");
if (part.opToNext) out += ` ${part.opToNext} `;
}
return {
ok: true,
command: out,
segmentCount
};
}
function renderQuotedArgv(argv) {
return argv.map((token) => shellEscapeSingleArg(token)).join(" ");
}
function resolvePlannedSegmentArgv(segment) {
if (segment.resolution?.policyBlocked === true) return null;
const baseArgv = segment.resolution?.effectiveArgv && segment.resolution.effectiveArgv.length > 0 ? segment.resolution.effectiveArgv : segment.argv;
if (baseArgv.length === 0) return null;
const argv = [...baseArgv];
const resolvedExecutable = segment.resolution?.resolvedPath?.trim() ?? "";
if (resolvedExecutable) argv[0] = resolvedExecutable;
return argv;
}
function buildEnforcedShellCommand(params) {
const rebuilt = rebuildShellCommandFromSource({
command: params.command,
platform: params.platform,
renderSegment: (_raw, segmentIndex) => {
const seg = params.segments[segmentIndex];
if (!seg) return {
ok: false,
reason: "segment mapping failed"
};
const argv = resolvePlannedSegmentArgv(seg);
if (!argv) return {
ok: false,
reason: "segment execution plan unavailable"
};
return {
ok: true,
rendered: renderQuotedArgv(argv)
};
}
});
if (!rebuilt.ok) return {
ok: false,
reason: rebuilt.reason
};
if (rebuilt.segmentCount !== params.segments.length) return {
ok: false,
reason: "segment count mismatch"
};
return {
ok: true,
command: rebuilt.command
};
}
/**
* Splits a command string by chain operators (&&, ||, ;) while respecting quotes.
* Returns null when no chain is present or when the chain is malformed.
*/
function splitCommandChain(command) {
const parts = splitCommandChainWithOperators(command);
if (!parts) return null;
return parts.map((p) => p.part);
}
function analyzeShellCommand(params) {
if (isWindowsPlatform(params.platform)) return analyzeWindowsShellCommand(params);
const chainParts = splitCommandChain(params.command);
if (chainParts) {
const chains = [];
const allSegments = [];
for (const part of chainParts) {
const pipelineSplit = splitShellPipeline(part);
if (!pipelineSplit.ok) return {
ok: false,
reason: pipelineSplit.reason,
segments: []
};
const segments = parseSegmentsFromParts(pipelineSplit.segments, params.cwd, params.env);
if (!segments) return {
ok: false,
reason: "unable to parse shell segment",
segments: []
};
chains.push(segments);
allSegments.push(...segments);
}
return {
ok: true,
segments: allSegments,
chains
};
}
const split = splitShellPipeline(params.command);
if (!split.ok) return {
ok: false,
reason: split.reason,
segments: []
};
const segments = parseSegmentsFromParts(split.segments, params.cwd, params.env);
if (!segments) return {
ok: false,
reason: "unable to parse shell segment",
segments: []
};
return {
ok: true,
segments
};
}
function analyzeArgvCommand(params) {
const argv = params.argv.filter((entry) => entry.trim().length > 0);
if (argv.length === 0) return {
ok: false,
reason: "empty argv",
segments: []
};
return {
ok: true,
segments: [{
raw: argv.join(" "),
argv,
resolution: resolveCommandResolutionFromArgv(argv, params.cwd, params.env)
}]
};
}
//#endregion
//#region src/infra/exec-safe-bin-policy-validator.ts
function isPathLikeToken(value) {
const trimmed = value.trim();
if (!trimmed) return false;
if (trimmed === "-") return false;
if (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("~")) return true;
if (trimmed.startsWith("/")) return true;
return /^[A-Za-z]:[\\/]/.test(trimmed);
}
function hasGlobToken(value) {
return /[*?[\]]/.test(value);
}
const NO_FLAGS = /* @__PURE__ */ new Set();
function isSafeLiteralToken(value) {
if (!value || value === "-") return true;
return !hasGlobToken(value) && !isPathLikeToken(value);
}
function isInvalidValueToken(value) {
return !value || !isSafeLiteralToken(value);
}
function resolveCanonicalLongFlag(params) {
if (!params.flag.startsWith("--") || params.flag.length <= 2) return null;
if (params.knownLongFlagsSet.has(params.flag)) return params.flag;
return params.longFlagPrefixMap.get(params.flag) ?? null;
}
function consumeLongOptionToken(params) {
const canonicalFlag = resolveCanonicalLongFlag({
flag: params.flag,
knownLongFlagsSet: params.knownLongFlagsSet,
longFlagPrefixMap: params.longFlagPrefixMap
});
if (!canonicalFlag) return -1;
if (params.deniedFlags.has(canonicalFlag)) return -1;
const expectsValue = params.allowedValueFlags.has(canonicalFlag);
if (params.inlineValue !== void 0) {
if (!expectsValue) return -1;
return isSafeLiteralToken(params.inlineValue) ? params.index + 1 : -1;
}
if (!expectsValue) return params.index + 1;
return isInvalidValueToken(params.args[params.index + 1]) ? -1 : params.index + 2;
}
function consumeShortOptionClusterToken(params) {
for (let j = 0; j < params.flags.length; j += 1) {
const flag = params.flags[j];
if (params.deniedFlags.has(flag)) return -1;
if (!params.allowedValueFlags.has(flag)) continue;
const inlineValue = params.cluster.slice(j + 1);
if (inlineValue) return isSafeLiteralToken(inlineValue) ? params.index + 1 : -1;
return isInvalidValueToken(params.args[params.index + 1]) ? -1 : params.index + 2;
}
return -1;
}
function consumePositionalToken(token, positional) {
if (!isSafeLiteralToken(token)) return false;
positional.push(token);
return true;
}
function validatePositionalCount(positional, profile) {
const minPositional = profile.minPositional ?? 0;
if (positional.length < minPositional) return false;
return typeof profile.maxPositional !== "number" || positional.length <= profile.maxPositional;
}
function validateSafeBinArgv(args, profile) {
const allowedValueFlags = profile.allowedValueFlags ?? NO_FLAGS;
const deniedFlags = profile.deniedFlags ?? NO_FLAGS;
const knownLongFlags = profile.knownLongFlags ?? collectKnownLongFlags(allowedValueFlags, deniedFlags);
const knownLongFlagsSet = profile.knownLongFlagsSet ?? new Set(knownLongFlags);
const longFlagPrefixMap = profile.longFlagPrefixMap ?? buildLongFlagPrefixMap(knownLongFlags);
const positional = [];
let i = 0;
while (i < args.length) {
const token = parseExecArgvToken(args[i] ?? "");
if (token.kind === "empty" || token.kind === "stdin") {
i += 1;
continue;
}
if (token.kind === "terminator") {
for (let j = i + 1; j < args.length; j += 1) {
const rest = args[j];
if (!rest || rest === "-") continue;
if (!consumePositionalToken(rest, positional)) return false;
}
break;
}
if (token.kind === "positional") {
if (!consumePositionalToken(token.raw, positional)) return false;
i += 1;
continue;
}
if (token.style === "long") {
const nextIndex = consumeLongOptionToken({
args,
index: i,
flag: token.flag,
inlineValue: token.inlineValue,
allowedValueFlags,
deniedFlags,
knownLongFlagsSet,
longFlagPrefixMap
});
if (nextIndex < 0) return false;
i = nextIndex;
continue;
}
const nextIndex = consumeShortOptionClusterToken({
args,
index: i,
cluster: token.cluster,
flags: token.flags,
allowedValueFlags,
deniedFlags
});
if (nextIndex < 0) return false;
i = nextIndex;
}
return validatePositionalCount(positional, profile);
}
//#endregion
//#region src/infra/exec-safe-bin-trust.ts
const DEFAULT_SAFE_BIN_TRUSTED_DIRS = ["/bin", "/usr/bin"];
let trustedSafeBinCache = null;
function normalizeTrustedDir(value) {
const trimmed = value.trim();
if (!trimmed) return null;
return path.resolve(trimmed);
}
function normalizeTrustedSafeBinDirs(entries) {
if (!Array.isArray(entries)) return [];
const normalized = entries.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
return Array.from(new Set(normalized));
}
function resolveTrustedSafeBinDirs(entries) {
const resolved = entries.map((entry) => normalizeTrustedDir(entry)).filter((entry) => Boolean(entry));
return Array.from(new Set(resolved)).toSorted();
}
function buildTrustedSafeBinCacheKey(entries) {
return resolveTrustedSafeBinDirs(normalizeTrustedSafeBinDirs(entries)).join("");
}
function buildTrustedSafeBinDirs(params = {}) {
const baseDirs = params.baseDirs ?? DEFAULT_SAFE_BIN_TRUSTED_DIRS;
const extraDirs = params.extraDirs ?? [];
return new Set(resolveTrustedSafeBinDirs([...normalizeTrustedSafeBinDirs(baseDirs), ...normalizeTrustedSafeBinDirs(extraDirs)]));
}
function getTrustedSafeBinDirs(params = {}) {
const baseDirs = params.baseDirs ?? DEFAULT_SAFE_BIN_TRUSTED_DIRS;
const extraDirs = params.extraDirs ?? [];
const key = buildTrustedSafeBinCacheKey([...baseDirs, ...extraDirs]);
if (!params.refresh && trustedSafeBinCache?.key === key) return trustedSafeBinCache.dirs;
const dirs = buildTrustedSafeBinDirs({
baseDirs,
extraDirs
});
trustedSafeBinCache = {
key,
dirs
};
return dirs;
}
function isTrustedSafeBinPath(params) {
const trustedDirs = params.trustedDirs ?? getTrustedSafeBinDirs();
const resolvedDir = path.dirname(path.resolve(params.resolvedPath));
return trustedDirs.has(resolvedDir);
}
function listWritableExplicitTrustedSafeBinDirs(entries) {
if (process.platform === "win32") return [];
const resolved = resolveTrustedSafeBinDirs(normalizeTrustedSafeBinDirs(entries));
const hits = [];
for (const dir of resolved) {
let stat;
try {
stat = fs.statSync(dir);
} catch {
continue;
}
if (!stat.isDirectory()) continue;
const mode = stat.mode & 511;
const groupWritable = (mode & 16) !== 0;
const worldWritable = (mode & 2) !== 0;
if (!groupWritable && !worldWritable) continue;
hits.push({
dir,
groupWritable,
worldWritable
});
}
return hits;
}
//#endregion
//#region src/config/normalize-exec-safe-bin.ts
function normalizeExecSafeBinProfilesInConfig(cfg) {
const normalizeExec = (exec) => {
if (!exec || typeof exec !== "object" || Array.isArray(exec)) return;
const typedExec = exec;
const normalizedProfiles = normalizeSafeBinProfileFixtures(typedExec.safeBinProfiles);
typedExec.safeBinProfiles = Object.keys(normalizedProfiles).length > 0 ? normalizedProfiles : void 0;
const normalizedTrustedDirs = normalizeTrustedSafeBinDirs(typedExec.safeBinTrustedDirs);
typedExec.safeBinTrustedDirs = normalizedTrustedDirs.length > 0 ? normalizedTrustedDirs : void 0;
};
normalizeExec(cfg.tools?.exec);
const agents = Array.isArray(cfg.agents?.list) ? cfg.agents.list : [];
for (const agent of agents) normalizeExec(agent?.tools?.exec);
}
//#endregion
//#region src/config/normalize-paths.ts
const PATH_VALUE_RE = /^~(?=$|[\\/])/;
const PATH_KEY_RE = /(dir|path|paths|file|root|workspace)$/i;
const PATH_LIST_KEYS = new Set(["paths", "pathPrepend"]);
function normalizeStringValue(key, value) {
if (!PATH_VALUE_RE.test(value.trim())) return value;
if (!key) return value;
if (PATH_KEY_RE.test(key) || PATH_LIST_KEYS.has(key)) return resolveUserPath(value);
return value;
}
function normalizeAny(key, value) {
if (typeof value === "string") return normalizeStringValue(key, value);
if (Array.isArray(value)) {
const normalizeChildren = Boolean(key && PATH_LIST_KEYS.has(key));
return value.map((entry) => {
if (typeof entry === "string") return normalizeChildren ? normalizeStringValue(key, entry) : entry;
if (Array.isArray(entry)) return normalizeAny(void 0, entry);
if (isPlainObject$2(entry)) return normalizeAny(void 0, entry);
return entry;
});
}
if (!isPlainObject$2(value)) return value;
for (const [childKey, childValue] of Object.entries(value)) {
const next = normalizeAny(childKey, childValue);
if (next !== childValue) value[childKey] = next;
}
return value;
}
/**
* Normalize "~" paths in path-ish config fields.
*
* Goal: accept `~/...` consistently across config file + env overrides, while
* keeping the surface area small and predictable.
*/
function normalizeConfigPaths(cfg) {
if (!cfg || typeof cfg !== "object") return cfg;
normalizeAny(void 0, cfg);
return cfg;
}
//#endregion
//#region src/config/config-paths.ts
function parseConfigPath(raw) {
const trimmed = raw.trim();
if (!trimmed) return {
ok: false,
error: "Invalid path. Use dot notation (e.g. foo.bar)."
};
const parts = trimmed.split(".").map((part) => part.trim());
if (parts.some((part) => !part)) return {
ok: false,
error: "Invalid path. Use dot notation (e.g. foo.bar)."
};
if (parts.some((part) => isBlockedObjectKey(part))) return {
ok: false,
error: "Invalid path segment."
};
return {
ok: true,
path: parts
};
}
function setConfigValueAtPath(root, path, value) {
let cursor = root;
for (let idx = 0; idx < path.length - 1; idx += 1) {
const key = path[idx];
const next = cursor[key];
if (!isPlainObject$2(next)) cursor[key] = {};
cursor = cursor[key];
}
cursor[path[path.length - 1]] = value;
}
function unsetConfigValueAtPath(root, path) {
const stack = [];
let cursor = root;
for (let idx = 0; idx < path.length - 1; idx += 1) {
const key = path[idx];
const next = cursor[key];
if (!isPlainObject$2(next)) return false;
stack.push({
node: cursor,
key
});
cursor = next;
}
const leafKey = path[path.length - 1];
if (!(leafKey in cursor)) return false;
delete cursor[leafKey];
for (let idx = stack.length - 1; idx >= 0; idx -= 1) {
const { node, key } = stack[idx];
const child = node[key];
if (isPlainObject$2(child) && Object.keys(child).length === 0) delete node[key];
else break;
}
return true;
}
function getConfigValueAtPath(root, path) {
let cursor = root;
for (const key of path) {
if (!isPlainObject$2(cursor)) return;
cursor = cursor[key];
}
return cursor;
}
//#endregion
//#region src/config/runtime-overrides.ts
let overrides = {};
function sanitizeOverrideValue(value, seen = /* @__PURE__ */ new WeakSet()) {
if (Array.isArray(value)) return value.map((entry) => sanitizeOverrideValue(entry, seen));
if (!isPlainObject$2(value)) return value;
if (seen.has(value)) return {};
seen.add(value);
const sanitized = {};
for (const [key, entry] of Object.entries(value)) {
if (entry === void 0 || isBlockedObjectKey(key)) continue;
sanitized[key] = sanitizeOverrideValue(entry, seen);
}
seen.delete(value);
return sanitized;
}
function mergeOverrides(base, override) {
if (!isPlainObject$2(base) || !isPlainObject$2(override)) return override;
const next = { ...base };
for (const [key, value] of Object.entries(override)) {
if (value === void 0 || isBlockedObjectKey(key)) continue;
next[key] = mergeOverrides(base[key], value);
}
return next;
}
function getConfigOverrides() {
return overrides;
}
function resetConfigOverrides() {
overrides = {};
}
function setConfigOverride(pathRaw, value) {
const parsed = parseConfigPath(pathRaw);
if (!parsed.ok || !parsed.path) return {
ok: false,
error: parsed.error ?? "Invalid path."
};
setConfigValueAtPath(overrides, parsed.path, sanitizeOverrideValue(value));
return { ok: true };
}
function unsetConfigOverride(pathRaw) {
const parsed = parseConfigPath(pathRaw);
if (!parsed.ok || !parsed.path) return {
ok: false,
removed: false,
error: parsed.error ?? "Invalid path."
};
return {
ok: true,
removed: unsetConfigValueAtPath(overrides, parsed.path)
};
}
function applyConfigOverrides(cfg) {
if (!overrides || Object.keys(overrides).length === 0) return cfg;
return mergeOverrides(cfg, overrides);
}
//#endregion
//#region src/plugins/schema-validator.ts
const ajv = new AjvPkg({
allErrors: true,
strict: false,
removeAdditional: false
});
const schemaCache = /* @__PURE__ */ new Map();
function formatAjvErrors(errors) {
if (!errors || errors.length === 0) return ["invalid config"];
return errors.map((error) => {
return `${error.instancePath?.replace(/^\//, "").replace(/\//g, ".") || "<root>"}: ${error.message ?? "invalid"}`;
});
}
function validateJsonSchemaValue(params) {
let cached = schemaCache.get(params.cacheKey);
if (!cached || cached.schema !== params.schema) {
cached = {
validate: ajv.compile(params.schema),
schema: params.schema
};
schemaCache.set(params.cacheKey, cached);
}
if (cached.validate(params.value)) return { ok: true };
return {
ok: false,
errors: formatAjvErrors(cached.validate.errors)
};
}
//#endregion
//#region src/shared/avatar-policy.ts
const AVATAR_MAX_BYTES = 2 * 1024 * 1024;
const LOCAL_AVATAR_EXTENSIONS = new Set([
".png",
".jpg",
".jpeg",
".gif",
".webp",
".svg"
]);
const AVATAR_MIME_BY_EXT = {
".png": "image/png",
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
".webp": "image/webp",
".gif": "image/gif",
".svg": "image/svg+xml",
".bmp": "image/bmp",
".tif": "image/tiff",
".tiff": "image/tiff"
};
const AVATAR_DATA_RE = /^data:/i;
const AVATAR_IMAGE_DATA_RE = /^data:image\//i;
const AVATAR_HTTP_RE = /^https?:\/\//i;
const AVATAR_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
const WINDOWS_ABS_RE = /^[a-zA-Z]:[\\/]/;
const AVATAR_PATH_EXT_RE = /\.(png|jpe?g|gif|webp|svg|ico)$/i;
function resolveAvatarMime(filePath) {
return AVATAR_MIME_BY_EXT[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
}
function isAvatarDataUrl(value) {
return AVATAR_DATA_RE.test(value);
}
function isAvatarImageDataUrl(value) {
return AVATAR_IMAGE_DATA_RE.test(value);
}
function isAvatarHttpUrl(value) {
return AVATAR_HTTP_RE.test(value);
}
function hasAvatarUriScheme(value) {
return AVATAR_SCHEME_RE.test(value);
}
function isWindowsAbsolutePath(value) {
return WINDOWS_ABS_RE.test(value);
}
function isWorkspaceRelativeAvatarPath(value) {
if (!value) return false;
if (value.startsWith("~")) return false;
if (hasAvatarUriScheme(value) && !isWindowsAbsolutePath(value)) return false;
return true;
}
function isPathWithinRoot(rootDir, targetPath) {
const relative = path.relative(rootDir, targetPath);
if (relative === "") return true;
return !relative.startsWith("..") && !path.isAbsolute(relative);
}
function looksLikeAvatarPath(value) {
if (/[\\/]/.test(value)) return true;
return AVATAR_PATH_EXT_RE.test(value);
}
function isSupportedLocalAvatarExtension(filePath) {
const ext = path.extname(filePath).toLowerCase();
return LOCAL_AVATAR_EXTENSIONS.has(ext);
}
//#endregion
//#region src/cli/parse-bytes.ts
const UNIT_MULTIPLIERS = {
b: 1,
kb: 1024,
k: 1024,
mb: 1024 ** 2,
m: 1024 ** 2,
gb: 1024 ** 3,
g: 1024 ** 3,
tb: 1024 ** 4,
t: 1024 ** 4
};
function parseByteSize(raw, opts) {
const trimmed = String(raw ?? "").trim().toLowerCase();
if (!trimmed) throw new Error("invalid byte size (empty)");
const m = /^(\d+(?:\.\d+)?)([a-z]+)?$/.exec(trimmed);
if (!m) throw new Error(`invalid byte size: ${raw}`);
const value = Number(m[1]);
if (!Number.isFinite(value) || value < 0) throw new Error(`invalid byte size: ${raw}`);
const multiplier = UNIT_MULTIPLIERS[(m[2] ?? opts?.defaultUnit ?? "b").toLowerCase()];
if (!multiplier) throw new Error(`invalid byte size unit: ${raw}`);
const bytes = Math.round(value * multiplier);
if (!Number.isFinite(bytes)) throw new Error(`invalid byte size: ${raw}`);
return bytes;
}
//#endregion
//#region src/cli/parse-duration.ts
const DURATION_MULTIPLIERS = {
ms: 1,
s: 1e3,
m: 6e4,
h: 36e5,
d: 864e5
};
function parseDurationMs(raw, opts) {
const trimmed = String(raw ?? "").trim().toLowerCase();
if (!trimmed) throw new Error("invalid duration (empty)");
const single = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/.exec(trimmed);
if (single) {
const value = Number(single[1]);
if (!Number.isFinite(value) || value < 0) throw new Error(`invalid duration: ${raw}`);
const unit = single[2] ?? opts?.defaultUnit ?? "ms";
const ms = Math.round(value * DURATION_MULTIPLIERS[unit]);
if (!Number.isFinite(ms)) throw new Error(`invalid duration: ${raw}`);
return ms;
}
let totalMs = 0;
let consumed = 0;
for (const match of trimmed.matchAll(/(\d+(?:\.\d+)?)(ms|s|m|h|d)/g)) {
const [full, valueRaw, unitRaw] = match;
const index = match.index ?? -1;
if (!full || !valueRaw || !unitRaw || index < 0) throw new Error(`invalid duration: ${raw}`);
if (index !== consumed) throw new Error(`invalid duration: ${raw}`);
const value = Number(valueRaw);
if (!Number.isFinite(value) || value < 0) throw new Error(`invalid duration: ${raw}`);
const multiplier = DURATION_MULTIPLIERS[unitRaw];
if (!multiplier) throw new Error(`invalid duration: ${raw}`);
totalMs += value * multiplier;
consumed += full.length;
}
if (consumed !== trimmed.length || consumed === 0) throw new Error(`invalid duration: ${raw}`);
const ms = Math.round(totalMs);
if (!Number.isFinite(ms)) throw new Error(`invalid duration: ${raw}`);
return ms;
}
//#endregion
//#region src/agents/sandbox/network-mode.ts
function normalizeNetworkMode(network) {
return network?.trim().toLowerCase() || void 0;
}
function getBlockedNetworkModeReason(params) {
const normalized = normalizeNetworkMode(params.network);
if (!normalized) return null;
if (normalized === "host") return "host";
if (normalized.startsWith("container:") && params.allowContainerNamespaceJoin !== true) return "container_namespace_join";
return null;
}
function isDangerousNetworkMode(network) {
const normalized = normalizeNetworkMode(network);
return normalized === "host" || normalized?.startsWith("container:") === true;
}
//#endregion
//#region src/config/zod-schema.agent-model.ts
const AgentModelSchema = z.union([z.string(), z.object({
primary: z.string().optional(),
fallbacks: z.array(z.string()).optional()
}).strict()]);
//#endregion
//#region src/config/zod-schema.allowdeny.ts
const AllowDenyActionSchema = z.union([z.literal("allow"), z.literal("deny")]);
const AllowDenyChatTypeSchema = z.union([
z.literal("direct"),
z.literal("group"),
z.literal("channel"),
z.literal("dm")
]).optional();
function createAllowDenyChannelRulesSchema() {
return z.object({
default: AllowDenyActionSchema.optional(),
rules: z.array(z.object({
action: AllowDenyActionSchema,
match: z.object({
channel: z.string().optional(),
chatType: AllowDenyChatTypeSchema,
keyPrefix: z.string().optional(),
rawKeyPrefix: z.string().optional()
}).strict().optional()
}).strict()).optional()
}).strict().optional();
}
//#endregion
//#region src/config/zod-schema.sensitive.ts
const sensitive = z.registry();
//#endregion
//#region src/config/zod-schema.core.ts
const ModelApiSchema = z.union([
z.literal("openai-completions"),
z.literal("openai-responses"),
z.literal("anthropic-messages"),
z.literal("google-generative-ai"),
z.literal("github-copilot"),
z.literal("bedrock-converse-stream"),
z.literal("ollama")
]);
const ModelCompatSchema = z.object({
supportsStore: z.boolean().optional(),
supportsDeveloperRole: z.boolean().optional(),
supportsReasoningEffort: z.boolean().optional(),
supportsUsageInStreaming: z.boolean().optional(),
supportsStrictMode: z.boolean().optional(),
maxTokensField: z.union([z.literal("max_completion_tokens"), z.literal("max_tokens")]).optional(),
thinkingFormat: z.union([
z.literal("openai"),
z.literal("zai"),
z.literal("qwen")
]).optional(),
requiresToolResultName: z.boolean().optional(),
requiresAssistantAfterToolResult: z.boolean().optional(),
requiresThinkingAsText: z.boolean().optional(),
requiresMistralToolIds: z.boolean().optional()
}).strict().optional();
const ModelDefinitionSchema = z.object({
id: z.string().min(1),
name: z.string().min(1),
api: ModelApiSchema.optional(),
reasoning: z.boolean().optional(),
input: z.array(z.union([z.literal("text"), z.literal("image")])).optional(),
cost: z.object({
input: z.number().optional(),
output: z.number().optional(),
cacheRead: z.number().optional(),
cacheWrite: z.number().optional()
}).strict().optional(),
contextWindow: z.number().positive().optional(),
maxTokens: z.number().positive().optional(),
headers: z.record(z.string(), z.string()).optional(),
compat: ModelCompatSchema
}).strict();
const ModelProviderSchema = z.object({
baseUrl: z.string().min(1),
apiKey: z.string().optional().register(sensitive),
auth: z.union([
z.literal("api-key"),
z.literal("aws-sdk"),
z.literal("oauth"),
z.literal("token")
]).optional(),
api: ModelApiSchema.optional(),
headers: z.record(z.string(), z.string()).optional(),
authHeader: z.boolean().optional(),
models: z.array(ModelDefinitionSchema)
}).strict();
const BedrockDiscoverySchema = z.object({
enabled: z.boolean().optional(),
region: z.string().optional(),
providerFilter: z.array(z.string()).optional(),
refreshInterval: z.number().int().nonnegative().optional(),
defaultContextWindow: z.number().int().positive().optional(),
defaultMaxTokens: z.number().int().positive().optional()
}).strict().optional();
const ModelsConfigSchema = z.object({
mode: z.union([z.literal("merge"), z.literal("replace")]).optional(),
providers: z.record(z.string(), ModelProviderSchema).optional(),
bedrockDiscovery: BedrockDiscoverySchema
}).strict().optional();
const GroupChatSchema = z.object({
mentionPatterns: z.array(z.string()).optional(),
historyLimit: z.number().int().positive().optional()
}).strict().optional();
const DmConfigSchema = z.object({ historyLimit: z.number().int().min(0).optional() }).strict();
const IdentitySchema = z.object({
name: z.string().optional(),
theme: z.string().optional(),
emoji: z.string().optional(),
avatar: z.string().optional()
}).strict().optional();
const QueueModeSchema = z.union([
z.literal("steer"),
z.literal("followup"),
z.literal("collect"),
z.literal("steer-backlog"),
z.literal("steer+backlog"),
z.literal("queue"),
z.literal("interrupt")
]);
const QueueDropSchema = z.union([
z.literal("old"),
z.literal("new"),
z.literal("summarize")
]);
const ReplyToModeSchema = z.union([
z.literal("off"),
z.literal("first"),
z.literal("all")
]);
const TypingModeSchema = z.union([
z.literal("never"),
z.literal("instant"),
z.literal("thinking"),
z.literal("message")
]);
const GroupPolicySchema = z.enum([
"open",
"disabled",
"allowlist"
]);
const DmPolicySchema = z.enum([
"pairing",
"allowlist",
"open",
"disabled"
]);
const BlockStreamingCoalesceSchema = z.object({
minChars: z.number().int().positive().optional(),
maxChars: z.number().int().positive().optional(),
idleMs: z.number().int().nonnegative().optional()
}).strict();
const ReplyRuntimeConfigSchemaShape = {
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
blockStreaming: z.boolean().optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
responsePrefix: z.string().optional(),
mediaMaxMb: z.number().positive().optional()
};
const BlockStreamingChunkSchema = z.object({
minChars: z.number().int().positive().optional(),
maxChars: z.number().int().positive().optional(),
breakPreference: z.union([
z.literal("paragraph"),
z.literal("newline"),
z.literal("sentence")
]).optional()
}).strict();
const MarkdownTableModeSchema = z.enum([
"off",
"bullets",
"code"
]);
const MarkdownConfigSchema = z.object({ tables: MarkdownTableModeSchema.optional() }).strict().optional();
const TtsProviderSchema = z.enum([
"elevenlabs",
"openai",
"edge"
]);
const TtsModeSchema = z.enum(["final", "all"]);
const TtsAutoSchema = z.enum([
"off",
"always",
"inbound",
"tagged"
]);
const TtsConfigSchema = z.object({
auto: TtsAutoSchema.optional(),
enabled: z.boolean().optional(),
mode: TtsModeSchema.optional(),
provider: TtsProviderSchema.optional(),
summaryModel: z.string().optional(),
modelOverrides: z.object({
enabled: z.boolean().optional(),
allowText: z.boolean().optional(),
allowProvider: z.boolean().optional(),
allowVoice: z.boolean().optional(),
allowModelId: z.boolean().optional(),
allowVoiceSettings: z.boolean().optional(),
allowNormalization: z.boolean().optional(),
allowSeed: z.boolean().optional()
}).strict().optional(),
elevenlabs: z.object({
apiKey: z.string().optional().register(sensitive),
baseUrl: z.string().optional(),
voiceId: z.string().optional(),
modelId: z.string().optional(),
seed: z.number().int().min(0).max(4294967295).optional(),
applyTextNormalization: z.enum([
"auto",
"on",
"off"
]).optional(),
languageCode: z.string().optional(),
voiceSettings: z.object({
stability: z.number().min(0).max(1).optional(),
similarityBoost: z.number().min(0).max(1).optional(),
style: z.number().min(0).max(1).optional(),
useSpeakerBoost: z.boolean().optional(),
speed: z.number().min(.5).max(2).optional()
}).strict().optional()
}).strict().optional(),
openai: z.object({
apiKey: z.string().optional().register(sensitive),
model: z.string().optional(),
voice: z.string().optional()
}).strict().optional(),
edge: z.object({
enabled: z.boolean().optional(),
voice: z.string().optional(),
lang: z.string().optional(),
outputFormat: z.string().optional(),
pitch: z.string().optional(),
rate: z.string().optional(),
volume: z.string().optional(),
saveSubtitles: z.boolean().optional(),
proxy: z.string().optional(),
timeoutMs: z.number().int().min(1e3).max(12e4).optional()
}).strict().optional(),
prefsPath: z.string().optional(),
maxTextLength: z.number().int().min(1).optional(),
timeoutMs: z.number().int().min(1e3).max(12e4).optional()
}).strict().optional();
const HumanDelaySchema = z.object({
mode: z.union([
z.literal("off"),
z.literal("natural"),
z.literal("custom")
]).optional(),
minMs: z.number().int().nonnegative().optional(),
maxMs: z.number().int().nonnegative().optional()
}).strict();
const CliBackendWatchdogModeSchema = z.object({
noOutputTimeoutMs: z.number().int().min(1e3).optional(),
noOutputTimeoutRatio: z.number().min(.05).max(.95).optional(),
minMs: z.number().int().min(1e3).optional(),
maxMs: z.number().int().min(1e3).optional()
}).strict().optional();
const CliBackendSchema = z.object({
command: z.string(),
args: z.array(z.string()).optional(),
output: z.union([
z.literal("json"),
z.literal("text"),
z.literal("jsonl")
]).optional(),
resumeOutput: z.union([
z.literal("json"),
z.literal("text"),
z.literal("jsonl")
]).optional(),
input: z.union([z.literal("arg"), z.literal("stdin")]).optional(),
maxPromptArgChars: z.number().int().positive().optional(),
env: z.record(z.string(), z.string()).optional(),
clearEnv: z.array(z.string()).optional(),
modelArg: z.string().optional(),
modelAliases: z.record(z.string(), z.string()).optional(),
sessionArg: z.string().optional(),
sessionArgs: z.array(z.string()).optional(),
resumeArgs: z.array(z.string()).optional(),
sessionMode: z.union([
z.literal("always"),
z.literal("existing"),
z.literal("none")
]).optional(),
sessionIdFields: z.array(z.string()).optional(),
systemPromptArg: z.string().optional(),
systemPromptMode: z.union([z.literal("append"), z.literal("replace")]).optional(),
systemPromptWhen: z.union([
z.literal("first"),
z.literal("always"),
z.literal("never")
]).optional(),
imageArg: z.string().optional(),
imageMode: z.union([z.literal("repeat"), z.literal("list")]).optional(),
serialize: z.boolean().optional(),
reliability: z.object({ watchdog: z.object({
fresh: CliBackendWatchdogModeSchema,
resume: CliBackendWatchdogModeSchema
}).strict().optional() }).strict().optional()
}).strict();
const normalizeAllowFrom = (values) => (values ?? []).map((v) => String(v).trim()).filter(Boolean);
const requireOpenAllowFrom = (params) => {
if (params.policy !== "open") return;
if (normalizeAllowFrom(params.allowFrom).includes("*")) return;
params.ctx.addIssue({
code: z.ZodIssueCode.custom,
path: params.path,
message: params.message
});
};
const MSTeamsReplyStyleSchema = z.enum(["thread", "top-level"]);
const RetryConfigSchema = z.object({
attempts: z.number().int().min(1).optional(),
minDelayMs: z.number().int().min(0).optional(),
maxDelayMs: z.number().int().min(0).optional(),
jitter: z.number().min(0).max(1).optional()
}).strict().optional();
const QueueModeBySurfaceSchema = z.object({
whatsapp: QueueModeSchema.optional(),
telegram: QueueModeSchema.optional(),
discord: QueueModeSchema.optional(),
irc: QueueModeSchema.optional(),
slack: QueueModeSchema.optional(),
mattermost: QueueModeSchema.optional(),
signal: QueueModeSchema.optional(),
imessage: QueueModeSchema.optional(),
msteams: QueueModeSchema.optional(),
webchat: QueueModeSchema.optional()
}).strict().optional();
const DebounceMsBySurfaceSchema = z.record(z.string(), z.number().int().nonnegative()).optional();
const QueueSchema = z.object({
mode: QueueModeSchema.optional(),
byChannel: QueueModeBySurfaceSchema,
debounceMs: z.number().int().nonnegative().optional(),
debounceMsByChannel: DebounceMsBySurfaceSchema,
cap: z.number().int().positive().optional(),
drop: QueueDropSchema.optional()
}).strict().optional();
const InboundDebounceSchema = z.object({
debounceMs: z.number().int().nonnegative().optional(),
byChannel: DebounceMsBySurfaceSchema
}).strict().optional();
const TranscribeAudioSchema = z.object({
command: z.array(z.string()).superRefine((value, ctx) => {
const executable = value[0];
if (!isSafeExecutableValue(executable)) ctx.addIssue({
code: z.ZodIssueCode.custom,
path: [0],
message: "expected safe executable name or path"
});
}),
timeoutSeconds: z.number().int().positive().optional()
}).strict().optional();
const HexColorSchema = z.string().regex(/^#?[0-9a-fA-F]{6}$/, "expected hex color (RRGGBB)");
const ExecutableTokenSchema = z.string().refine(isSafeExecutableValue, "expected safe executable name or path");
const MediaUnderstandingScopeSchema = createAllowDenyChannelRulesSchema();
const MediaUnderstandingCapabilitiesSchema = z.array(z.union([
z.literal("image"),
z.literal("audio"),
z.literal("video")
])).optional();
const MediaUnderstandingAttachmentsSchema = z.object({
mode: z.union([z.literal("first"), z.literal("all")]).optional(),
maxAttachments: z.number().int().positive().optional(),
prefer: z.union([
z.literal("first"),
z.literal("last"),
z.literal("path"),
z.literal("url")
]).optional()
}).strict().optional();
const DeepgramAudioSchema = z.object({
detectLanguage: z.boolean().optional(),
punctuate: z.boolean().optional(),
smartFormat: z.boolean().optional()
}).strict().optional();
const ProviderOptionValueSchema = z.union([
z.string(),
z.number(),
z.boolean()
]);
const ProviderOptionsSchema = z.record(z.string(), z.record(z.string(), ProviderOptionValueSchema)).optional();
const MediaUnderstandingRuntimeFields = {
prompt: z.string().optional(),
timeoutSeconds: z.number().int().positive().optional(),
language: z.string().optional(),
providerOptions: ProviderOptionsSchema,
deepgram: DeepgramAudioSchema,
baseUrl: z.string().optional(),
headers: z.record(z.string(), z.string()).optional()
};
const MediaUnderstandingModelSchema = z.object({
provider: z.string().optional(),
model: z.string().optional(),
capabilities: MediaUnderstandingCapabilitiesSchema,
type: z.union([z.literal("provider"), z.literal("cli")]).optional(),
command: z.string().optional(),
args: z.array(z.string()).optional(),
maxChars: z.number().int().positive().optional(),
maxBytes: z.number().int().positive().optional(),
...MediaUnderstandingRuntimeFields,
profile: z.string().optional(),
preferredProfile: z.string().optional()
}).strict().optional();
const ToolsMediaUnderstandingSchema = z.object({
enabled: z.boolean().optional(),
scope: MediaUnderstandingScopeSchema,
maxBytes: z.number().int().positive().optional(),
maxChars: z.number().int().positive().optional(),
...MediaUnderstandingRuntimeFields,
attachments: MediaUnderstandingAttachmentsSchema,
models: z.array(MediaUnderstandingModelSchema).optional()
}).strict().optional();
const ToolsMediaSchema = z.object({
models: z.array(MediaUnderstandingModelSchema).optional(),
concurrency: z.number().int().positive().optional(),
image: ToolsMediaUnderstandingSchema.optional(),
audio: ToolsMediaUnderstandingSchema.optional(),
video: ToolsMediaUnderstandingSchema.optional()
}).strict().optional();
const LinkModelSchema = z.object({
type: z.literal("cli").optional(),
command: z.string().min(1),
args: z.array(z.string()).optional(),
timeoutSeconds: z.number().int().positive().optional()
}).strict();
const ToolsLinksSchema = z.object({
enabled: z.boolean().optional(),
scope: MediaUnderstandingScopeSchema,
maxLinks: z.number().int().positive().optional(),
timeoutSeconds: z.number().int().positive().optional(),
models: z.array(LinkModelSchema).optional()
}).strict().optional();
const NativeCommandsSettingSchema = z.union([z.boolean(), z.literal("auto")]);
const ProviderCommandsSchema = z.object({
native: NativeCommandsSettingSchema.optional(),
nativeSkills: NativeCommandsSettingSchema.optional()
}).strict().optional();
//#endregion
//#region src/config/zod-schema.agent-runtime.ts
const HeartbeatSchema = z.object({
every: z.string().optional(),
activeHours: z.object({
start: z.string().optional(),
end: z.string().optional(),
timezone: z.string().optional()
}).strict().optional(),
model: z.string().optional(),
session: z.string().optional(),
includeReasoning: z.boolean().optional(),
target: z.string().optional(),
to: z.string().optional(),
accountId: z.string().optional(),
prompt: z.string().optional(),
ackMaxChars: z.number().int().nonnegative().optional(),
suppressToolErrorWarnings: z.boolean().optional()
}).strict().superRefine((val, ctx) => {
if (!val.every) return;
try {
parseDurationMs(val.every, { defaultUnit: "m" });
} catch {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["every"],
message: "invalid duration (use ms, s, m, h)"
});
}
const active = val.activeHours;
if (!active) return;
const timePattern = /^([01]\d|2[0-3]|24):([0-5]\d)$/;
const validateTime = (raw, opts, path) => {
if (!raw) return;
if (!timePattern.test(raw)) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["activeHours", path],
message: "invalid time (use \"HH:MM\" 24h format)"
});
return;
}
const [hourStr, minuteStr] = raw.split(":");
const hour = Number(hourStr);
if (hour === 24 && Number(minuteStr) !== 0) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["activeHours", path],
message: "invalid time (24:00 is the only allowed 24:xx value)"
});
return;
}
if (hour === 24 && !opts.allow24) ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["activeHours", path],
message: "invalid time (start cannot be 24:00)"
});
};
validateTime(active.start, { allow24: false }, "start");
validateTime(active.end, { allow24: true }, "end");
}).optional();
const SandboxDockerSchema = z.object({
image: z.string().optional(),
containerPrefix: z.string().optional(),
workdir: z.string().optional(),
readOnlyRoot: z.boolean().optional(),
tmpfs: z.array(z.string()).optional(),
network: z.string().optional(),
user: z.string().optional(),
capDrop: z.array(z.string()).optional(),
env: z.record(z.string(), z.string()).optional(),
setupCommand: z.string().optional(),
pidsLimit: z.number().int().positive().optional(),
memory: z.union([z.string(), z.number()]).optional(),
memorySwap: z.union([z.string(), z.number()]).optional(),
cpus: z.number().positive().optional(),
ulimits: z.record(z.string(), z.union([
z.string(),
z.number(),
z.object({
soft: z.number().int().nonnegative().optional(),
hard: z.number().int().nonnegative().optional()
}).strict()
])).optional(),
seccompProfile: z.string().optional(),
apparmorProfile: z.string().optional(),
dns: z.array(z.string()).optional(),
extraHosts: z.array(z.string()).optional(),
binds: z.array(z.string()).optional(),
dangerouslyAllowReservedContainerTargets: z.boolean().optional(),
dangerouslyAllowExternalBindSources: z.boolean().optional(),
dangerouslyAllowContainerNamespaceJoin: z.boolean().optional()
}).strict().superRefine((data, ctx) => {
if (data.binds) for (let i = 0; i < data.binds.length; i += 1) {
const bind = data.binds[i]?.trim() ?? "";
if (!bind) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["binds", i],
message: "Sandbox security: bind mount entry must be a non-empty string."
});
continue;
}
const firstColon = bind.indexOf(":");
const source = (firstColon <= 0 ? bind : bind.slice(0, firstColon)).trim();
if (!source.startsWith("/")) ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["binds", i],
message: `Sandbox security: bind mount "${bind}" uses a non-absolute source path "${source}". Only absolute POSIX paths are supported for sandbox binds.`
});
}
const blockedNetworkReason = getBlockedNetworkModeReason({
network: data.network,
allowContainerNamespaceJoin: data.dangerouslyAllowContainerNamespaceJoin === true
});
if (blockedNetworkReason === "host") ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["network"],
message: "Sandbox security: network mode \"host\" is blocked. Use \"bridge\" or \"none\" instead."
});
if (blockedNetworkReason === "container_namespace_join") ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["network"],
message: "Sandbox security: network mode \"container:*\" is blocked by default. Use a custom bridge network, or set dangerouslyAllowContainerNamespaceJoin=true only when you fully trust this runtime."
});
if (data.seccompProfile?.trim().toLowerCase() === "unconfined") ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["seccompProfile"],
message: "Sandbox security: seccomp profile \"unconfined\" is blocked. Use a custom seccomp profile file or omit this setting."
});
if (data.apparmorProfile?.trim().toLowerCase() === "unconfined") ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["apparmorProfile"],
message: "Sandbox security: apparmor profile \"unconfined\" is blocked. Use a named AppArmor profile or omit this setting."
});
}).optional();
const SandboxBrowserSchema = z.object({
enabled: z.boolean().optional(),
image: z.string().optional(),
containerPrefix: z.string().optional(),
network: z.string().optional(),
cdpPort: z.number().int().positive().optional(),
cdpSourceRange: z.string().optional(),
vncPort: z.number().int().positive().optional(),
noVncPort: z.number().int().positive().optional(),
headless: z.boolean().optional(),
enableNoVnc: z.boolean().optional(),
allowHostControl: z.boolean().optional(),
autoStart: z.boolean().optional(),
autoStartTimeoutMs: z.number().int().positive().optional(),
binds: z.array(z.string()).optional()
}).superRefine((data, ctx) => {
if (data.network?.trim().toLowerCase() === "host") ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["network"],
message: "Sandbox security: browser network mode \"host\" is blocked. Use \"bridge\" or a custom bridge network instead."
});
}).strict().optional();
const SandboxPruneSchema = z.object({
idleHours: z.number().int().nonnegative().optional(),
maxAgeDays: z.number().int().nonnegative().optional()
}).strict().optional();
const ToolPolicyBaseSchema = z.object({
allow: z.array(z.string()).optional(),
alsoAllow: z.array(z.string()).optional(),
deny: z.array(z.string()).optional()
}).strict();
const ToolPolicySchema = ToolPolicyBaseSchema.superRefine((value, ctx) => {
if (value.allow && value.allow.length > 0 && value.alsoAllow && value.alsoAllow.length > 0) ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "tools policy cannot set both allow and alsoAllow in the same scope (merge alsoAllow into allow, or remove allow and use profile + alsoAllow)"
});
}).optional();
const ToolsWebSearchSchema = z.object({
enabled: z.boolean().optional(),
provider: z.union([
z.literal("brave"),
z.literal("perplexity"),
z.literal("grok"),
z.literal("gemini"),
z.literal("kimi")
]).optional(),
apiKey: z.string().optional().register(sensitive),
maxResults: z.number().int().positive().optional(),
timeoutSeconds: z.number().int().positive().optional(),
cacheTtlMinutes: z.number().nonnegative().optional(),
perplexity: z.object({
apiKey: z.string().optional().register(sensitive),
baseUrl: z.string().optional(),
model: z.string().optional()
}).strict().optional(),
grok: z.object({
apiKey: z.string().optional().register(sensitive),
model: z.string().optional(),
inlineCitations: z.boolean().optional()
}).strict().optional(),
gemini: z.object({
apiKey: z.string().optional().register(sensitive),
model: z.string().optional()
}).strict().optional(),
kimi: z.object({
apiKey: z.string().optional().register(sensitive),
baseUrl: z.string().optional(),
model: z.string().optional()
}).strict().optional()
}).strict().optional();
const ToolsWebFetchSchema = z.object({
enabled: z.boolean().optional(),
maxChars: z.number().int().positive().optional(),
maxCharsCap: z.number().int().positive().optional(),
timeoutSeconds: z.number().int().positive().optional(),
cacheTtlMinutes: z.number().nonnegative().optional(),
maxRedirects: z.number().int().nonnegative().optional(),
userAgent: z.string().optional()
}).strict().optional();
const ToolsWebSchema = z.object({
search: ToolsWebSearchSchema,
fetch: ToolsWebFetchSchema
}).strict().optional();
const ToolProfileSchema = z.union([
z.literal("minimal"),
z.literal("coding"),
z.literal("messaging"),
z.literal("full")
]).optional();
function addAllowAlsoAllowConflictIssue(value, ctx, message) {
if (value.allow && value.allow.length > 0 && value.alsoAllow && value.alsoAllow.length > 0) ctx.addIssue({
code: z.ZodIssueCode.custom,
message
});
}
const ToolPolicyWithProfileSchema = z.object({
allow: z.array(z.string()).optional(),
alsoAllow: z.array(z.string()).optional(),
deny: z.array(z.string()).optional(),
profile: ToolProfileSchema
}).strict().superRefine((value, ctx) => {
addAllowAlsoAllowConflictIssue(value, ctx, "tools.byProvider policy cannot set both allow and alsoAllow in the same scope (merge alsoAllow into allow, or remove allow and use profile + alsoAllow)");
});
const ElevatedAllowFromSchema = z.record(z.string(), z.array(z.union([z.string(), z.number()]))).optional();
const ToolExecApplyPatchSchema = z.object({
enabled: z.boolean().optional(),
workspaceOnly: z.boolean().optional(),
allowModels: z.array(z.string()).optional()
}).strict().optional();
const ToolExecSafeBinProfileSchema = z.object({
minPositional: z.number().int().nonnegative().optional(),
maxPositional: z.number().int().nonnegative().optional(),
allowedValueFlags: z.array(z.string()).optional(),
deniedFlags: z.array(z.string()).optional()
}).strict();
const ToolExecBaseShape = {
host: z.enum([
"sandbox",
"gateway",
"node"
]).optional(),
security: z.enum([
"deny",
"allowlist",
"full"
]).optional(),
ask: z.enum([
"off",
"on-miss",
"always"
]).optional(),
node: z.string().optional(),
pathPrepend: z.array(z.string()).optional(),
safeBins: z.array(z.string()).optional(),
safeBinTrustedDirs: z.array(z.string()).optional(),
safeBinProfiles: z.record(z.string(), ToolExecSafeBinProfileSchema).optional(),
backgroundMs: z.number().int().positive().optional(),
timeoutSec: z.number().int().positive().optional(),
cleanupMs: z.number().int().positive().optional(),
notifyOnExit: z.boolean().optional(),
notifyOnExitEmptySuccess: z.boolean().optional(),
applyPatch: ToolExecApplyPatchSchema
};
const AgentToolExecSchema = z.object({
...ToolExecBaseShape,
approvalRunningNoticeMs: z.number().int().nonnegative().optional()
}).strict().optional();
const ToolExecSchema = z.object(ToolExecBaseShape).strict().optional();
const ToolFsSchema = z.object({ workspaceOnly: z.boolean().optional() }).strict().optional();
const ToolLoopDetectionDetectorSchema = z.object({
genericRepeat: z.boolean().optional(),
knownPollNoProgress: z.boolean().optional(),
pingPong: z.boolean().optional()
}).strict().optional();
const ToolLoopDetectionSchema = z.object({
enabled: z.boolean().optional(),
historySize: z.number().int().positive().optional(),
warningThreshold: z.number().int().positive().optional(),
criticalThreshold: z.number().int().positive().optional(),
globalCircuitBreakerThreshold: z.number().int().positive().optional(),
detectors: ToolLoopDetectionDetectorSchema
}).strict().superRefine((value, ctx) => {
if (value.warningThreshold !== void 0 && value.criticalThreshold !== void 0 && value.warningThreshold >= value.criticalThreshold) ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["criticalThreshold"],
message: "tools.loopDetection.warningThreshold must be lower than criticalThreshold."
});
if (value.criticalThreshold !== void 0 && value.globalCircuitBreakerThreshold !== void 0 && value.criticalThreshold >= value.globalCircuitBreakerThreshold) ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["globalCircuitBreakerThreshold"],
message: "tools.loopDetection.criticalThreshold must be lower than globalCircuitBreakerThreshold."
});
}).optional();
const AgentSandboxSchema = z.object({
mode: z.union([
z.literal("off"),
z.literal("non-main"),
z.literal("all")
]).optional(),
workspaceAccess: z.union([
z.literal("none"),
z.literal("ro"),
z.literal("rw")
]).optional(),
sessionToolsVisibility: z.union([z.literal("spawned"), z.literal("all")]).optional(),
scope: z.union([
z.literal("session"),
z.literal("agent"),
z.literal("shared")
]).optional(),
perSession: z.boolean().optional(),
workspaceRoot: z.string().optional(),
docker: SandboxDockerSchema,
browser: SandboxBrowserSchema,
prune: SandboxPruneSchema
}).strict().superRefine((data, ctx) => {
if (getBlockedNetworkModeReason({
network: data.browser?.network,
allowContainerNamespaceJoin: data.docker?.dangerouslyAllowContainerNamespaceJoin === true
}) === "container_namespace_join") ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["browser", "network"],
message: "Sandbox security: browser network mode \"container:*\" is blocked by default. Set sandbox.docker.dangerouslyAllowContainerNamespaceJoin=true only when you fully trust this runtime."
});
}).optional();
const CommonToolPolicyFields = {
profile: ToolProfileSchema,
allow: z.array(z.string()).optional(),
alsoAllow: z.array(z.string()).optional(),
deny: z.array(z.string()).optional(),
byProvider: z.record(z.string(), ToolPolicyWithProfileSchema).optional()
};
const AgentToolsSchema = z.object({
...CommonToolPolicyFields,
elevated: z.object({
enabled: z.boolean().optional(),
allowFrom: ElevatedAllowFromSchema
}).strict().optional(),
exec: AgentToolExecSchema,
fs: ToolFsSchema,
loopDetection: ToolLoopDetectionSchema,
sandbox: z.object({ tools: ToolPolicySchema }).strict().optional()
}).strict().superRefine((value, ctx) => {
addAllowAlsoAllowConflictIssue(value, ctx, "agent tools cannot set both allow and alsoAllow in the same scope (merge alsoAllow into allow, or remove allow and use profile + alsoAllow)");
}).optional();
const MemorySearchSchema = z.object({
enabled: z.boolean().optional(),
sources: z.array(z.union([z.literal("memory"), z.literal("sessions")])).optional(),
extraPaths: z.array(z.string()).optional(),
experimental: z.object({ sessionMemory: z.boolean().optional() }).strict().optional(),
provider: z.union([
z.literal("openai"),
z.literal("local"),
z.literal("gemini"),
z.literal("voyage"),
z.literal("mistral")
]).optional(),
remote: z.object({
baseUrl: z.string().optional(),
apiKey: z.string().optional().register(sensitive),
headers: z.record(z.string(), z.string()).optional(),
batch: z.object({
enabled: z.boolean().optional(),
wait: z.boolean().optional(),
concurrency: z.number().int().positive().optional(),
pollIntervalMs: z.number().int().nonnegative().optional(),
timeoutMinutes: z.number().int().positive().optional()
}).strict().optional()
}).strict().optional(),
fallback: z.union([
z.literal("openai"),
z.literal("gemini"),
z.literal("local"),
z.literal("voyage"),
z.literal("mistral"),
z.literal("none")
]).optional(),
model: z.string().optional(),
local: z.object({
modelPath: z.string().optional(),
modelCacheDir: z.string().optional()
}).strict().optional(),
store: z.object({
driver: z.literal("sqlite").optional(),
path: z.string().optional(),
vector: z.object({
enabled: z.boolean().optional(),
extensionPath: z.string().optional()
}).strict().optional()
}).strict().optional(),
chunking: z.object({
tokens: z.number().int().positive().optional(),
overlap: z.number().int().nonnegative().optional()
}).strict().optional(),
sync: z.object({
onSessionStart: z.boolean().optional(),
onSearch: z.boolean().optional(),
watch: z.boolean().optional(),
watchDebounceMs: z.number().int().nonnegative().optional(),
intervalMinutes: z.number().int().nonnegative().optional(),
sessions: z.object({
deltaBytes: z.number().int().nonnegative().optional(),
deltaMessages: z.number().int().nonnegative().optional()
}).strict().optional()
}).strict().optional(),
query: z.object({
maxResults: z.number().int().positive().optional(),
minScore: z.number().min(0).max(1).optional(),
hybrid: z.object({
enabled: z.boolean().optional(),
vectorWeight: z.number().min(0).max(1).optional(),
textWeight: z.number().min(0).max(1).optional(),
candidateMultiplier: z.number().int().positive().optional(),
mmr: z.object({
enabled: z.boolean().optional(),
lambda: z.number().min(0).max(1).optional()
}).strict().optional(),
temporalDecay: z.object({
enabled: z.boolean().optional(),
halfLifeDays: z.number().int().positive().optional()
}).strict().optional()
}).strict().optional()
}).strict().optional(),
cache: z.object({
enabled: z.boolean().optional(),
maxEntries: z.number().int().positive().optional()
}).strict().optional()
}).strict().optional();
const AgentEntrySchema = z.object({
id: z.string(),
default: z.boolean().optional(),
name: z.string().optional(),
workspace: z.string().optional(),
agentDir: z.string().optional(),
model: AgentModelSchema.optional(),
skills: z.array(z.string()).optional(),
memorySearch: MemorySearchSchema,
humanDelay: HumanDelaySchema.optional(),
heartbeat: HeartbeatSchema,
identity: IdentitySchema,
groupChat: GroupChatSchema,
subagents: z.object({
allowAgents: z.array(z.string()).optional(),
model: z.union([z.string(), z.object({
primary: z.string().optional(),
fallbacks: z.array(z.string()).optional()
}).strict()]).optional(),
thinking: z.string().optional()
}).strict().optional(),
sandbox: AgentSandboxSchema,
tools: AgentToolsSchema
}).strict();
const ToolsSchema = z.object({
...CommonToolPolicyFields,
web: ToolsWebSchema,
media: ToolsMediaSchema,
links: ToolsLinksSchema,
sessions: z.object({ visibility: z.enum([
"self",
"tree",
"agent",
"all"
]).optional() }).strict().optional(),
loopDetection: ToolLoopDetectionSchema,
message: z.object({
allowCrossContextSend: z.boolean().optional(),
crossContext: z.object({
allowWithinProvider: z.boolean().optional(),
allowAcrossProviders: z.boolean().optional(),
marker: z.object({
enabled: z.boolean().optional(),
prefix: z.string().optional(),
suffix: z.string().optional()
}).strict().optional()
}).strict().optional(),
broadcast: z.object({ enabled: z.boolean().optional() }).strict().optional()
}).strict().optional(),
agentToAgent: z.object({
enabled: z.boolean().optional(),
allow: z.array(z.string()).optional()
}).strict().optional(),
elevated: z.object({
enabled: z.boolean().optional(),
allowFrom: ElevatedAllowFromSchema
}).strict().optional(),
exec: ToolExecSchema,
fs: ToolFsSchema,
subagents: z.object({ tools: ToolPolicySchema }).strict().optional(),
sandbox: z.object({ tools: ToolPolicySchema }).strict().optional()
}).strict().superRefine((value, ctx) => {
addAllowAlsoAllowConflictIssue(value, ctx, "tools cannot set both allow and alsoAllow in the same scope (merge alsoAllow into allow, or remove allow and use profile + alsoAllow)");
}).optional();
//#endregion
//#region src/config/zod-schema.agent-defaults.ts
const AgentDefaultsSchema = z.object({
model: AgentModelSchema.optional(),
imageModel: AgentModelSchema.optional(),
models: z.record(z.string(), z.object({
alias: z.string().optional(),
params: z.record(z.string(), z.unknown()).optional(),
streaming: z.boolean().optional()
}).strict()).optional(),
workspace: z.string().optional(),
repoRoot: z.string().optional(),
skipBootstrap: z.boolean().optional(),
bootstrapMaxChars: z.number().int().positive().optional(),
bootstrapTotalMaxChars: z.number().int().positive().optional(),
userTimezone: z.string().optional(),
timeFormat: z.union([
z.literal("auto"),
z.literal("12"),
z.literal("24")
]).optional(),
envelopeTimezone: z.string().optional(),
envelopeTimestamp: z.union([z.literal("on"), z.literal("off")]).optional(),
envelopeElapsed: z.union([z.literal("on"), z.literal("off")]).optional(),
contextTokens: z.number().int().positive().optional(),
cliBackends: z.record(z.string(), CliBackendSchema).optional(),
memorySearch: MemorySearchSchema,
contextPruning: z.object({
mode: z.union([z.literal("off"), z.literal("cache-ttl")]).optional(),
ttl: z.string().optional(),
keepLastAssistants: z.number().int().nonnegative().optional(),
softTrimRatio: z.number().min(0).max(1).optional(),
hardClearRatio: z.number().min(0).max(1).optional(),
minPrunableToolChars: z.number().int().nonnegative().optional(),
tools: z.object({
allow: z.array(z.string()).optional(),
deny: z.array(z.string()).optional()
}).strict().optional(),
softTrim: z.object({
maxChars: z.number().int().nonnegative().optional(),
headChars: z.number().int().nonnegative().optional(),
tailChars: z.number().int().nonnegative().optional()
}).strict().optional(),
hardClear: z.object({
enabled: z.boolean().optional(),
placeholder: z.string().optional()
}).strict().optional()
}).strict().optional(),
compaction: z.object({
mode: z.union([z.literal("default"), z.literal("safeguard")]).optional(),
reserveTokens: z.number().int().nonnegative().optional(),
keepRecentTokens: z.number().int().positive().optional(),
reserveTokensFloor: z.number().int().nonnegative().optional(),
maxHistoryShare: z.number().min(.1).max(.9).optional(),
memoryFlush: z.object({
enabled: z.boolean().optional(),
softThresholdTokens: z.number().int().nonnegative().optional(),
prompt: z.string().optional(),
systemPrompt: z.string().optional()
}).strict().optional()
}).strict().optional(),
thinkingDefault: z.union([
z.literal("off"),
z.literal("minimal"),
z.literal("low"),
z.literal("medium"),
z.literal("high"),
z.literal("xhigh")
]).optional(),
verboseDefault: z.union([
z.literal("off"),
z.literal("on"),
z.literal("full")
]).optional(),
elevatedDefault: z.union([
z.literal("off"),
z.literal("on"),
z.literal("ask"),
z.literal("full")
]).optional(),
blockStreamingDefault: z.union([z.literal("off"), z.literal("on")]).optional(),
blockStreamingBreak: z.union([z.literal("text_end"), z.literal("message_end")]).optional(),
blockStreamingChunk: BlockStreamingChunkSchema.optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
humanDelay: HumanDelaySchema.optional(),
timeoutSeconds: z.number().int().positive().optional(),
mediaMaxMb: z.number().positive().optional(),
imageMaxDimensionPx: z.number().int().positive().optional(),
typingIntervalSeconds: z.number().int().positive().optional(),
typingMode: TypingModeSchema.optional(),
heartbeat: HeartbeatSchema,
maxConcurrent: z.number().int().positive().optional(),
subagents: z.object({
maxConcurrent: z.number().int().positive().optional(),
maxSpawnDepth: z.number().int().min(1).max(5).optional().describe("Maximum nesting depth for sub-agent spawning. 1 = no nesting (default), 2 = sub-agents can spawn sub-sub-agents."),
maxChildrenPerAgent: z.number().int().min(1).max(20).optional().describe("Maximum number of active children a single agent session can spawn (default: 5)."),
archiveAfterMinutes: z.number().int().positive().optional(),
model: AgentModelSchema.optional(),
thinking: z.string().optional(),
runTimeoutSeconds: z.number().int().min(0).optional(),
announceTimeoutMs: z.number().int().positive().optional()
}).strict().optional(),
sandbox: AgentSandboxSchema
}).strict().optional();
//#endregion
//#region src/config/zod-schema.agents.ts
const AgentsSchema = z.object({
defaults: z.lazy(() => AgentDefaultsSchema).optional(),
list: z.array(AgentEntrySchema).optional()
}).strict().optional();
const BindingsSchema = z.array(z.object({
agentId: z.string(),
comment: z.string().optional(),
match: z.object({
channel: z.string(),
accountId: z.string().optional(),
peer: z.object({
kind: z.union([
z.literal("direct"),
z.literal("group"),
z.literal("channel"),
z.literal("dm")
]),
id: z.string()
}).strict().optional(),
guildId: z.string().optional(),
teamId: z.string().optional(),
roles: z.array(z.string()).optional()
}).strict()
}).strict()).optional();
const BroadcastStrategySchema = z.enum(["parallel", "sequential"]);
const BroadcastSchema = z.object({ strategy: BroadcastStrategySchema.optional() }).catchall(z.array(z.string())).optional();
const AudioSchema = z.object({ transcription: TranscribeAudioSchema }).strict().optional();
//#endregion
//#region src/config/zod-schema.approvals.ts
const ExecApprovalForwardTargetSchema = z.object({
channel: z.string().min(1),
to: z.string().min(1),
accountId: z.string().optional(),
threadId: z.union([z.string(), z.number()]).optional()
}).strict();
const ExecApprovalForwardingSchema = z.object({
enabled: z.boolean().optional(),
mode: z.union([
z.literal("session"),
z.literal("targets"),
z.literal("both")
]).optional(),
agentFilter: z.array(z.string()).optional(),
sessionFilter: z.array(z.string()).optional(),
targets: z.array(ExecApprovalForwardTargetSchema).optional()
}).strict().optional();
const ApprovalsSchema = z.object({ exec: ExecApprovalForwardingSchema }).strict().optional();
//#endregion
//#region src/config/zod-schema.installs.ts
const InstallSourceSchema = z.union([
z.literal("npm"),
z.literal("archive"),
z.literal("path")
]);
const InstallRecordShape = {
source: InstallSourceSchema,
spec: z.string().optional(),
sourcePath: z.string().optional(),
installPath: z.string().optional(),
version: z.string().optional(),
resolvedName: z.string().optional(),
resolvedVersion: z.string().optional(),
resolvedSpec: z.string().optional(),
integrity: z.string().optional(),
shasum: z.string().optional(),
resolvedAt: z.string().optional(),
installedAt: z.string().optional()
};
//#endregion
//#region src/config/zod-schema.hooks.ts
function isSafeRelativeModulePath(raw) {
const value = raw.trim();
if (!value) return false;
if (path.isAbsolute(value)) return false;
if (value.startsWith("~")) return false;
if (value.includes(":")) return false;
if (value.split(/[\\/]+/g).some((part) => part === "..")) return false;
return true;
}
const SafeRelativeModulePathSchema = z.string().refine(isSafeRelativeModulePath, "module must be a safe relative path (no absolute paths)");
const HookMappingSchema = z.object({
id: z.string().optional(),
match: z.object({
path: z.string().optional(),
source: z.string().optional()
}).optional(),
action: z.union([z.literal("wake"), z.literal("agent")]).optional(),
wakeMode: z.union([z.literal("now"), z.literal("next-heartbeat")]).optional(),
name: z.string().optional(),
agentId: z.string().optional(),
sessionKey: z.string().optional().register(sensitive),
messageTemplate: z.string().optional(),
textTemplate: z.string().optional(),
deliver: z.boolean().optional(),
allowUnsafeExternalContent: z.boolean().optional(),
channel: z.union([
z.literal("last"),
z.literal("whatsapp"),
z.literal("telegram"),
z.literal("discord"),
z.literal("irc"),
z.literal("slack"),
z.literal("signal"),
z.literal("imessage"),
z.literal("msteams")
]).optional(),
to: z.string().optional(),
model: z.string().optional(),
thinking: z.string().optional(),
timeoutSeconds: z.number().int().positive().optional(),
transform: z.object({
module: SafeRelativeModulePathSchema,
export: z.string().optional()
}).strict().optional()
}).strict().optional();
const InternalHookHandlerSchema = z.object({
event: z.string(),
module: SafeRelativeModulePathSchema,
export: z.string().optional()
}).strict();
const HookConfigSchema = z.object({
enabled: z.boolean().optional(),
env: z.record(z.string(), z.string()).optional()
}).passthrough();
const HookInstallRecordSchema = z.object({
...InstallRecordShape,
hooks: z.array(z.string()).optional()
}).strict();
const InternalHooksSchema = z.object({
enabled: z.boolean().optional(),
handlers: z.array(InternalHookHandlerSchema).optional(),
entries: z.record(z.string(), HookConfigSchema).optional(),
load: z.object({ extraDirs: z.array(z.string()).optional() }).strict().optional(),
installs: z.record(z.string(), HookInstallRecordSchema).optional()
}).strict().optional();
const HooksGmailSchema = z.object({
account: z.string().optional(),
label: z.string().optional(),
topic: z.string().optional(),
subscription: z.string().optional(),
pushToken: z.string().optional().register(sensitive),
hookUrl: z.string().optional(),
includeBody: z.boolean().optional(),
maxBytes: z.number().int().positive().optional(),
renewEveryMinutes: z.number().int().positive().optional(),
allowUnsafeExternalContent: z.boolean().optional(),
serve: z.object({
bind: z.string().optional(),
port: z.number().int().positive().optional(),
path: z.string().optional()
}).strict().optional(),
tailscale: z.object({
mode: z.union([
z.literal("off"),
z.literal("serve"),
z.literal("funnel")
]).optional(),
path: z.string().optional(),
target: z.string().optional()
}).strict().optional(),
model: z.string().optional(),
thinking: z.union([
z.literal("off"),
z.literal("minimal"),
z.literal("low"),
z.literal("medium"),
z.literal("high")
]).optional()
}).strict().optional();
//#endregion
//#region src/config/zod-schema.channels.ts
const ChannelHeartbeatVisibilitySchema = z.object({
showOk: z.boolean().optional(),
showAlerts: z.boolean().optional(),
useIndicator: z.boolean().optional()
}).strict().optional();
//#endregion
//#region src/infra/scp-host.ts
const SSH_TOKEN = /^[A-Za-z0-9._-]+$/;
const BRACKETED_IPV6 = /^\[[0-9A-Fa-f:.%]+\]$/;
const WHITESPACE = /\s/;
function hasControlOrWhitespace(value) {
for (const char of value) {
const code = char.charCodeAt(0);
if (code <= 31 || code === 127 || WHITESPACE.test(char)) return true;
}
return false;
}
function normalizeScpRemoteHost(value) {
if (typeof value !== "string") return;
const trimmed = value.trim();
if (!trimmed) return;
if (hasControlOrWhitespace(trimmed)) return;
if (trimmed.startsWith("-") || trimmed.includes("/") || trimmed.includes("\\")) return;
const firstAt = trimmed.indexOf("@");
const lastAt = trimmed.lastIndexOf("@");
let user;
let host = trimmed;
if (firstAt !== -1) {
if (firstAt !== lastAt || firstAt === 0 || firstAt === trimmed.length - 1) return;
user = trimmed.slice(0, firstAt);
host = trimmed.slice(firstAt + 1);
if (!SSH_TOKEN.test(user)) return;
}
if (!host || host.startsWith("-") || host.includes("@")) return;
if (host.includes(":") && !BRACKETED_IPV6.test(host)) return;
if (!SSH_TOKEN.test(host) && !BRACKETED_IPV6.test(host)) return;
return user ? `${user}@${host}` : host;
}
function isSafeScpRemoteHost(value) {
return normalizeScpRemoteHost(value) !== void 0;
}
//#endregion
//#region src/media/inbound-path-policy.ts
const WILDCARD_SEGMENT = "*";
const WINDOWS_DRIVE_ABS_RE = /^[A-Za-z]:\//;
const WINDOWS_DRIVE_ROOT_RE = /^[A-Za-z]:$/;
const DEFAULT_IMESSAGE_ATTACHMENT_ROOTS = ["/Users/*/Library/Messages/Attachments"];
function normalizePosixAbsolutePath(value) {
const trimmed = value.trim();
if (!trimmed || trimmed.includes("\0")) return;
const normalized = path.posix.normalize(trimmed.replaceAll("\\", "/"));
if (!(normalized.startsWith("/") || WINDOWS_DRIVE_ABS_RE.test(normalized)) || normalized === "/") return;
const withoutTrailingSlash = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
if (WINDOWS_DRIVE_ROOT_RE.test(withoutTrailingSlash)) return;
return withoutTrailingSlash;
}
function splitPathSegments(value) {
return value.split("/").filter(Boolean);
}
function matchesRootPattern(params) {
const candidateSegments = splitPathSegments(params.candidatePath);
const rootSegments = splitPathSegments(params.rootPattern);
if (candidateSegments.length < rootSegments.length) return false;
for (let idx = 0; idx < rootSegments.length; idx += 1) {
const expected = rootSegments[idx];
const actual = candidateSegments[idx];
if (expected === WILDCARD_SEGMENT) continue;
if (expected !== actual) return false;
}
return true;
}
function isValidInboundPathRootPattern(value) {
const normalized = normalizePosixAbsolutePath(value);
if (!normalized) return false;
const segments = splitPathSegments(normalized);
if (segments.length === 0) return false;
return segments.every((segment) => segment === WILDCARD_SEGMENT || !segment.includes("*"));
}
function normalizeInboundPathRoots(roots) {
const normalized = [];
const seen = /* @__PURE__ */ new Set();
for (const root of roots ?? []) {
if (typeof root !== "string") continue;
if (!isValidInboundPathRootPattern(root)) continue;
const candidate = normalizePosixAbsolutePath(root);
if (!candidate || seen.has(candidate)) continue;
seen.add(candidate);
normalized.push(candidate);
}
return normalized;
}
function mergeInboundPathRoots(...rootsLists) {
const merged = [];
const seen = /* @__PURE__ */ new Set();
for (const roots of rootsLists) {
const normalized = normalizeInboundPathRoots(roots);
for (const root of normalized) {
if (seen.has(root)) continue;
seen.add(root);
merged.push(root);
}
}
return merged;
}
function isInboundPathAllowed(params) {
const candidatePath = normalizePosixAbsolutePath(params.filePath);
if (!candidatePath) return false;
const roots = normalizeInboundPathRoots(params.roots);
const effectiveRoots = roots.length > 0 ? roots : normalizeInboundPathRoots(params.fallbackRoots ?? void 0);
if (effectiveRoots.length === 0) return false;
return effectiveRoots.some((rootPattern) => matchesRootPattern({
candidatePath,
rootPattern
}));
}
function resolveIMessageAccountConfig(params) {
const accountId = params.accountId?.trim();
if (!accountId) return;
return params.cfg.channels?.imessage?.accounts?.[accountId];
}
function resolveIMessageAttachmentRoots(params) {
return mergeInboundPathRoots(resolveIMessageAccountConfig(params)?.attachmentRoots, params.cfg.channels?.imessage?.attachmentRoots, DEFAULT_IMESSAGE_ATTACHMENT_ROOTS);
}
function resolveIMessageRemoteAttachmentRoots(params) {
const accountConfig = resolveIMessageAccountConfig(params);
return mergeInboundPathRoots(accountConfig?.remoteAttachmentRoots, params.cfg.channels?.imessage?.remoteAttachmentRoots, accountConfig?.attachmentRoots, params.cfg.channels?.imessage?.attachmentRoots, DEFAULT_IMESSAGE_ATTACHMENT_ROOTS);
}
//#endregion
//#region src/config/telegram-custom-commands.ts
const TELEGRAM_COMMAND_NAME_PATTERN = /^[a-z0-9_]{1,32}$/;
function normalizeTelegramCommandName(value) {
const trimmed = value.trim();
if (!trimmed) return "";
return (trimmed.startsWith("/") ? trimmed.slice(1) : trimmed).trim().toLowerCase().replace(/-/g, "_");
}
function normalizeTelegramCommandDescription(value) {
return value.trim();
}
function resolveTelegramCustomCommands(params) {
const entries = Array.isArray(params.commands) ? params.commands : [];
const reserved = params.reservedCommands ?? /* @__PURE__ */ new Set();
const checkReserved = params.checkReserved !== false;
const checkDuplicates = params.checkDuplicates !== false;
const seen = /* @__PURE__ */ new Set();
const resolved = [];
const issues = [];
for (let index = 0; index < entries.length; index += 1) {
const entry = entries[index];
const normalized = normalizeTelegramCommandName(String(entry?.command ?? ""));
if (!normalized) {
issues.push({
index,
field: "command",
message: "Telegram custom command is missing a command name."
});
continue;
}
if (!TELEGRAM_COMMAND_NAME_PATTERN.test(normalized)) {
issues.push({
index,
field: "command",
message: `Telegram custom command "/${normalized}" is invalid (use a-z, 0-9, underscore; max 32 chars).`
});
continue;
}
if (checkReserved && reserved.has(normalized)) {
issues.push({
index,
field: "command",
message: `Telegram custom command "/${normalized}" conflicts with a native command.`
});
continue;
}
if (checkDuplicates && seen.has(normalized)) {
issues.push({
index,
field: "command",
message: `Telegram custom command "/${normalized}" is duplicated.`
});
continue;
}
const description = normalizeTelegramCommandDescription(String(entry?.description ?? ""));
if (!description) {
issues.push({
index,
field: "description",
message: `Telegram custom command "/${normalized}" is missing a description.`
});
continue;
}
if (checkDuplicates) seen.add(normalized);
resolved.push({
command: normalized,
description
});
}
return {
commands: resolved,
issues
};
}
//#endregion
//#region src/config/zod-schema.providers-core.ts
const ToolPolicyBySenderSchema$1 = z.record(z.string(), ToolPolicySchema).optional();
const DiscordIdSchema = z.union([z.string(), z.number()]).refine((value) => typeof value === "string", { message: "Discord IDs must be strings (wrap numeric IDs in quotes)." });
const DiscordIdListSchema = z.array(DiscordIdSchema);
const TelegramInlineButtonsScopeSchema = z.enum([
"off",
"dm",
"group",
"all",
"allowlist"
]);
const TelegramCapabilitiesSchema = z.union([z.array(z.string()), z.object({ inlineButtons: TelegramInlineButtonsScopeSchema.optional() }).strict()]);
const TelegramTopicSchema = z.object({
requireMention: z.boolean().optional(),
groupPolicy: GroupPolicySchema.optional(),
skills: z.array(z.string()).optional(),
enabled: z.boolean().optional(),
allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
systemPrompt: z.string().optional()
}).strict();
const TelegramGroupSchema = z.object({
requireMention: z.boolean().optional(),
groupPolicy: GroupPolicySchema.optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema$1,
skills: z.array(z.string()).optional(),
enabled: z.boolean().optional(),
allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
systemPrompt: z.string().optional(),
topics: z.record(z.string(), TelegramTopicSchema.optional()).optional()
}).strict();
const TelegramCustomCommandSchema = z.object({
command: z.string().transform(normalizeTelegramCommandName),
description: z.string().transform(normalizeTelegramCommandDescription)
}).strict();
const validateTelegramCustomCommands = (value, ctx) => {
if (!value.customCommands || value.customCommands.length === 0) return;
const { issues } = resolveTelegramCustomCommands({
commands: value.customCommands,
checkReserved: false,
checkDuplicates: false
});
for (const issue of issues) ctx.addIssue({
code: z.ZodIssueCode.custom,
path: [
"customCommands",
issue.index,
issue.field
],
message: issue.message
});
};
function normalizeTelegramStreamingConfig(value) {
value.streaming = resolveTelegramPreviewStreamMode(value);
delete value.streamMode;
}
function normalizeDiscordStreamingConfig(value) {
value.streaming = resolveDiscordPreviewStreamMode(value);
delete value.streamMode;
}
function normalizeSlackStreamingConfig(value) {
value.nativeStreaming = resolveSlackNativeStreaming(value);
value.streaming = resolveSlackStreamingMode(value);
delete value.streamMode;
}
const TelegramAccountSchemaBase = z.object({
name: z.string().optional(),
capabilities: TelegramCapabilitiesSchema.optional(),
markdown: MarkdownConfigSchema,
enabled: z.boolean().optional(),
commands: ProviderCommandsSchema,
customCommands: z.array(TelegramCustomCommandSchema).optional(),
configWrites: z.boolean().optional(),
dmPolicy: DmPolicySchema.optional().default("pairing"),
botToken: z.string().optional().register(sensitive),
tokenFile: z.string().optional(),
replyToMode: ReplyToModeSchema.optional(),
groups: z.record(z.string(), TelegramGroupSchema.optional()).optional(),
allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
defaultTo: z.union([z.string(), z.number()]).optional(),
groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
streaming: z.union([z.boolean(), z.enum([
"off",
"partial",
"block",
"progress"
])]).optional(),
blockStreaming: z.boolean().optional(),
draftChunk: BlockStreamingChunkSchema.optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
streamMode: z.enum([
"off",
"partial",
"block"
]).optional(),
mediaMaxMb: z.number().positive().optional(),
timeoutSeconds: z.number().int().positive().optional(),
retry: RetryConfigSchema,
network: z.object({
autoSelectFamily: z.boolean().optional(),
dnsResultOrder: z.enum(["ipv4first", "verbatim"]).optional()
}).strict().optional(),
proxy: z.string().optional(),
webhookUrl: z.string().optional(),
webhookSecret: z.string().optional().register(sensitive),
webhookPath: z.string().optional(),
webhookHost: z.string().optional(),
webhookPort: z.number().int().positive().optional(),
actions: z.object({
reactions: z.boolean().optional(),
sendMessage: z.boolean().optional(),
deleteMessage: z.boolean().optional(),
sticker: z.boolean().optional()
}).strict().optional(),
reactionNotifications: z.enum([
"off",
"own",
"all"
]).optional(),
reactionLevel: z.enum([
"off",
"ack",
"minimal",
"extensive"
]).optional(),
heartbeat: ChannelHeartbeatVisibilitySchema,
linkPreview: z.boolean().optional(),
responsePrefix: z.string().optional(),
ackReaction: z.string().optional()
}).strict();
const TelegramAccountSchema = TelegramAccountSchemaBase.superRefine((value, ctx) => {
normalizeTelegramStreamingConfig(value);
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.telegram.dmPolicy=\"open\" requires channels.telegram.allowFrom to include \"*\""
});
validateTelegramCustomCommands(value, ctx);
});
const TelegramConfigSchema = TelegramAccountSchemaBase.extend({ accounts: z.record(z.string(), TelegramAccountSchema.optional()).optional() }).superRefine((value, ctx) => {
normalizeTelegramStreamingConfig(value);
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.telegram.dmPolicy=\"open\" requires channels.telegram.allowFrom to include \"*\""
});
validateTelegramCustomCommands(value, ctx);
const baseWebhookUrl = typeof value.webhookUrl === "string" ? value.webhookUrl.trim() : "";
const baseWebhookSecret = typeof value.webhookSecret === "string" ? value.webhookSecret.trim() : "";
if (baseWebhookUrl && !baseWebhookSecret) ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "channels.telegram.webhookUrl requires channels.telegram.webhookSecret",
path: ["webhookSecret"]
});
if (!value.accounts) return;
for (const [accountId, account] of Object.entries(value.accounts)) {
if (!account) continue;
if (account.enabled === false) continue;
if (!(typeof account.webhookUrl === "string" ? account.webhookUrl.trim() : "")) continue;
if (!(typeof account.webhookSecret === "string" ? account.webhookSecret.trim() : "") && !baseWebhookSecret) ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "channels.telegram.accounts.*.webhookUrl requires channels.telegram.webhookSecret or channels.telegram.accounts.*.webhookSecret",
path: [
"accounts",
accountId,
"webhookSecret"
]
});
}
});
const DiscordDmSchema = z.object({
enabled: z.boolean().optional(),
policy: DmPolicySchema.optional(),
allowFrom: DiscordIdListSchema.optional(),
groupEnabled: z.boolean().optional(),
groupChannels: DiscordIdListSchema.optional()
}).strict();
const DiscordGuildChannelSchema = z.object({
allow: z.boolean().optional(),
requireMention: z.boolean().optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema$1,
skills: z.array(z.string()).optional(),
enabled: z.boolean().optional(),
users: DiscordIdListSchema.optional(),
roles: DiscordIdListSchema.optional(),
systemPrompt: z.string().optional(),
includeThreadStarter: z.boolean().optional(),
autoThread: z.boolean().optional()
}).strict();
const DiscordGuildSchema = z.object({
slug: z.string().optional(),
requireMention: z.boolean().optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema$1,
reactionNotifications: z.enum([
"off",
"own",
"all",
"allowlist"
]).optional(),
users: DiscordIdListSchema.optional(),
roles: DiscordIdListSchema.optional(),
channels: z.record(z.string(), DiscordGuildChannelSchema.optional()).optional()
}).strict();
const DiscordUiSchema = z.object({ components: z.object({ accentColor: HexColorSchema.optional() }).strict().optional() }).strict().optional();
const DiscordVoiceAutoJoinSchema = z.object({
guildId: z.string().min(1),
channelId: z.string().min(1)
}).strict();
const DiscordVoiceSchema = z.object({
enabled: z.boolean().optional(),
autoJoin: z.array(DiscordVoiceAutoJoinSchema).optional(),
daveEncryption: z.boolean().optional(),
decryptionFailureTolerance: z.number().int().min(0).optional(),
tts: TtsConfigSchema.optional()
}).strict().optional();
const DiscordAccountSchema = z.object({
name: z.string().optional(),
capabilities: z.array(z.string()).optional(),
markdown: MarkdownConfigSchema,
enabled: z.boolean().optional(),
commands: ProviderCommandsSchema,
configWrites: z.boolean().optional(),
token: z.string().optional().register(sensitive),
proxy: z.string().optional(),
allowBots: z.boolean().optional(),
dangerouslyAllowNameMatching: z.boolean().optional(),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
blockStreaming: z.boolean().optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
streaming: z.union([z.boolean(), z.enum([
"off",
"partial",
"block",
"progress"
])]).optional(),
streamMode: z.enum([
"partial",
"block",
"off"
]).optional(),
draftChunk: BlockStreamingChunkSchema.optional(),
maxLinesPerMessage: z.number().int().positive().optional(),
mediaMaxMb: z.number().positive().optional(),
retry: RetryConfigSchema,
actions: z.object({
reactions: z.boolean().optional(),
stickers: z.boolean().optional(),
emojiUploads: z.boolean().optional(),
stickerUploads: z.boolean().optional(),
polls: z.boolean().optional(),
permissions: z.boolean().optional(),
messages: z.boolean().optional(),
threads: z.boolean().optional(),
pins: z.boolean().optional(),
search: z.boolean().optional(),
memberInfo: z.boolean().optional(),
roleInfo: z.boolean().optional(),
roles: z.boolean().optional(),
channelInfo: z.boolean().optional(),
voiceStatus: z.boolean().optional(),
events: z.boolean().optional(),
moderation: z.boolean().optional(),
channels: z.boolean().optional(),
presence: z.boolean().optional()
}).strict().optional(),
replyToMode: ReplyToModeSchema.optional(),
dmPolicy: DmPolicySchema.optional(),
allowFrom: DiscordIdListSchema.optional(),
defaultTo: z.string().optional(),
dm: DiscordDmSchema.optional(),
guilds: z.record(z.string(), DiscordGuildSchema.optional()).optional(),
heartbeat: ChannelHeartbeatVisibilitySchema,
execApprovals: z.object({
enabled: z.boolean().optional(),
approvers: DiscordIdListSchema.optional(),
agentFilter: z.array(z.string()).optional(),
sessionFilter: z.array(z.string()).optional(),
cleanupAfterResolve: z.boolean().optional(),
target: z.enum([
"dm",
"channel",
"both"
]).optional()
}).strict().optional(),
ui: DiscordUiSchema,
slashCommand: z.object({ ephemeral: z.boolean().optional() }).strict().optional(),
threadBindings: z.object({
enabled: z.boolean().optional(),
ttlHours: z.number().nonnegative().optional(),
spawnSubagentSessions: z.boolean().optional()
}).strict().optional(),
intents: z.object({
presence: z.boolean().optional(),
guildMembers: z.boolean().optional()
}).strict().optional(),
voice: DiscordVoiceSchema,
pluralkit: z.object({
enabled: z.boolean().optional(),
token: z.string().optional().register(sensitive)
}).strict().optional(),
responsePrefix: z.string().optional(),
ackReaction: z.string().optional(),
activity: z.string().optional(),
status: z.enum([
"online",
"dnd",
"idle",
"invisible"
]).optional(),
activityType: z.union([
z.literal(0),
z.literal(1),
z.literal(2),
z.literal(3),
z.literal(4),
z.literal(5)
]).optional(),
activityUrl: z.string().url().optional()
}).strict().superRefine((value, ctx) => {
normalizeDiscordStreamingConfig(value);
const activityText = typeof value.activity === "string" ? value.activity.trim() : "";
const hasActivity = Boolean(activityText);
const hasActivityType = value.activityType !== void 0;
const activityUrl = typeof value.activityUrl === "string" ? value.activityUrl.trim() : "";
const hasActivityUrl = Boolean(activityUrl);
if ((hasActivityType || hasActivityUrl) && !hasActivity) ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "channels.discord.activity is required when activityType or activityUrl is set",
path: ["activity"]
});
if (value.activityType === 1 && !hasActivityUrl) ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "channels.discord.activityUrl is required when activityType is 1 (Streaming)",
path: ["activityUrl"]
});
if (hasActivityUrl && value.activityType !== 1) ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "channels.discord.activityType must be 1 (Streaming) when activityUrl is set",
path: ["activityType"]
});
requireOpenAllowFrom({
policy: value.dmPolicy ?? value.dm?.policy ?? "pairing",
allowFrom: value.allowFrom ?? value.dm?.allowFrom,
ctx,
path: [...value.allowFrom !== void 0 ? ["allowFrom"] : ["dm", "allowFrom"]],
message: "channels.discord.dmPolicy=\"open\" requires channels.discord.allowFrom (or channels.discord.dm.allowFrom) to include \"*\""
});
});
const DiscordConfigSchema = DiscordAccountSchema.extend({ accounts: z.record(z.string(), DiscordAccountSchema.optional()).optional() });
const GoogleChatDmSchema = z.object({
enabled: z.boolean().optional(),
policy: DmPolicySchema.optional().default("pairing"),
allowFrom: z.array(z.union([z.string(), z.number()])).optional()
}).strict().superRefine((value, ctx) => {
requireOpenAllowFrom({
policy: value.policy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.googlechat.dm.policy=\"open\" requires channels.googlechat.dm.allowFrom to include \"*\""
});
});
const GoogleChatGroupSchema = z.object({
enabled: z.boolean().optional(),
allow: z.boolean().optional(),
requireMention: z.boolean().optional(),
users: z.array(z.union([z.string(), z.number()])).optional(),
systemPrompt: z.string().optional()
}).strict();
const GoogleChatAccountSchema = z.object({
name: z.string().optional(),
capabilities: z.array(z.string()).optional(),
enabled: z.boolean().optional(),
configWrites: z.boolean().optional(),
allowBots: z.boolean().optional(),
dangerouslyAllowNameMatching: z.boolean().optional(),
requireMention: z.boolean().optional(),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
groups: z.record(z.string(), GoogleChatGroupSchema.optional()).optional(),
defaultTo: z.string().optional(),
serviceAccount: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
serviceAccountFile: z.string().optional(),
audienceType: z.enum(["app-url", "project-number"]).optional(),
audience: z.string().optional(),
webhookPath: z.string().optional(),
webhookUrl: z.string().optional(),
botUser: z.string().optional(),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
blockStreaming: z.boolean().optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
streamMode: z.enum([
"replace",
"status_final",
"append"
]).optional().default("replace"),
mediaMaxMb: z.number().positive().optional(),
replyToMode: ReplyToModeSchema.optional(),
actions: z.object({ reactions: z.boolean().optional() }).strict().optional(),
dm: GoogleChatDmSchema.optional(),
typingIndicator: z.enum([
"none",
"message",
"reaction"
]).optional(),
responsePrefix: z.string().optional()
}).strict();
const GoogleChatConfigSchema = GoogleChatAccountSchema.extend({
accounts: z.record(z.string(), GoogleChatAccountSchema.optional()).optional(),
defaultAccount: z.string().optional()
});
const SlackDmSchema = z.object({
enabled: z.boolean().optional(),
policy: DmPolicySchema.optional(),
allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
groupEnabled: z.boolean().optional(),
groupChannels: z.array(z.union([z.string(), z.number()])).optional(),
replyToMode: ReplyToModeSchema.optional()
}).strict();
const SlackChannelSchema = z.object({
enabled: z.boolean().optional(),
allow: z.boolean().optional(),
requireMention: z.boolean().optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema$1,
allowBots: z.boolean().optional(),
users: z.array(z.union([z.string(), z.number()])).optional(),
skills: z.array(z.string()).optional(),
systemPrompt: z.string().optional()
}).strict();
const SlackThreadSchema = z.object({
historyScope: z.enum(["thread", "channel"]).optional(),
inheritParent: z.boolean().optional(),
initialHistoryLimit: z.number().int().min(0).optional()
}).strict();
const SlackReplyToModeByChatTypeSchema = z.object({
direct: ReplyToModeSchema.optional(),
group: ReplyToModeSchema.optional(),
channel: ReplyToModeSchema.optional()
}).strict();
const SlackAccountSchema = z.object({
name: z.string().optional(),
mode: z.enum(["socket", "http"]).optional(),
signingSecret: z.string().optional().register(sensitive),
webhookPath: z.string().optional(),
capabilities: z.array(z.string()).optional(),
markdown: MarkdownConfigSchema,
enabled: z.boolean().optional(),
commands: ProviderCommandsSchema,
configWrites: z.boolean().optional(),
botToken: z.string().optional().register(sensitive),
appToken: z.string().optional().register(sensitive),
userToken: z.string().optional().register(sensitive),
userTokenReadOnly: z.boolean().optional().default(true),
allowBots: z.boolean().optional(),
dangerouslyAllowNameMatching: z.boolean().optional(),
requireMention: z.boolean().optional(),
groupPolicy: GroupPolicySchema.optional(),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
blockStreaming: z.boolean().optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
streaming: z.union([z.boolean(), z.enum([
"off",
"partial",
"block",
"progress"
])]).optional(),
nativeStreaming: z.boolean().optional(),
streamMode: z.enum([
"replace",
"status_final",
"append"
]).optional(),
mediaMaxMb: z.number().positive().optional(),
reactionNotifications: z.enum([
"off",
"own",
"all",
"allowlist"
]).optional(),
reactionAllowlist: z.array(z.union([z.string(), z.number()])).optional(),
replyToMode: ReplyToModeSchema.optional(),
replyToModeByChatType: SlackReplyToModeByChatTypeSchema.optional(),
thread: SlackThreadSchema.optional(),
actions: z.object({
reactions: z.boolean().optional(),
messages: z.boolean().optional(),
pins: z.boolean().optional(),
search: z.boolean().optional(),
permissions: z.boolean().optional(),
memberInfo: z.boolean().optional(),
channelInfo: z.boolean().optional(),
emojiList: z.boolean().optional()
}).strict().optional(),
slashCommand: z.object({
enabled: z.boolean().optional(),
name: z.string().optional(),
sessionPrefix: z.string().optional(),
ephemeral: z.boolean().optional()
}).strict().optional(),
dmPolicy: DmPolicySchema.optional(),
allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
defaultTo: z.string().optional(),
dm: SlackDmSchema.optional(),
channels: z.record(z.string(), SlackChannelSchema.optional()).optional(),
heartbeat: ChannelHeartbeatVisibilitySchema,
responsePrefix: z.string().optional(),
ackReaction: z.string().optional()
}).strict().superRefine((value, ctx) => {
normalizeSlackStreamingConfig(value);
requireOpenAllowFrom({
policy: value.dmPolicy ?? value.dm?.policy ?? "pairing",
allowFrom: value.allowFrom ?? value.dm?.allowFrom,
ctx,
path: [...value.allowFrom !== void 0 ? ["allowFrom"] : ["dm", "allowFrom"]],
message: "channels.slack.dmPolicy=\"open\" requires channels.slack.allowFrom (or channels.slack.dm.allowFrom) to include \"*\""
});
});
const SlackConfigSchema = SlackAccountSchema.safeExtend({
mode: z.enum(["socket", "http"]).optional().default("socket"),
signingSecret: z.string().optional().register(sensitive),
webhookPath: z.string().optional().default("/slack/events"),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
accounts: z.record(z.string(), SlackAccountSchema.optional()).optional()
}).superRefine((value, ctx) => {
const baseMode = value.mode ?? "socket";
if (baseMode === "http" && !value.signingSecret) ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "channels.slack.mode=\"http\" requires channels.slack.signingSecret",
path: ["signingSecret"]
});
if (!value.accounts) return;
for (const [accountId, account] of Object.entries(value.accounts)) {
if (!account) continue;
if (account.enabled === false) continue;
if ((account.mode ?? baseMode) !== "http") continue;
if (!(account.signingSecret ?? value.signingSecret)) ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "channels.slack.accounts.*.mode=\"http\" requires channels.slack.signingSecret or channels.slack.accounts.*.signingSecret",
path: [
"accounts",
accountId,
"signingSecret"
]
});
}
});
const SignalAccountSchemaBase = z.object({
name: z.string().optional(),
capabilities: z.array(z.string()).optional(),
markdown: MarkdownConfigSchema,
enabled: z.boolean().optional(),
configWrites: z.boolean().optional(),
account: z.string().optional(),
httpUrl: z.string().optional(),
httpHost: z.string().optional(),
httpPort: z.number().int().positive().optional(),
cliPath: ExecutableTokenSchema.optional(),
autoStart: z.boolean().optional(),
startupTimeoutMs: z.number().int().min(1e3).max(12e4).optional(),
receiveMode: z.union([z.literal("on-start"), z.literal("manual")]).optional(),
ignoreAttachments: z.boolean().optional(),
ignoreStories: z.boolean().optional(),
sendReadReceipts: z.boolean().optional(),
dmPolicy: DmPolicySchema.optional().default("pairing"),
allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
defaultTo: z.string().optional(),
groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
blockStreaming: z.boolean().optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
mediaMaxMb: z.number().int().positive().optional(),
reactionNotifications: z.enum([
"off",
"own",
"all",
"allowlist"
]).optional(),
reactionAllowlist: z.array(z.union([z.string(), z.number()])).optional(),
actions: z.object({ reactions: z.boolean().optional() }).strict().optional(),
reactionLevel: z.enum([
"off",
"ack",
"minimal",
"extensive"
]).optional(),
heartbeat: ChannelHeartbeatVisibilitySchema,
responsePrefix: z.string().optional()
}).strict();
const SignalAccountSchema = SignalAccountSchemaBase.superRefine((value, ctx) => {
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.signal.dmPolicy=\"open\" requires channels.signal.allowFrom to include \"*\""
});
});
const SignalConfigSchema = SignalAccountSchemaBase.extend({ accounts: z.record(z.string(), SignalAccountSchema.optional()).optional() }).superRefine((value, ctx) => {
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.signal.dmPolicy=\"open\" requires channels.signal.allowFrom to include \"*\""
});
});
const IrcGroupSchema = z.object({
requireMention: z.boolean().optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema$1,
skills: z.array(z.string()).optional(),
enabled: z.boolean().optional(),
allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
systemPrompt: z.string().optional()
}).strict();
const IrcNickServSchema = z.object({
enabled: z.boolean().optional(),
service: z.string().optional(),
password: z.string().optional().register(sensitive),
passwordFile: z.string().optional(),
register: z.boolean().optional(),
registerEmail: z.string().optional()
}).strict();
const IrcAccountSchemaBase = z.object({
name: z.string().optional(),
capabilities: z.array(z.string()).optional(),
markdown: MarkdownConfigSchema,
enabled: z.boolean().optional(),
configWrites: z.boolean().optional(),
host: z.string().optional(),
port: z.number().int().min(1).max(65535).optional(),
tls: z.boolean().optional(),
nick: z.string().optional(),
username: z.string().optional(),
realname: z.string().optional(),
password: z.string().optional().register(sensitive),
passwordFile: z.string().optional(),
nickserv: IrcNickServSchema.optional(),
channels: z.array(z.string()).optional(),
dmPolicy: DmPolicySchema.optional().default("pairing"),
allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
defaultTo: z.string().optional(),
groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
groups: z.record(z.string(), IrcGroupSchema.optional()).optional(),
mentionPatterns: z.array(z.string()).optional(),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
blockStreaming: z.boolean().optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
mediaMaxMb: z.number().positive().optional(),
heartbeat: ChannelHeartbeatVisibilitySchema,
responsePrefix: z.string().optional()
}).strict();
function refineIrcAllowFromAndNickserv(value, ctx) {
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.irc.dmPolicy=\"open\" requires channels.irc.allowFrom to include \"*\""
});
if (value.nickserv?.register && !value.nickserv.registerEmail?.trim()) ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["nickserv", "registerEmail"],
message: "channels.irc.nickserv.register=true requires channels.irc.nickserv.registerEmail"
});
}
const IrcAccountSchema = IrcAccountSchemaBase.superRefine((value, ctx) => {
refineIrcAllowFromAndNickserv(value, ctx);
});
const IrcConfigSchema = IrcAccountSchemaBase.extend({ accounts: z.record(z.string(), IrcAccountSchema.optional()).optional() }).superRefine((value, ctx) => {
refineIrcAllowFromAndNickserv(value, ctx);
});
const IMessageAccountSchemaBase = z.object({
name: z.string().optional(),
capabilities: z.array(z.string()).optional(),
markdown: MarkdownConfigSchema,
enabled: z.boolean().optional(),
configWrites: z.boolean().optional(),
cliPath: ExecutableTokenSchema.optional(),
dbPath: z.string().optional(),
remoteHost: z.string().refine(isSafeScpRemoteHost, "expected SSH host or user@host (no spaces/options)").optional(),
service: z.union([
z.literal("imessage"),
z.literal("sms"),
z.literal("auto")
]).optional(),
region: z.string().optional(),
dmPolicy: DmPolicySchema.optional().default("pairing"),
allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
defaultTo: z.string().optional(),
groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
includeAttachments: z.boolean().optional(),
attachmentRoots: z.array(z.string().refine(isValidInboundPathRootPattern, "expected absolute path root")).optional(),
remoteAttachmentRoots: z.array(z.string().refine(isValidInboundPathRootPattern, "expected absolute path root")).optional(),
mediaMaxMb: z.number().int().positive().optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
blockStreaming: z.boolean().optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
groups: z.record(z.string(), z.object({
requireMention: z.boolean().optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema$1
}).strict().optional()).optional(),
heartbeat: ChannelHeartbeatVisibilitySchema,
responsePrefix: z.string().optional()
}).strict();
const IMessageAccountSchema = IMessageAccountSchemaBase.superRefine((value, ctx) => {
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.imessage.dmPolicy=\"open\" requires channels.imessage.allowFrom to include \"*\""
});
});
const IMessageConfigSchema = IMessageAccountSchemaBase.extend({ accounts: z.record(z.string(), IMessageAccountSchema.optional()).optional() }).superRefine((value, ctx) => {
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.imessage.dmPolicy=\"open\" requires channels.imessage.allowFrom to include \"*\""
});
});
const BlueBubblesAllowFromEntry = z.union([z.string(), z.number()]);
const BlueBubblesActionSchema = z.object({
reactions: z.boolean().optional(),
edit: z.boolean().optional(),
unsend: z.boolean().optional(),
reply: z.boolean().optional(),
sendWithEffect: z.boolean().optional(),
renameGroup: z.boolean().optional(),
setGroupIcon: z.boolean().optional(),
addParticipant: z.boolean().optional(),
removeParticipant: z.boolean().optional(),
leaveGroup: z.boolean().optional(),
sendAttachment: z.boolean().optional()
}).strict().optional();
const BlueBubblesGroupConfigSchema = z.object({
requireMention: z.boolean().optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema$1
}).strict();
const BlueBubblesAccountSchemaBase = z.object({
name: z.string().optional(),
capabilities: z.array(z.string()).optional(),
markdown: MarkdownConfigSchema,
configWrites: z.boolean().optional(),
enabled: z.boolean().optional(),
serverUrl: z.string().optional(),
password: z.string().optional().register(sensitive),
webhookPath: z.string().optional(),
dmPolicy: DmPolicySchema.optional().default("pairing"),
allowFrom: z.array(BlueBubblesAllowFromEntry).optional(),
groupAllowFrom: z.array(BlueBubblesAllowFromEntry).optional(),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
mediaMaxMb: z.number().int().positive().optional(),
mediaLocalRoots: z.array(z.string()).optional(),
sendReadReceipts: z.boolean().optional(),
blockStreaming: z.boolean().optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
groups: z.record(z.string(), BlueBubblesGroupConfigSchema.optional()).optional(),
heartbeat: ChannelHeartbeatVisibilitySchema,
responsePrefix: z.string().optional()
}).strict();
const BlueBubblesAccountSchema = BlueBubblesAccountSchemaBase.superRefine((value, ctx) => {
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.bluebubbles.accounts.*.dmPolicy=\"open\" requires allowFrom to include \"*\""
});
});
const BlueBubblesConfigSchema = BlueBubblesAccountSchemaBase.extend({
accounts: z.record(z.string(), BlueBubblesAccountSchema.optional()).optional(),
actions: BlueBubblesActionSchema
}).superRefine((value, ctx) => {
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.bluebubbles.dmPolicy=\"open\" requires channels.bluebubbles.allowFrom to include \"*\""
});
});
const MSTeamsChannelSchema = z.object({
requireMention: z.boolean().optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema$1,
replyStyle: MSTeamsReplyStyleSchema.optional()
}).strict();
const MSTeamsTeamSchema = z.object({
requireMention: z.boolean().optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema$1,
replyStyle: MSTeamsReplyStyleSchema.optional(),
channels: z.record(z.string(), MSTeamsChannelSchema.optional()).optional()
}).strict();
const MSTeamsConfigSchema = z.object({
enabled: z.boolean().optional(),
capabilities: z.array(z.string()).optional(),
dangerouslyAllowNameMatching: z.boolean().optional(),
markdown: MarkdownConfigSchema,
configWrites: z.boolean().optional(),
appId: z.string().optional(),
appPassword: z.string().optional().register(sensitive),
tenantId: z.string().optional(),
webhook: z.object({
port: z.number().int().positive().optional(),
path: z.string().optional()
}).strict().optional(),
dmPolicy: DmPolicySchema.optional().default("pairing"),
allowFrom: z.array(z.string()).optional(),
defaultTo: z.string().optional(),
groupAllowFrom: z.array(z.string()).optional(),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
mediaAllowHosts: z.array(z.string()).optional(),
mediaAuthAllowHosts: z.array(z.string()).optional(),
requireMention: z.boolean().optional(),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
replyStyle: MSTeamsReplyStyleSchema.optional(),
teams: z.record(z.string(), MSTeamsTeamSchema.optional()).optional(),
mediaMaxMb: z.number().positive().optional(),
sharePointSiteId: z.string().optional(),
heartbeat: ChannelHeartbeatVisibilitySchema,
responsePrefix: z.string().optional()
}).strict().superRefine((value, ctx) => {
requireOpenAllowFrom({
policy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
path: ["allowFrom"],
message: "channels.msteams.dmPolicy=\"open\" requires channels.msteams.allowFrom to include \"*\""
});
});
//#endregion
//#region src/config/zod-schema.providers-whatsapp.ts
const ToolPolicyBySenderSchema = z.record(z.string(), ToolPolicySchema).optional();
const WhatsAppGroupEntrySchema = z.object({
requireMention: z.boolean().optional(),
tools: ToolPolicySchema,
toolsBySender: ToolPolicyBySenderSchema
}).strict().optional();
const WhatsAppGroupsSchema = z.record(z.string(), WhatsAppGroupEntrySchema).optional();
const WhatsAppAckReactionSchema = z.object({
emoji: z.string().optional(),
direct: z.boolean().optional().default(true),
group: z.enum([
"always",
"mentions",
"never"
]).optional().default("mentions")
}).strict().optional();
const WhatsAppSharedSchema = z.object({
enabled: z.boolean().optional(),
capabilities: z.array(z.string()).optional(),
markdown: MarkdownConfigSchema,
configWrites: z.boolean().optional(),
sendReadReceipts: z.boolean().optional(),
messagePrefix: z.string().optional(),
responsePrefix: z.string().optional(),
dmPolicy: DmPolicySchema.optional().default("pairing"),
selfChatMode: z.boolean().optional(),
allowFrom: z.array(z.string()).optional(),
defaultTo: z.string().optional(),
groupAllowFrom: z.array(z.string()).optional(),
groupPolicy: GroupPolicySchema.optional().default("allowlist"),
historyLimit: z.number().int().min(0).optional(),
dmHistoryLimit: z.number().int().min(0).optional(),
dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
textChunkLimit: z.number().int().positive().optional(),
chunkMode: z.enum(["length", "newline"]).optional(),
blockStreaming: z.boolean().optional(),
blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
groups: WhatsAppGroupsSchema,
ackReaction: WhatsAppAckReactionSchema,
debounceMs: z.number().int().nonnegative().optional().default(0),
heartbeat: ChannelHeartbeatVisibilitySchema
});
function enforceOpenDmPolicyAllowFromStar(params) {
if (params.dmPolicy !== "open") return;
if ((Array.isArray(params.allowFrom) ? params.allowFrom : []).map((v) => String(v).trim()).filter(Boolean).includes("*")) return;
params.ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["allowFrom"],
message: params.message
});
}
const WhatsAppAccountSchema = WhatsAppSharedSchema.extend({
name: z.string().optional(),
enabled: z.boolean().optional(),
authDir: z.string().optional(),
mediaMaxMb: z.number().int().positive().optional()
}).strict().superRefine((value, ctx) => {
enforceOpenDmPolicyAllowFromStar({
dmPolicy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
message: "channels.whatsapp.accounts.*.dmPolicy=\"open\" requires allowFrom to include \"*\""
});
});
const WhatsAppConfigSchema = WhatsAppSharedSchema.extend({
accounts: z.record(z.string(), WhatsAppAccountSchema.optional()).optional(),
mediaMaxMb: z.number().int().positive().optional().default(50),
actions: z.object({
reactions: z.boolean().optional(),
sendMessage: z.boolean().optional(),
polls: z.boolean().optional()
}).strict().optional()
}).strict().superRefine((value, ctx) => {
enforceOpenDmPolicyAllowFromStar({
dmPolicy: value.dmPolicy,
allowFrom: value.allowFrom,
ctx,
message: "channels.whatsapp.dmPolicy=\"open\" requires channels.whatsapp.allowFrom to include \"*\""
});
});
//#endregion
//#region src/config/zod-schema.providers.ts
const ChannelModelByChannelSchema = z.record(z.string(), z.record(z.string(), z.string())).optional();
const ChannelsSchema = z.object({
defaults: z.object({
groupPolicy: GroupPolicySchema.optional(),
heartbeat: ChannelHeartbeatVisibilitySchema
}).strict().optional(),
modelByChannel: ChannelModelByChannelSchema,
whatsapp: WhatsAppConfigSchema.optional(),
telegram: TelegramConfigSchema.optional(),
discord: DiscordConfigSchema.optional(),
irc: IrcConfigSchema.optional(),
googlechat: GoogleChatConfigSchema.optional(),
slack: SlackConfigSchema.optional(),
signal: SignalConfigSchema.optional(),
imessage: IMessageConfigSchema.optional(),
bluebubbles: BlueBubblesConfigSchema.optional(),
msteams: MSTeamsConfigSchema.optional()
}).passthrough().optional();
//#endregion
//#region src/config/zod-schema.session.ts
const SessionResetConfigSchema = z.object({
mode: z.union([z.literal("daily"), z.literal("idle")]).optional(),
atHour: z.number().int().min(0).max(23).optional(),
idleMinutes: z.number().int().positive().optional()
}).strict();
const SessionSendPolicySchema = createAllowDenyChannelRulesSchema();
const SessionSchema = z.object({
scope: z.union([z.literal("per-sender"), z.literal("global")]).optional(),
dmScope: z.union([
z.literal("main"),
z.literal("per-peer"),
z.literal("per-channel-peer"),
z.literal("per-account-channel-peer")
]).optional(),
identityLinks: z.record(z.string(), z.array(z.string())).optional(),
resetTriggers: z.array(z.string()).optional(),
idleMinutes: z.number().int().positive().optional(),
reset: SessionResetConfigSchema.optional(),
resetByType: z.object({
direct: SessionResetConfigSchema.optional(),
dm: SessionResetConfigSchema.optional(),
group: SessionResetConfigSchema.optional(),
thread: SessionResetConfigSchema.optional()
}).strict().optional(),
resetByChannel: z.record(z.string(), SessionResetConfigSchema).optional(),
store: z.string().optional(),
typingIntervalSeconds: z.number().int().positive().optional(),
typingMode: TypingModeSchema.optional(),
mainKey: z.string().optional(),
sendPolicy: SessionSendPolicySchema.optional(),
agentToAgent: z.object({ maxPingPongTurns: z.number().int().min(0).max(5).optional() }).strict().optional(),
threadBindings: z.object({
enabled: z.boolean().optional(),
ttlHours: z.number().nonnegative().optional()
}).strict().optional(),
maintenance: z.object({
mode: z.enum(["enforce", "warn"]).optional(),
pruneAfter: z.union([z.string(), z.number()]).optional(),
pruneDays: z.number().int().positive().optional(),
maxEntries: z.number().int().positive().optional(),
rotateBytes: z.union([z.string(), z.number()]).optional(),
resetArchiveRetention: z.union([
z.string(),
z.number(),
z.literal(false)
]).optional(),
maxDiskBytes: z.union([z.string(), z.number()]).optional(),
highWaterBytes: z.union([z.string(), z.number()]).optional()
}).strict().superRefine((val, ctx) => {
if (val.pruneAfter !== void 0) try {
parseDurationMs(String(val.pruneAfter).trim(), { defaultUnit: "d" });
} catch {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["pruneAfter"],
message: "invalid duration (use ms, s, m, h, d)"
});
}
if (val.rotateBytes !== void 0) try {
parseByteSize(String(val.rotateBytes).trim(), { defaultUnit: "b" });
} catch {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["rotateBytes"],
message: "invalid size (use b, kb, mb, gb, tb)"
});
}
if (val.resetArchiveRetention !== void 0 && val.resetArchiveRetention !== false) try {
parseDurationMs(String(val.resetArchiveRetention).trim(), { defaultUnit: "d" });
} catch {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["resetArchiveRetention"],
message: "invalid duration (use ms, s, m, h, d)"
});
}
if (val.maxDiskBytes !== void 0) try {
parseByteSize(String(val.maxDiskBytes).trim(), { defaultUnit: "b" });
} catch {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["maxDiskBytes"],
message: "invalid size (use b, kb, mb, gb, tb)"
});
}
if (val.highWaterBytes !== void 0) try {
parseByteSize(String(val.highWaterBytes).trim(), { defaultUnit: "b" });
} catch {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["highWaterBytes"],
message: "invalid size (use b, kb, mb, gb, tb)"
});
}
}).optional()
}).strict().optional();
const MessagesSchema = z.object({
messagePrefix: z.string().optional(),
responsePrefix: z.string().optional(),
groupChat: GroupChatSchema,
queue: QueueSchema,
inbound: InboundDebounceSchema,
ackReaction: z.string().optional(),
ackReactionScope: z.enum([
"group-mentions",
"group-all",
"direct",
"all"
]).optional(),
removeAckAfterReply: z.boolean().optional(),
statusReactions: z.object({
enabled: z.boolean().optional(),
emojis: z.object({
thinking: z.string().optional(),
tool: z.string().optional(),
coding: z.string().optional(),
web: z.string().optional(),
done: z.string().optional(),
error: z.string().optional(),
stallSoft: z.string().optional(),
stallHard: z.string().optional()
}).strict().optional(),
timing: z.object({
debounceMs: z.number().int().min(0).optional(),
stallSoftMs: z.number().int().min(0).optional(),
stallHardMs: z.number().int().min(0).optional(),
doneHoldMs: z.number().int().min(0).optional(),
errorHoldMs: z.number().int().min(0).optional()
}).strict().optional()
}).strict().optional(),
suppressToolErrors: z.boolean().optional(),
tts: TtsConfigSchema
}).strict().optional();
const CommandsSchema = z.object({
native: NativeCommandsSettingSchema.optional().default("auto"),
nativeSkills: NativeCommandsSettingSchema.optional().default("auto"),
text: z.boolean().optional(),
bash: z.boolean().optional(),
bashForegroundMs: z.number().int().min(0).max(3e4).optional(),
config: z.boolean().optional(),
debug: z.boolean().optional(),
restart: z.boolean().optional().default(true),
useAccessGroups: z.boolean().optional(),
ownerAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
ownerDisplay: z.enum(["raw", "hash"]).optional().default("raw"),
ownerDisplaySecret: z.string().optional().register(sensitive),
allowFrom: ElevatedAllowFromSchema.optional()
}).strict().optional().default(() => ({
native: "auto",
nativeSkills: "auto",
restart: true,
ownerDisplay: "raw"
}));
//#endregion
//#region src/config/zod-schema.ts
const BrowserSnapshotDefaultsSchema = z.object({ mode: z.literal("efficient").optional() }).strict().optional();
const NodeHostSchema = z.object({ browserProxy: z.object({
enabled: z.boolean().optional(),
allowProfiles: z.array(z.string()).optional()
}).strict().optional() }).strict().optional();
const MemoryQmdPathSchema = z.object({
path: z.string(),
name: z.string().optional(),
pattern: z.string().optional()
}).strict();
const MemoryQmdSessionSchema = z.object({
enabled: z.boolean().optional(),
exportDir: z.string().optional(),
retentionDays: z.number().int().nonnegative().optional()
}).strict();
const MemoryQmdUpdateSchema = z.object({
interval: z.string().optional(),
debounceMs: z.number().int().nonnegative().optional(),
onBoot: z.boolean().optional(),
waitForBootSync: z.boolean().optional(),
embedInterval: z.string().optional(),
commandTimeoutMs: z.number().int().nonnegative().optional(),
updateTimeoutMs: z.number().int().nonnegative().optional(),
embedTimeoutMs: z.number().int().nonnegative().optional()
}).strict();
const MemoryQmdLimitsSchema = z.object({
maxResults: z.number().int().positive().optional(),
maxSnippetChars: z.number().int().positive().optional(),
maxInjectedChars: z.number().int().positive().optional(),
timeoutMs: z.number().int().nonnegative().optional()
}).strict();
const MemoryQmdMcporterSchema = z.object({
enabled: z.boolean().optional(),
serverName: z.string().optional(),
startDaemon: z.boolean().optional()
}).strict();
const LoggingLevelSchema = z.union([
z.literal("silent"),
z.literal("fatal"),
z.literal("error"),
z.literal("warn"),
z.literal("info"),
z.literal("debug"),
z.literal("trace")
]);
const MemoryQmdSchema = z.object({
command: z.string().optional(),
mcporter: MemoryQmdMcporterSchema.optional(),
searchMode: z.union([
z.literal("query"),
z.literal("search"),
z.literal("vsearch")
]).optional(),
includeDefaultMemory: z.boolean().optional(),
paths: z.array(MemoryQmdPathSchema).optional(),
sessions: MemoryQmdSessionSchema.optional(),
update: MemoryQmdUpdateSchema.optional(),
limits: MemoryQmdLimitsSchema.optional(),
scope: SessionSendPolicySchema.optional()
}).strict();
const MemorySchema = z.object({
backend: z.union([z.literal("builtin"), z.literal("qmd")]).optional(),
citations: z.union([
z.literal("auto"),
z.literal("on"),
z.literal("off")
]).optional(),
qmd: MemoryQmdSchema.optional()
}).strict().optional();
const HttpUrlSchema = z.string().url().refine((value) => {
const protocol = new URL(value).protocol;
return protocol === "http:" || protocol === "https:";
}, "Expected http:// or https:// URL");
const OpenClawSchema = z.object({
$schema: z.string().optional(),
meta: z.object({
lastTouchedVersion: z.string().optional(),
lastTouchedAt: z.union([z.string(), z.number().transform((n, ctx) => {
const d = new Date(n);
if (Number.isNaN(d.getTime())) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Invalid timestamp"
});
return z.NEVER;
}
return d.toISOString();
})]).optional()
}).strict().optional(),
env: z.object({
shellEnv: z.object({
enabled: z.boolean().optional(),
timeoutMs: z.number().int().nonnegative().optional()
}).strict().optional(),
vars: z.record(z.string(), z.string()).optional()
}).catchall(z.string()).optional(),
wizard: z.object({
lastRunAt: z.string().optional(),
lastRunVersion: z.string().optional(),
lastRunCommit: z.string().optional(),
lastRunCommand: z.string().optional(),
lastRunMode: z.union([z.literal("local"), z.literal("remote")]).optional()
}).strict().optional(),
diagnostics: z.object({
enabled: z.boolean().optional(),
flags: z.array(z.string()).optional(),
otel: z.object({
enabled: z.boolean().optional(),
endpoint: z.string().optional(),
protocol: z.union([z.literal("http/protobuf"), z.literal("grpc")]).optional(),
headers: z.record(z.string(), z.string()).optional(),
serviceName: z.string().optional(),
traces: z.boolean().optional(),
metrics: z.boolean().optional(),
logs: z.boolean().optional(),
sampleRate: z.number().min(0).max(1).optional(),
flushIntervalMs: z.number().int().nonnegative().optional()
}).strict().optional(),
cacheTrace: z.object({
enabled: z.boolean().optional(),
filePath: z.string().optional(),
includeMessages: z.boolean().optional(),
includePrompt: z.boolean().optional(),
includeSystem: z.boolean().optional()
}).strict().optional()
}).strict().optional(),
logging: z.object({
level: LoggingLevelSchema.optional(),
file: z.string().optional(),
maxFileBytes: z.number().int().positive().optional(),
consoleLevel: LoggingLevelSchema.optional(),
consoleStyle: z.union([
z.literal("pretty"),
z.literal("compact"),
z.literal("json")
]).optional(),
redactSensitive: z.union([z.literal("off"), z.literal("tools")]).optional(),
redactPatterns: z.array(z.string()).optional()
}).strict().optional(),
update: z.object({
channel: z.union([
z.literal("stable"),
z.literal("beta"),
z.literal("dev")
]).optional(),
checkOnStart: z.boolean().optional(),
auto: z.object({
enabled: z.boolean().optional(),
stableDelayHours: z.number().nonnegative().max(168).optional(),
stableJitterHours: z.number().nonnegative().max(168).optional(),
betaCheckIntervalHours: z.number().positive().max(24).optional()
}).strict().optional()
}).strict().optional(),
browser: z.object({
enabled: z.boolean().optional(),
evaluateEnabled: z.boolean().optional(),
cdpUrl: z.string().optional(),
remoteCdpTimeoutMs: z.number().int().nonnegative().optional(),
remoteCdpHandshakeTimeoutMs: z.number().int().nonnegative().optional(),
color: z.string().optional(),
executablePath: z.string().optional(),
headless: z.boolean().optional(),
noSandbox: z.boolean().optional(),
attachOnly: z.boolean().optional(),
defaultProfile: z.string().optional(),
snapshotDefaults: BrowserSnapshotDefaultsSchema,
ssrfPolicy: z.object({
allowPrivateNetwork: z.boolean().optional(),
dangerouslyAllowPrivateNetwork: z.boolean().optional(),
allowedHostnames: z.array(z.string()).optional(),
hostnameAllowlist: z.array(z.string()).optional()
}).strict().optional(),
profiles: z.record(z.string().regex(/^[a-z0-9-]+$/, "Profile names must be alphanumeric with hyphens only"), z.object({
cdpPort: z.number().int().min(1).max(65535).optional(),
cdpUrl: z.string().optional(),
driver: z.union([z.literal("clawd"), z.literal("extension")]).optional(),
color: HexColorSchema
}).strict().refine((value) => value.cdpPort || value.cdpUrl, { message: "Profile must set cdpPort or cdpUrl" })).optional()
}).strict().optional(),
ui: z.object({
seamColor: HexColorSchema.optional(),
assistant: z.object({
name: z.string().max(50).optional(),
avatar: z.string().max(200).optional()
}).strict().optional()
}).strict().optional(),
auth: z.object({
profiles: z.record(z.string(), z.object({
provider: z.string(),
mode: z.union([
z.literal("api_key"),
z.literal("oauth"),
z.literal("token")
]),
email: z.string().optional()
}).strict()).optional(),
order: z.record(z.string(), z.array(z.string())).optional(),
cooldowns: z.object({
billingBackoffHours: z.number().positive().optional(),
billingBackoffHoursByProvider: z.record(z.string(), z.number().positive()).optional(),
billingMaxHours: z.number().positive().optional(),
failureWindowHours: z.number().positive().optional()
}).strict().optional()
}).strict().optional(),
models: ModelsConfigSchema,
nodeHost: NodeHostSchema,
agents: AgentsSchema,
tools: ToolsSchema,
bindings: BindingsSchema,
broadcast: BroadcastSchema,
audio: AudioSchema,
media: z.object({ preserveFilenames: z.boolean().optional() }).strict().optional(),
messages: MessagesSchema,
commands: CommandsSchema,
approvals: ApprovalsSchema,
session: SessionSchema,
cron: z.object({
enabled: z.boolean().optional(),
store: z.string().optional(),
maxConcurrentRuns: z.number().int().positive().optional(),
webhook: HttpUrlSchema.optional(),
webhookToken: z.string().optional().register(sensitive),
sessionRetention: z.union([z.string(), z.literal(false)]).optional(),
runLog: z.object({
maxBytes: z.union([z.string(), z.number()]).optional(),
keepLines: z.number().int().positive().optional()
}).strict().optional()
}).strict().superRefine((val, ctx) => {
if (val.sessionRetention !== void 0 && val.sessionRetention !== false) try {
parseDurationMs(String(val.sessionRetention).trim(), { defaultUnit: "h" });
} catch {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["sessionRetention"],
message: "invalid duration (use ms, s, m, h, d)"
});
}
if (val.runLog?.maxBytes !== void 0) try {
parseByteSize(String(val.runLog.maxBytes).trim(), { defaultUnit: "b" });
} catch {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ["runLog", "maxBytes"],
message: "invalid size (use b, kb, mb, gb, tb)"
});
}
}).optional(),
hooks: z.object({
enabled: z.boolean().optional(),
path: z.string().optional(),
token: z.string().optional().register(sensitive),
defaultSessionKey: z.string().optional(),
allowRequestSessionKey: z.boolean().optional(),
allowedSessionKeyPrefixes: z.array(z.string()).optional(),
allowedAgentIds: z.array(z.string()).optional(),
maxBodyBytes: z.number().int().positive().optional(),
presets: z.array(z.string()).optional(),
transformsDir: z.string().optional(),
mappings: z.array(HookMappingSchema).optional(),
gmail: HooksGmailSchema,
internal: InternalHooksSchema
}).strict().optional(),
web: z.object({
enabled: z.boolean().optional(),
heartbeatSeconds: z.number().int().positive().optional(),
reconnect: z.object({
initialMs: z.number().positive().optional(),
maxMs: z.number().positive().optional(),
factor: z.number().positive().optional(),
jitter: z.number().min(0).max(1).optional(),
maxAttempts: z.number().int().min(0).optional()
}).strict().optional()
}).strict().optional(),
channels: ChannelsSchema,
discovery: z.object({
wideArea: z.object({ enabled: z.boolean().optional() }).strict().optional(),
mdns: z.object({ mode: z.enum([
"off",
"minimal",
"full"
]).optional() }).strict().optional()
}).strict().optional(),
canvasHost: z.object({
enabled: z.boolean().optional(),
root: z.string().optional(),
port: z.number().int().positive().optional(),
liveReload: z.boolean().optional()
}).strict().optional(),
talk: z.object({
provider: z.string().optional(),
providers: z.record(z.string(), z.object({
voiceId: z.string().optional(),
voiceAliases: z.record(z.string(), z.string()).optional(),
modelId: z.string().optional(),
outputFormat: z.string().optional(),
apiKey: z.string().optional().register(sensitive)
}).catchall(z.unknown())).optional(),
voiceId: z.string().optional(),
voiceAliases: z.record(z.string(), z.string()).optional(),
modelId: z.string().optional(),
outputFormat: z.string().optional(),
apiKey: z.string().optional().register(sensitive),
interruptOnSpeech: z.boolean().optional()
}).strict().optional(),
gateway: z.object({
port: z.number().int().positive().optional(),
mode: z.union([z.literal("local"), z.literal("remote")]).optional(),
bind: z.union([
z.literal("auto"),
z.literal("lan"),
z.literal("loopback"),
z.literal("custom"),
z.literal("tailnet")
]).optional(),
customBindHost: z.string().optional(),
controlUi: z.object({
enabled: z.boolean().optional(),
basePath: z.string().optional(),
root: z.string().optional(),
allowedOrigins: z.array(z.string()).optional(),
dangerouslyAllowHostHeaderOriginFallback: z.boolean().optional(),
allowInsecureAuth: z.boolean().optional(),
dangerouslyDisableDeviceAuth: z.boolean().optional()
}).strict().optional(),
auth: z.object({
mode: z.union([
z.literal("none"),
z.literal("token"),
z.literal("password"),
z.literal("trusted-proxy")
]).optional(),
token: z.string().optional().register(sensitive),
password: z.string().optional().register(sensitive),
allowTailscale: z.boolean().optional(),
rateLimit: z.object({
maxAttempts: z.number().optional(),
windowMs: z.number().optional(),
lockoutMs: z.number().optional(),
exemptLoopback: z.boolean().optional()
}).strict().optional(),
trustedProxy: z.object({
userHeader: z.string().min(1, "userHeader is required for trusted-proxy mode"),
requiredHeaders: z.array(z.string()).optional(),
allowUsers: z.array(z.string()).optional()
}).strict().optional()
}).strict().optional(),
trustedProxies: z.array(z.string()).optional(),
allowRealIpFallback: z.boolean().optional(),
tools: z.object({
deny: z.array(z.string()).optional(),
allow: z.array(z.string()).optional()
}).strict().optional(),
channelHealthCheckMinutes: z.number().int().min(0).optional(),
tailscale: z.object({
mode: z.union([
z.literal("off"),
z.literal("serve"),
z.literal("funnel")
]).optional(),
resetOnExit: z.boolean().optional()
}).strict().optional(),
remote: z.object({
url: z.string().optional(),
transport: z.union([z.literal("ssh"), z.literal("direct")]).optional(),
token: z.string().optional().register(sensitive),
password: z.string().optional().register(sensitive),
tlsFingerprint: z.string().optional(),
sshTarget: z.string().optional(),
sshIdentity: z.string().optional()
}).strict().optional(),
reload: z.object({
mode: z.union([
z.literal("off"),
z.literal("restart"),
z.literal("hot"),
z.literal("hybrid")
]).optional(),
debounceMs: z.number().int().min(0).optional()
}).strict().optional(),
tls: z.object({
enabled: z.boolean().optional(),
autoGenerate: z.boolean().optional(),
certPath: z.string().optional(),
keyPath: z.string().optional(),
caPath: z.string().optional()
}).optional(),
http: z.object({
endpoints: z.object({
chatCompletions: z.object({ enabled: z.boolean().optional() }).strict().optional(),
responses: z.object({
enabled: z.boolean().optional(),
maxBodyBytes: z.number().int().positive().optional(),
maxUrlParts: z.number().int().nonnegative().optional(),
files: z.object({
allowUrl: z.boolean().optional(),
urlAllowlist: z.array(z.string()).optional(),
allowedMimes: z.array(z.string()).optional(),
maxBytes: z.number().int().positive().optional(),
maxChars: z.number().int().positive().optional(),
maxRedirects: z.number().int().nonnegative().optional(),
timeoutMs: z.number().int().positive().optional(),
pdf: z.object({
maxPages: z.number().int().positive().optional(),
maxPixels: z.number().int().positive().optional(),
minTextChars: z.number().int().nonnegative().optional()
}).strict().optional()
}).strict().optional(),
images: z.object({
allowUrl: z.boolean().optional(),
urlAllowlist: z.array(z.string()).optional(),
allowedMimes: z.array(z.string()).optional(),
maxBytes: z.number().int().positive().optional(),
maxRedirects: z.number().int().nonnegative().optional(),
timeoutMs: z.number().int().positive().optional()
}).strict().optional()
}).strict().optional()
}).strict().optional(),
securityHeaders: z.object({ strictTransportSecurity: z.union([z.string(), z.literal(false)]).optional() }).strict().optional()
}).strict().optional(),
nodes: z.object({
browser: z.object({
mode: z.union([
z.literal("auto"),
z.literal("manual"),
z.literal("off")
]).optional(),
node: z.string().optional()
}).strict().optional(),
allowCommands: z.array(z.string()).optional(),
denyCommands: z.array(z.string()).optional()
}).strict().optional()
}).strict().optional(),
memory: MemorySchema,
skills: z.object({
allowBundled: z.array(z.string()).optional(),
load: z.object({
extraDirs: z.array(z.string()).optional(),
watch: z.boolean().optional(),
watchDebounceMs: z.number().int().min(0).optional()
}).strict().optional(),
install: z.object({
preferBrew: z.boolean().optional(),
nodeManager: z.union([
z.literal("npm"),
z.literal("pnpm"),
z.literal("yarn"),
z.literal("bun")
]).optional()
}).strict().optional(),
limits: z.object({
maxCandidatesPerRoot: z.number().int().min(1).optional(),
maxSkillsLoadedPerSource: z.number().int().min(1).optional(),
maxSkillsInPrompt: z.number().int().min(0).optional(),
maxSkillsPromptChars: z.number().int().min(0).optional(),
maxSkillFileBytes: z.number().int().min(0).optional()
}).strict().optional(),
entries: z.record(z.string(), z.object({
enabled: z.boolean().optional(),
apiKey: z.string().optional().register(sensitive),
env: z.record(z.string(), z.string()).optional(),
config: z.record(z.string(), z.unknown()).optional()
}).strict()).optional()
}).strict().optional(),
plugins: z.object({
enabled: z.boolean().optional(),
allow: z.array(z.string()).optional(),
deny: z.array(z.string()).optional(),
load: z.object({ paths: z.array(z.string()).optional() }).strict().optional(),
slots: z.object({ memory: z.string().optional() }).strict().optional(),
entries: z.record(z.string(), z.object({
enabled: z.boolean().optional(),
config: z.record(z.string(), z.unknown()).optional()
}).strict()).optional(),
installs: z.record(z.string(), z.object({ ...InstallRecordShape }).strict()).optional()
}).strict().optional()
}).strict().superRefine((cfg, ctx) => {
const agents = cfg.agents?.list ?? [];
if (agents.length === 0) return;
const agentIds = new Set(agents.map((agent) => agent.id));
const broadcast = cfg.broadcast;
if (!broadcast) return;
for (const [peerId, ids] of Object.entries(broadcast)) {
if (peerId === "strategy") continue;
if (!Array.isArray(ids)) continue;
for (let idx = 0; idx < ids.length; idx += 1) {
const agentId = ids[idx];
if (!agentIds.has(agentId)) ctx.addIssue({
code: z.ZodIssueCode.custom,
path: [
"broadcast",
peerId,
idx
],
message: `Unknown agent id "${agentId}" (not in agents.list).`
});
}
}
});
//#endregion
//#region src/config/validation.ts
const LEGACY_REMOVED_PLUGIN_IDS = new Set(["google-antigravity-auth"]);
function isWorkspaceAvatarPath(value, workspaceDir) {
const workspaceRoot = path.resolve(workspaceDir);
return isPathWithinRoot(workspaceRoot, path.resolve(workspaceRoot, value));
}
function validateIdentityAvatar(config) {
const agents = config.agents?.list;
if (!Array.isArray(agents) || agents.length === 0) return [];
const issues = [];
for (const [index, entry] of agents.entries()) {
if (!entry || typeof entry !== "object") continue;
const avatarRaw = entry.identity?.avatar;
if (typeof avatarRaw !== "string") continue;
const avatar = avatarRaw.trim();
if (!avatar) continue;
if (isAvatarDataUrl(avatar) || isAvatarHttpUrl(avatar)) continue;
if (avatar.startsWith("~")) {
issues.push({
path: `agents.list.${index}.identity.avatar`,
message: "identity.avatar must be a workspace-relative path, http(s) URL, or data URI."
});
continue;
}
if (hasAvatarUriScheme(avatar) && !isWindowsAbsolutePath(avatar)) {
issues.push({
path: `agents.list.${index}.identity.avatar`,
message: "identity.avatar must be a workspace-relative path, http(s) URL, or data URI."
});
continue;
}
if (!isWorkspaceAvatarPath(avatar, resolveAgentWorkspaceDir(config, entry.id ?? resolveDefaultAgentId(config)))) issues.push({
path: `agents.list.${index}.identity.avatar`,
message: "identity.avatar must stay within the agent workspace."
});
}
return issues;
}
/**
* Validates config without applying runtime defaults.
* Use this when you need the raw validated config (e.g., for writing back to file).
*/
function validateConfigObjectRaw(raw) {
const legacyIssues = findLegacyConfigIssues(raw);
if (legacyIssues.length > 0) return {
ok: false,
issues: legacyIssues.map((iss) => ({
path: iss.path,
message: iss.message
}))
};
const validated = OpenClawSchema.safeParse(raw);
if (!validated.success) return {
ok: false,
issues: validated.error.issues.map((iss) => ({
path: iss.path.join("."),
message: iss.message
}))
};
const duplicates = findDuplicateAgentDirs(validated.data);
if (duplicates.length > 0) return {
ok: false,
issues: [{
path: "agents.list",
message: formatDuplicateAgentDirError(duplicates)
}]
};
const avatarIssues = validateIdentityAvatar(validated.data);
if (avatarIssues.length > 0) return {
ok: false,
issues: avatarIssues
};
return {
ok: true,
config: validated.data
};
}
function validateConfigObject(raw) {
const result = validateConfigObjectRaw(raw);
if (!result.ok) return result;
return {
ok: true,
config: applyModelDefaults(applyAgentDefaults(applySessionDefaults(result.config)))
};
}
function validateConfigObjectWithPlugins(raw) {
return validateConfigObjectWithPluginsBase(raw, { applyDefaults: true });
}
function validateConfigObjectRawWithPlugins(raw) {
return validateConfigObjectWithPluginsBase(raw, { applyDefaults: false });
}
function validateConfigObjectWithPluginsBase(raw, opts) {
const base = opts.applyDefaults ? validateConfigObject(raw) : validateConfigObjectRaw(raw);
if (!base.ok) return {
ok: false,
issues: base.issues,
warnings: []
};
const config = base.config;
const issues = [];
const warnings = [];
const hasExplicitPluginsConfig = isRecord(raw) && Object.prototype.hasOwnProperty.call(raw, "plugins");
let registryInfo = null;
const ensureRegistry = () => {
if (registryInfo) return registryInfo;
const registry = loadPluginManifestRegistry({
config,
workspaceDir: resolveAgentWorkspaceDir(config, resolveDefaultAgentId(config)) ?? void 0
});
const knownIds = new Set(registry.plugins.map((record) => record.id));
const normalizedPlugins = normalizePluginsConfig(config.plugins);
for (const diag of registry.diagnostics) {
let path = diag.pluginId ? `plugins.entries.${diag.pluginId}` : "plugins";
if (!diag.pluginId && diag.message.includes("plugin path not found")) path = "plugins.load.paths";
const message = `${diag.pluginId ? `plugin ${diag.pluginId}` : "plugin"}: ${diag.message}`;
if (diag.level === "error") issues.push({
path,
message
});
else warnings.push({
path,
message
});
}
registryInfo = {
registry,
knownIds,
normalizedPlugins
};
return registryInfo;
};
const allowedChannels = new Set([
"defaults",
"modelByChannel",
...CHANNEL_IDS
]);
if (config.channels && isRecord(config.channels)) for (const key of Object.keys(config.channels)) {
const trimmed = key.trim();
if (!trimmed) continue;
if (!allowedChannels.has(trimmed)) {
const { registry } = ensureRegistry();
for (const record of registry.plugins) for (const channelId of record.channels) allowedChannels.add(channelId);
}
if (!allowedChannels.has(trimmed)) issues.push({
path: `channels.${trimmed}`,
message: `unknown channel id: ${trimmed}`
});
}
const heartbeatChannelIds = /* @__PURE__ */ new Set();
for (const channelId of CHANNEL_IDS) heartbeatChannelIds.add(channelId.toLowerCase());
const validateHeartbeatTarget = (target, path) => {
if (typeof target !== "string") return;
const trimmed = target.trim();
if (!trimmed) {
issues.push({
path,
message: "heartbeat target must not be empty"
});
return;
}
const normalized = trimmed.toLowerCase();
if (normalized === "last" || normalized === "none") return;
if (normalizeChatChannelId(trimmed)) return;
if (!heartbeatChannelIds.has(normalized)) {
const { registry } = ensureRegistry();
for (const record of registry.plugins) for (const channelId of record.channels) {
const pluginChannel = channelId.trim();
if (pluginChannel) heartbeatChannelIds.add(pluginChannel.toLowerCase());
}
}
if (heartbeatChannelIds.has(normalized)) return;
issues.push({
path,
message: `unknown heartbeat target: ${target}`
});
};
validateHeartbeatTarget(config.agents?.defaults?.heartbeat?.target, "agents.defaults.heartbeat.target");
if (Array.isArray(config.agents?.list)) for (const [index, entry] of config.agents.list.entries()) validateHeartbeatTarget(entry?.heartbeat?.target, `agents.list.${index}.heartbeat.target`);
if (!hasExplicitPluginsConfig) {
if (issues.length > 0) return {
ok: false,
issues,
warnings
};
return {
ok: true,
config,
warnings
};
}
const { registry, knownIds, normalizedPlugins } = ensureRegistry();
const pushMissingPluginIssue = (path, pluginId) => {
if (LEGACY_REMOVED_PLUGIN_IDS.has(pluginId)) {
warnings.push({
path,
message: `plugin removed: ${pluginId} (stale config entry ignored; remove it from plugins config)`
});
return;
}
issues.push({
path,
message: `plugin not found: ${pluginId}`
});
};
const pluginsConfig = config.plugins;
const entries = pluginsConfig?.entries;
if (entries && isRecord(entries)) {
for (const pluginId of Object.keys(entries)) if (!knownIds.has(pluginId)) pushMissingPluginIssue(`plugins.entries.${pluginId}`, pluginId);
}
const allow = pluginsConfig?.allow ?? [];
for (const pluginId of allow) {
if (typeof pluginId !== "string" || !pluginId.trim()) continue;
if (!knownIds.has(pluginId)) pushMissingPluginIssue("plugins.allow", pluginId);
}
const deny = pluginsConfig?.deny ?? [];
for (const pluginId of deny) {
if (typeof pluginId !== "string" || !pluginId.trim()) continue;
if (!knownIds.has(pluginId)) pushMissingPluginIssue("plugins.deny", pluginId);
}
const memorySlot = normalizedPlugins.slots.memory;
if (typeof memorySlot === "string" && memorySlot.trim() && !knownIds.has(memorySlot)) pushMissingPluginIssue("plugins.slots.memory", memorySlot);
let selectedMemoryPluginId = null;
const seenPlugins = /* @__PURE__ */ new Set();
for (const record of registry.plugins) {
const pluginId = record.id;
if (seenPlugins.has(pluginId)) continue;
seenPlugins.add(pluginId);
const entry = normalizedPlugins.entries[pluginId];
const entryHasConfig = Boolean(entry?.config);
const enableState = resolveEffectiveEnableState({
id: pluginId,
origin: record.origin,
config: normalizedPlugins,
rootConfig: config
});
let enabled = enableState.enabled;
let reason = enableState.reason;
if (enabled) {
const memoryDecision = resolveMemorySlotDecision({
id: pluginId,
kind: record.kind,
slot: memorySlot,
selectedId: selectedMemoryPluginId
});
if (!memoryDecision.enabled) {
enabled = false;
reason = memoryDecision.reason;
}
if (memoryDecision.selected && record.kind === "memory") selectedMemoryPluginId = pluginId;
}
if (enabled || entryHasConfig) if (record.configSchema) {
const res = validateJsonSchemaValue({
schema: record.configSchema,
cacheKey: record.schemaCacheKey ?? record.manifestPath ?? pluginId,
value: entry?.config ?? {}
});
if (!res.ok) for (const error of res.errors) issues.push({
path: `plugins.entries.${pluginId}.config`,
message: `invalid config: ${error}`
});
} else issues.push({
path: `plugins.entries.${pluginId}`,
message: `plugin schema missing for ${pluginId}`
});
if (!enabled && entryHasConfig) warnings.push({
path: `plugins.entries.${pluginId}`,
message: `plugin disabled (${reason ?? "disabled"}) but config is present`
});
}
if (issues.length > 0) return {
ok: false,
issues,
warnings
};
return {
ok: true,
config,
warnings
};
}
//#endregion
//#region src/config/version.ts
const VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-(\d+))?/;
function parseOpenClawVersion(raw) {
if (!raw) return null;
const match = raw.trim().match(VERSION_RE);
if (!match) return null;
const [, major, minor, patch, revision] = match;
return {
major: Number.parseInt(major, 10),
minor: Number.parseInt(minor, 10),
patch: Number.parseInt(patch, 10),
revision: revision ? Number.parseInt(revision, 10) : 0
};
}
function compareOpenClawVersions(a, b) {
const parsedA = parseOpenClawVersion(a);
const parsedB = parseOpenClawVersion(b);
if (!parsedA || !parsedB) return null;
if (parsedA.major !== parsedB.major) return parsedA.major < parsedB.major ? -1 : 1;
if (parsedA.minor !== parsedB.minor) return parsedA.minor < parsedB.minor ? -1 : 1;
if (parsedA.patch !== parsedB.patch) return parsedA.patch < parsedB.patch ? -1 : 1;
if (parsedA.revision !== parsedB.revision) return parsedA.revision < parsedB.revision ? -1 : 1;
return 0;
}
//#endregion
//#region src/config/io.ts
const SHELL_ENV_EXPECTED_KEYS = [
"OPENAI_API_KEY",
"ANTHROPIC_API_KEY",
"ANTHROPIC_OAUTH_TOKEN",
"GEMINI_API_KEY",
"ZAI_API_KEY",
"OPENROUTER_API_KEY",
"AI_GATEWAY_API_KEY",
"MINIMAX_API_KEY",
"SYNTHETIC_API_KEY",
"KILOCODE_API_KEY",
"ELEVENLABS_API_KEY",
"TELEGRAM_BOT_TOKEN",
"DISCORD_BOT_TOKEN",
"SLACK_BOT_TOKEN",
"SLACK_APP_TOKEN",
"OPENCLAW_GATEWAY_TOKEN",
"OPENCLAW_GATEWAY_PASSWORD"
];
const OPEN_DM_POLICY_ALLOW_FROM_RE = /^(?<policyPath>[a-z0-9_.-]+)\s*=\s*"open"\s+requires\s+(?<allowPath>[a-z0-9_.-]+)(?:\s+\(or\s+[a-z0-9_.-]+\))?\s+to include "\*"$/i;
const CONFIG_AUDIT_LOG_FILENAME = "config-audit.jsonl";
const loggedInvalidConfigs = /* @__PURE__ */ new Set();
function hashConfigRaw(raw) {
return crypto.createHash("sha256").update(raw ?? "").digest("hex");
}
function formatConfigValidationFailure(pathLabel, issueMessage) {
const match = issueMessage.match(OPEN_DM_POLICY_ALLOW_FROM_RE);
const policyPath = match?.groups?.policyPath?.trim();
const allowPath = match?.groups?.allowPath?.trim();
if (!policyPath || !allowPath) return `Config validation failed: ${pathLabel}: ${issueMessage}`;
return [
`Config validation failed: ${pathLabel}`,
"",
`Configuration mismatch: ${policyPath} is "open", but ${allowPath} does not include "*".`,
"",
"Fix with:",
` openclaw config set ${allowPath} '["*"]'`,
"",
"Or switch policy:",
` openclaw config set ${policyPath} "pairing"`
].join("\n");
}
function isNumericPathSegment(raw) {
return /^[0-9]+$/.test(raw);
}
function isWritePlainObject(value) {
return Boolean(value) && typeof value === "object" && !Array.isArray(value);
}
function hasOwnObjectKey(value, key) {
return Object.prototype.hasOwnProperty.call(value, key);
}
const WRITE_PRUNED_OBJECT = Symbol("write-pruned-object");
function unsetPathForWriteAt(value, pathSegments, depth) {
if (depth >= pathSegments.length) return {
changed: false,
value
};
const segment = pathSegments[depth];
const isLeaf = depth === pathSegments.length - 1;
if (Array.isArray(value)) {
if (!isNumericPathSegment(segment)) return {
changed: false,
value
};
const index = Number.parseInt(segment, 10);
if (!Number.isFinite(index) || index < 0 || index >= value.length) return {
changed: false,
value
};
if (isLeaf) {
const next = value.slice();
next.splice(index, 1);
return {
changed: true,
value: next
};
}
const child = unsetPathForWriteAt(value[index], pathSegments, depth + 1);
if (!child.changed) return {
changed: false,
value
};
const next = value.slice();
if (child.value === WRITE_PRUNED_OBJECT) next.splice(index, 1);
else next[index] = child.value;
return {
changed: true,
value: next
};
}
if (isBlockedObjectKey(segment) || !isWritePlainObject(value) || !hasOwnObjectKey(value, segment)) return {
changed: false,
value
};
if (isLeaf) {
const next = { ...value };
delete next[segment];
return {
changed: true,
value: Object.keys(next).length === 0 ? WRITE_PRUNED_OBJECT : next
};
}
const child = unsetPathForWriteAt(value[segment], pathSegments, depth + 1);
if (!child.changed) return {
changed: false,
value
};
const next = { ...value };
if (child.value === WRITE_PRUNED_OBJECT) delete next[segment];
else next[segment] = child.value;
return {
changed: true,
value: Object.keys(next).length === 0 ? WRITE_PRUNED_OBJECT : next
};
}
function unsetPathForWrite(root, pathSegments) {
if (pathSegments.length === 0) return {
changed: false,
next: root
};
const result = unsetPathForWriteAt(root, pathSegments, 0);
if (!result.changed) return {
changed: false,
next: root
};
if (result.value === WRITE_PRUNED_OBJECT) return {
changed: true,
next: {}
};
if (isWritePlainObject(result.value)) return {
changed: true,
next: coerceConfig(result.value)
};
return {
changed: false,
next: root
};
}
function resolveConfigSnapshotHash(snapshot) {
if (typeof snapshot.hash === "string") {
const trimmed = snapshot.hash.trim();
if (trimmed) return trimmed;
}
if (typeof snapshot.raw !== "string") return null;
return hashConfigRaw(snapshot.raw);
}
function coerceConfig(value) {
if (!value || typeof value !== "object" || Array.isArray(value)) return {};
return value;
}
function isPlainObject(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function hasConfigMeta(value) {
if (!isPlainObject(value)) return false;
const meta = value.meta;
return isPlainObject(meta);
}
function resolveGatewayMode(value) {
if (!isPlainObject(value)) return null;
const gateway = value.gateway;
if (!isPlainObject(gateway) || typeof gateway.mode !== "string") return null;
const trimmed = gateway.mode.trim();
return trimmed.length > 0 ? trimmed : null;
}
function cloneUnknown(value) {
return structuredClone(value);
}
function createMergePatch(base, target) {
if (!isPlainObject(base) || !isPlainObject(target)) return cloneUnknown(target);
const patch = {};
const keys = new Set([...Object.keys(base), ...Object.keys(target)]);
for (const key of keys) {
const hasBase = key in base;
if (!(key in target)) {
patch[key] = null;
continue;
}
const targetValue = target[key];
if (!hasBase) {
patch[key] = cloneUnknown(targetValue);
continue;
}
const baseValue = base[key];
if (isPlainObject(baseValue) && isPlainObject(targetValue)) {
const childPatch = createMergePatch(baseValue, targetValue);
if (isPlainObject(childPatch) && Object.keys(childPatch).length === 0) continue;
patch[key] = childPatch;
continue;
}
if (!isDeepStrictEqual(baseValue, targetValue)) patch[key] = cloneUnknown(targetValue);
}
return patch;
}
function collectEnvRefPaths(value, path, output) {
if (typeof value === "string") {
if (containsEnvVarReference(value)) output.set(path, value);
return;
}
if (Array.isArray(value)) {
value.forEach((item, index) => {
collectEnvRefPaths(item, `${path}[${index}]`, output);
});
return;
}
if (isPlainObject(value)) for (const [key, child] of Object.entries(value)) collectEnvRefPaths(child, path ? `${path}.${key}` : key, output);
}
function collectChangedPaths(base, target, path, output) {
if (Array.isArray(base) && Array.isArray(target)) {
const max = Math.max(base.length, target.length);
for (let index = 0; index < max; index += 1) {
const childPath = path ? `${path}[${index}]` : `[${index}]`;
if (index >= base.length || index >= target.length) {
output.add(childPath);
continue;
}
collectChangedPaths(base[index], target[index], childPath, output);
}
return;
}
if (isPlainObject(base) && isPlainObject(target)) {
const keys = new Set([...Object.keys(base), ...Object.keys(target)]);
for (const key of keys) {
const childPath = path ? `${path}.${key}` : key;
const hasBase = key in base;
if (!(key in target) || !hasBase) {
output.add(childPath);
continue;
}
collectChangedPaths(base[key], target[key], childPath, output);
}
return;
}
if (!isDeepStrictEqual(base, target)) output.add(path);
}
function parentPath(value) {
if (!value) return "";
if (value.endsWith("]")) {
const index = value.lastIndexOf("[");
return index > 0 ? value.slice(0, index) : "";
}
const index = value.lastIndexOf(".");
return index >= 0 ? value.slice(0, index) : "";
}
function isPathChanged(path, changedPaths) {
if (changedPaths.has(path)) return true;
let current = parentPath(path);
while (current) {
if (changedPaths.has(current)) return true;
current = parentPath(current);
}
return changedPaths.has("");
}
function restoreEnvRefsFromMap(value, path, envRefMap, changedPaths) {
if (typeof value === "string") {
if (!isPathChanged(path, changedPaths)) {
const original = envRefMap.get(path);
if (original !== void 0) return original;
}
return value;
}
if (Array.isArray(value)) {
let changed = false;
const next = value.map((item, index) => {
const updated = restoreEnvRefsFromMap(item, `${path}[${index}]`, envRefMap, changedPaths);
if (updated !== item) changed = true;
return updated;
});
return changed ? next : value;
}
if (isPlainObject(value)) {
let changed = false;
const next = {};
for (const [key, child] of Object.entries(value)) {
const updated = restoreEnvRefsFromMap(child, path ? `${path}.${key}` : key, envRefMap, changedPaths);
if (updated !== child) changed = true;
next[key] = updated;
}
return changed ? next : value;
}
return value;
}
function resolveConfigAuditLogPath(env, homedir) {
return path.join(resolveStateDir(env, homedir), "logs", CONFIG_AUDIT_LOG_FILENAME);
}
function resolveConfigWriteSuspiciousReasons(params) {
const reasons = [];
if (!params.existsBefore) return reasons;
if (typeof params.previousBytes === "number" && typeof params.nextBytes === "number" && params.previousBytes >= 512 && params.nextBytes < Math.floor(params.previousBytes * .5)) reasons.push(`size-drop:${params.previousBytes}->${params.nextBytes}`);
if (!params.hasMetaBefore) reasons.push("missing-meta-before-write");
if (params.gatewayModeBefore && !params.gatewayModeAfter) reasons.push("gateway-mode-removed");
return reasons;
}
async function appendConfigWriteAuditRecord(deps, record) {
try {
const auditPath = resolveConfigAuditLogPath(deps.env, deps.homedir);
await deps.fs.promises.mkdir(path.dirname(auditPath), {
recursive: true,
mode: 448
});
await deps.fs.promises.appendFile(auditPath, `${JSON.stringify(record)}\n`, {
encoding: "utf-8",
mode: 384
});
} catch {}
}
function warnOnConfigMiskeys(raw, logger) {
if (!raw || typeof raw !== "object") return;
const gateway = raw.gateway;
if (!gateway || typeof gateway !== "object") return;
if ("token" in gateway) logger.warn("Config uses \"gateway.token\". This key is ignored; use \"gateway.auth.token\" instead.");
}
function stampConfigVersion(cfg) {
const now = (/* @__PURE__ */ new Date()).toISOString();
return {
...cfg,
meta: {
...cfg.meta,
lastTouchedVersion: VERSION,
lastTouchedAt: now
}
};
}
function warnIfConfigFromFuture(cfg, logger) {
const touched = cfg.meta?.lastTouchedVersion;
if (!touched) return;
const cmp = compareOpenClawVersions(VERSION, touched);
if (cmp === null) return;
if (cmp < 0) logger.warn(`Config was last written by a newer OpenClaw (${touched}); current version is ${VERSION}.`);
}
function resolveConfigPathForDeps(deps) {
if (deps.configPath) return deps.configPath;
return resolveConfigPath(deps.env, resolveStateDir(deps.env, deps.homedir));
}
function normalizeDeps(overrides = {}) {
return {
fs: overrides.fs ?? fs,
json5: overrides.json5 ?? JSON5,
env: overrides.env ?? process.env,
homedir: overrides.homedir ?? (() => resolveRequiredHomeDir(overrides.env ?? process.env, os.homedir)),
configPath: overrides.configPath ?? "",
logger: overrides.logger ?? console
};
}
function maybeLoadDotEnvForConfig(env) {
if (env !== process.env) return;
loadDotEnv({ quiet: true });
}
function parseConfigJson5(raw, json5 = JSON5) {
try {
return {
ok: true,
parsed: json5.parse(raw)
};
} catch (err) {
return {
ok: false,
error: String(err)
};
}
}
function resolveConfigIncludesForRead(parsed, configPath, deps) {
return resolveConfigIncludes(parsed, configPath, {
readFile: (candidate) => deps.fs.readFileSync(candidate, "utf-8"),
parseJson: (raw) => deps.json5.parse(raw)
});
}
function resolveConfigForRead(resolvedIncludes, env) {
if (resolvedIncludes && typeof resolvedIncludes === "object" && "env" in resolvedIncludes) applyConfigEnvVars(resolvedIncludes, env);
return {
resolvedConfigRaw: resolveConfigEnvVars(resolvedIncludes, env),
envSnapshotForRestore: { ...env }
};
}
function createConfigIO(overrides = {}) {
const deps = normalizeDeps(overrides);
const requestedConfigPath = resolveConfigPathForDeps(deps);
const configPath = (deps.configPath ? [requestedConfigPath] : resolveDefaultConfigCandidates(deps.env, deps.homedir)).find((candidate) => deps.fs.existsSync(candidate)) ?? requestedConfigPath;
function loadConfig() {
try {
maybeLoadDotEnvForConfig(deps.env);
if (!deps.fs.existsSync(configPath)) {
if (shouldEnableShellEnvFallback(deps.env) && !shouldDeferShellEnvFallback(deps.env)) loadShellEnvFallback({
enabled: true,
env: deps.env,
expectedKeys: SHELL_ENV_EXPECTED_KEYS,
logger: deps.logger,
timeoutMs: resolveShellEnvFallbackTimeoutMs(deps.env)
});
return {};
}
const raw = deps.fs.readFileSync(configPath, "utf-8");
const { resolvedConfigRaw: resolvedConfig } = resolveConfigForRead(resolveConfigIncludesForRead(deps.json5.parse(raw), configPath, deps), deps.env);
warnOnConfigMiskeys(resolvedConfig, deps.logger);
if (typeof resolvedConfig !== "object" || resolvedConfig === null) return {};
const preValidationDuplicates = findDuplicateAgentDirs(resolvedConfig, {
env: deps.env,
homedir: deps.homedir
});
if (preValidationDuplicates.length > 0) throw new DuplicateAgentDirError(preValidationDuplicates);
const validated = validateConfigObjectWithPlugins(resolvedConfig);
if (!validated.ok) {
const details = validated.issues.map((iss) => `- ${iss.path || "<root>"}: ${iss.message}`).join("\n");
if (!loggedInvalidConfigs.has(configPath)) {
loggedInvalidConfigs.add(configPath);
deps.logger.error(`Invalid config at ${configPath}:\\n${details}`);
}
const error = /* @__PURE__ */ new Error("Invalid config");
error.code = "INVALID_CONFIG";
error.details = details;
throw error;
}
if (validated.warnings.length > 0) {
const details = validated.warnings.map((iss) => `- ${iss.path || "<root>"}: ${iss.message}`).join("\n");
deps.logger.warn(`Config warnings:\\n${details}`);
}
warnIfConfigFromFuture(validated.config, deps.logger);
const cfg = applyTalkConfigNormalization(applyModelDefaults(applyCompactionDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyLoggingDefaults(applyMessageDefaults(validated.config))))))));
normalizeConfigPaths(cfg);
normalizeExecSafeBinProfilesInConfig(cfg);
const duplicates = findDuplicateAgentDirs(cfg, {
env: deps.env,
homedir: deps.homedir
});
if (duplicates.length > 0) throw new DuplicateAgentDirError(duplicates);
applyConfigEnvVars(cfg, deps.env);
if ((shouldEnableShellEnvFallback(deps.env) || cfg.env?.shellEnv?.enabled === true) && !shouldDeferShellEnvFallback(deps.env)) loadShellEnvFallback({
enabled: true,
env: deps.env,
expectedKeys: SHELL_ENV_EXPECTED_KEYS,
logger: deps.logger,
timeoutMs: cfg.env?.shellEnv?.timeoutMs ?? resolveShellEnvFallbackTimeoutMs(deps.env)
});
const pendingSecret = AUTO_OWNER_DISPLAY_SECRET_BY_PATH.get(configPath);
const ownerDisplaySecretResolution = ensureOwnerDisplaySecret(cfg, () => pendingSecret ?? crypto.randomBytes(32).toString("hex"));
const cfgWithOwnerDisplaySecret = ownerDisplaySecretResolution.config;
if (ownerDisplaySecretResolution.generatedSecret) {
AUTO_OWNER_DISPLAY_SECRET_BY_PATH.set(configPath, ownerDisplaySecretResolution.generatedSecret);
if (!AUTO_OWNER_DISPLAY_SECRET_PERSIST_IN_FLIGHT.has(configPath)) {
AUTO_OWNER_DISPLAY_SECRET_PERSIST_IN_FLIGHT.add(configPath);
writeConfigFile(cfgWithOwnerDisplaySecret, { expectedConfigPath: configPath }).then(() => {
AUTO_OWNER_DISPLAY_SECRET_BY_PATH.delete(configPath);
AUTO_OWNER_DISPLAY_SECRET_PERSIST_WARNED.delete(configPath);
}).catch((err) => {
if (!AUTO_OWNER_DISPLAY_SECRET_PERSIST_WARNED.has(configPath)) {
AUTO_OWNER_DISPLAY_SECRET_PERSIST_WARNED.add(configPath);
deps.logger.warn(`Failed to persist auto-generated commands.ownerDisplaySecret at ${configPath}: ${String(err)}`);
}
}).finally(() => {
AUTO_OWNER_DISPLAY_SECRET_PERSIST_IN_FLIGHT.delete(configPath);
});
}
} else {
AUTO_OWNER_DISPLAY_SECRET_BY_PATH.delete(configPath);
AUTO_OWNER_DISPLAY_SECRET_PERSIST_WARNED.delete(configPath);
}
return applyConfigOverrides(cfgWithOwnerDisplaySecret);
} catch (err) {
if (err instanceof DuplicateAgentDirError) {
deps.logger.error(err.message);
throw err;
}
if (err?.code === "INVALID_CONFIG") return {};
deps.logger.error(`Failed to read config at ${configPath}`, err);
return {};
}
}
async function readConfigFileSnapshotInternal() {
maybeLoadDotEnvForConfig(deps.env);
if (!deps.fs.existsSync(configPath)) {
const hash = hashConfigRaw(null);
return { snapshot: {
path: configPath,
exists: false,
raw: null,
parsed: {},
resolved: {},
valid: true,
config: applyTalkApiKey(applyTalkConfigNormalization(applyModelDefaults(applyCompactionDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyMessageDefaults({})))))))),
hash,
issues: [],
warnings: [],
legacyIssues: []
} };
}
try {
const raw = deps.fs.readFileSync(configPath, "utf-8");
const hash = hashConfigRaw(raw);
const parsedRes = parseConfigJson5(raw, deps.json5);
if (!parsedRes.ok) return { snapshot: {
path: configPath,
exists: true,
raw,
parsed: {},
resolved: {},
valid: false,
config: {},
hash,
issues: [{
path: "",
message: `JSON5 parse failed: ${parsedRes.error}`
}],
warnings: [],
legacyIssues: []
} };
let resolved;
try {
resolved = resolveConfigIncludesForRead(parsedRes.parsed, configPath, deps);
} catch (err) {
const message = err instanceof ConfigIncludeError ? err.message : `Include resolution failed: ${String(err)}`;
return { snapshot: {
path: configPath,
exists: true,
raw,
parsed: parsedRes.parsed,
resolved: coerceConfig(parsedRes.parsed),
valid: false,
config: coerceConfig(parsedRes.parsed),
hash,
issues: [{
path: "",
message
}],
warnings: [],
legacyIssues: []
} };
}
let readResolution;
try {
readResolution = resolveConfigForRead(resolved, deps.env);
} catch (err) {
const message = err instanceof MissingEnvVarError ? err.message : `Env var substitution failed: ${String(err)}`;
return { snapshot: {
path: configPath,
exists: true,
raw,
parsed: parsedRes.parsed,
resolved: coerceConfig(resolved),
valid: false,
config: coerceConfig(resolved),
hash,
issues: [{
path: "",
message
}],
warnings: [],
legacyIssues: []
} };
}
const resolvedConfigRaw = readResolution.resolvedConfigRaw;
const legacyIssues = findLegacyConfigIssues(resolvedConfigRaw);
const validated = validateConfigObjectWithPlugins(resolvedConfigRaw);
if (!validated.ok) return { snapshot: {
path: configPath,
exists: true,
raw,
parsed: parsedRes.parsed,
resolved: coerceConfig(resolvedConfigRaw),
valid: false,
config: coerceConfig(resolvedConfigRaw),
hash,
issues: validated.issues,
warnings: validated.warnings,
legacyIssues
} };
warnIfConfigFromFuture(validated.config, deps.logger);
const snapshotConfig = normalizeConfigPaths(applyTalkApiKey(applyTalkConfigNormalization(applyModelDefaults(applyAgentDefaults(applySessionDefaults(applyLoggingDefaults(applyMessageDefaults(validated.config))))))));
normalizeExecSafeBinProfilesInConfig(snapshotConfig);
return {
snapshot: {
path: configPath,
exists: true,
raw,
parsed: parsedRes.parsed,
resolved: coerceConfig(resolvedConfigRaw),
valid: true,
config: snapshotConfig,
hash,
issues: [],
warnings: validated.warnings,
legacyIssues
},
envSnapshotForRestore: readResolution.envSnapshotForRestore
};
} catch (err) {
const nodeErr = err;
let message;
if (nodeErr?.code === "EACCES") {
const uid = process.getuid?.();
const uidHint = typeof uid === "number" ? String(uid) : "$(id -u)";
message = [
`read failed: ${String(err)}`,
``,
`Config file is not readable by the current process. If running in a container`,
`or 1-click deployment, fix ownership with:`,
` chown ${uidHint} "${configPath}"`,
`Then restart the gateway.`
].join("\n");
deps.logger.error(message);
} else message = `read failed: ${String(err)}`;
return { snapshot: {
path: configPath,
exists: true,
raw: null,
parsed: {},
resolved: {},
valid: false,
config: {},
hash: hashConfigRaw(null),
issues: [{
path: "",
message
}],
warnings: [],
legacyIssues: []
} };
}
}
async function readConfigFileSnapshot() {
return (await readConfigFileSnapshotInternal()).snapshot;
}
async function readConfigFileSnapshotForWrite() {
const result = await readConfigFileSnapshotInternal();
return {
snapshot: result.snapshot,
writeOptions: {
envSnapshotForRestore: result.envSnapshotForRestore,
expectedConfigPath: configPath
}
};
}
async function writeConfigFile(cfg, options = {}) {
clearConfigCache();
let persistCandidate = cfg;
const { snapshot } = await readConfigFileSnapshotInternal();
let envRefMap = null;
let changedPaths = null;
if (snapshot.valid && snapshot.exists) {
const patch = createMergePatch(snapshot.config, cfg);
persistCandidate = applyMergePatch(snapshot.resolved, patch);
try {
const resolvedIncludes = resolveConfigIncludes(snapshot.parsed, configPath, {
readFile: (candidate) => deps.fs.readFileSync(candidate, "utf-8"),
parseJson: (raw) => deps.json5.parse(raw)
});
const collected = /* @__PURE__ */ new Map();
collectEnvRefPaths(resolvedIncludes, "", collected);
if (collected.size > 0) {
envRefMap = collected;
changedPaths = /* @__PURE__ */ new Set();
collectChangedPaths(snapshot.config, cfg, "", changedPaths);
}
} catch {
envRefMap = null;
}
}
const validated = validateConfigObjectRawWithPlugins(persistCandidate);
if (!validated.ok) {
const issue = validated.issues[0];
const pathLabel = issue?.path ? issue.path : "<root>";
const issueMessage = issue?.message ?? "invalid";
throw new Error(formatConfigValidationFailure(pathLabel, issueMessage));
}
if (validated.warnings.length > 0) {
const details = validated.warnings.map((warning) => `- ${warning.path}: ${warning.message}`).join("\n");
deps.logger.warn(`Config warnings:\n${details}`);
}
let cfgToWrite = validated.config;
try {
if (deps.fs.existsSync(configPath)) {
const parsedRes = parseConfigJson5(await deps.fs.promises.readFile(configPath, "utf-8"), deps.json5);
if (parsedRes.ok) {
const envForRestore = options.envSnapshotForRestore ?? deps.env;
cfgToWrite = restoreEnvVarRefs(cfgToWrite, parsedRes.parsed, envForRestore);
}
}
} catch {}
const dir = path.dirname(configPath);
await deps.fs.promises.mkdir(dir, {
recursive: true,
mode: 448
});
let outputConfig = envRefMap && changedPaths ? restoreEnvRefsFromMap(cfgToWrite, "", envRefMap, changedPaths) : cfgToWrite;
if (options.unsetPaths?.length) for (const unsetPath of options.unsetPaths) {
if (!Array.isArray(unsetPath) || unsetPath.length === 0) continue;
const unsetResult = unsetPathForWrite(outputConfig, unsetPath);
if (unsetResult.changed) outputConfig = unsetResult.next;
}
const stampedOutputConfig = stampConfigVersion(outputConfig);
const json = JSON.stringify(stampedOutputConfig, null, 2).trimEnd().concat("\n");
const nextHash = hashConfigRaw(json);
const previousHash = resolveConfigSnapshotHash(snapshot);
const changedPathCount = changedPaths?.size;
const previousBytes = typeof snapshot.raw === "string" ? Buffer.byteLength(snapshot.raw, "utf-8") : null;
const nextBytes = Buffer.byteLength(json, "utf-8");
const hasMetaBefore = hasConfigMeta(snapshot.parsed);
const hasMetaAfter = hasConfigMeta(stampedOutputConfig);
const gatewayModeBefore = resolveGatewayMode(snapshot.resolved);
const gatewayModeAfter = resolveGatewayMode(stampedOutputConfig);
const suspiciousReasons = resolveConfigWriteSuspiciousReasons({
existsBefore: snapshot.exists,
previousBytes,
nextBytes,
hasMetaBefore,
gatewayModeBefore,
gatewayModeAfter
});
const logConfigOverwrite = () => {
if (!snapshot.exists) return;
const isVitest = deps.env.VITEST === "true";
const shouldLogInVitest = deps.env.OPENCLAW_TEST_CONFIG_OVERWRITE_LOG === "1";
if (isVitest && !shouldLogInVitest) return;
const changeSummary = typeof changedPathCount === "number" ? `, changedPaths=${changedPathCount}` : "";
deps.logger.warn(`Config overwrite: ${configPath} (sha256 ${previousHash ?? "unknown"} -> ${nextHash}, backup=${configPath}.bak${changeSummary})`);
};
const logConfigWriteAnomalies = () => {
if (suspiciousReasons.length === 0) return;
const isVitest = deps.env.VITEST === "true";
const shouldLogInVitest = deps.env.OPENCLAW_TEST_CONFIG_WRITE_ANOMALY_LOG === "1";
if (isVitest && !shouldLogInVitest) return;
deps.logger.warn(`Config write anomaly: ${configPath} (${suspiciousReasons.join(", ")})`);
};
const auditRecordBase = {
ts: (/* @__PURE__ */ new Date()).toISOString(),
source: "config-io",
event: "config.write",
configPath,
pid: process.pid,
ppid: process.ppid,
cwd: process.cwd(),
argv: process.argv.slice(0, 8),
execArgv: process.execArgv.slice(0, 8),
watchMode: deps.env.OPENCLAW_WATCH_MODE === "1",
watchSession: typeof deps.env.OPENCLAW_WATCH_SESSION === "string" && deps.env.OPENCLAW_WATCH_SESSION.trim().length > 0 ? deps.env.OPENCLAW_WATCH_SESSION.trim() : null,
watchCommand: typeof deps.env.OPENCLAW_WATCH_COMMAND === "string" && deps.env.OPENCLAW_WATCH_COMMAND.trim().length > 0 ? deps.env.OPENCLAW_WATCH_COMMAND.trim() : null,
existsBefore: snapshot.exists,
previousHash: previousHash ?? null,
nextHash,
previousBytes,
nextBytes,
changedPathCount: typeof changedPathCount === "number" ? changedPathCount : null,
hasMetaBefore,
hasMetaAfter,
gatewayModeBefore,
gatewayModeAfter,
suspicious: suspiciousReasons
};
const appendWriteAudit = async (result, err) => {
const errorCode = err && typeof err === "object" && "code" in err && typeof err.code === "string" ? err.code : void 0;
const errorMessage = err && typeof err === "object" && "message" in err && typeof err.message === "string" ? err.message : void 0;
await appendConfigWriteAuditRecord(deps, {
...auditRecordBase,
result,
nextHash: result === "failed" ? null : auditRecordBase.nextHash,
nextBytes: result === "failed" ? null : auditRecordBase.nextBytes,
errorCode,
errorMessage
});
};
const tmp = path.join(dir, `${path.basename(configPath)}.${process.pid}.${crypto.randomUUID()}.tmp`);
try {
await deps.fs.promises.writeFile(tmp, json, {
encoding: "utf-8",
mode: 384
});
if (deps.fs.existsSync(configPath)) {
await rotateConfigBackups(configPath, deps.fs.promises);
await deps.fs.promises.copyFile(configPath, `${configPath}.bak`).catch(() => {});
}
try {
await deps.fs.promises.rename(tmp, configPath);
} catch (err) {
const code = err.code;
if (code === "EPERM" || code === "EEXIST") {
await deps.fs.promises.copyFile(tmp, configPath);
await deps.fs.promises.chmod(configPath, 384).catch(() => {});
await deps.fs.promises.unlink(tmp).catch(() => {});
logConfigOverwrite();
logConfigWriteAnomalies();
await appendWriteAudit("copy-fallback");
return;
}
await deps.fs.promises.unlink(tmp).catch(() => {});
throw err;
}
logConfigOverwrite();
logConfigWriteAnomalies();
await appendWriteAudit("rename");
} catch (err) {
await appendWriteAudit("failed", err);
throw err;
}
}
return {
configPath,
loadConfig,
readConfigFileSnapshot,
readConfigFileSnapshotForWrite,
writeConfigFile
};
}
const DEFAULT_CONFIG_CACHE_MS = 200;
const AUTO_OWNER_DISPLAY_SECRET_BY_PATH = /* @__PURE__ */ new Map();
const AUTO_OWNER_DISPLAY_SECRET_PERSIST_IN_FLIGHT = /* @__PURE__ */ new Set();
const AUTO_OWNER_DISPLAY_SECRET_PERSIST_WARNED = /* @__PURE__ */ new Set();
let configCache = null;
function resolveConfigCacheMs(env) {
const raw = env.OPENCLAW_CONFIG_CACHE_MS?.trim();
if (raw === "" || raw === "0") return 0;
if (!raw) return DEFAULT_CONFIG_CACHE_MS;
const parsed = Number.parseInt(raw, 10);
if (!Number.isFinite(parsed)) return DEFAULT_CONFIG_CACHE_MS;
return Math.max(0, parsed);
}
function shouldUseConfigCache(env) {
if (env.OPENCLAW_DISABLE_CONFIG_CACHE?.trim()) return false;
return resolveConfigCacheMs(env) > 0;
}
function clearConfigCache() {
configCache = null;
}
function loadConfig() {
const io = createConfigIO();
const configPath = io.configPath;
const now = Date.now();
if (shouldUseConfigCache(process.env)) {
const cached = configCache;
if (cached && cached.configPath === configPath && cached.expiresAt > now) return cached.config;
}
const config = io.loadConfig();
if (shouldUseConfigCache(process.env)) {
const cacheMs = resolveConfigCacheMs(process.env);
if (cacheMs > 0) configCache = {
configPath,
expiresAt: now + cacheMs,
config
};
}
return config;
}
async function readConfigFileSnapshot() {
return await createConfigIO().readConfigFileSnapshot();
}
async function readConfigFileSnapshotForWrite() {
return await createConfigIO().readConfigFileSnapshotForWrite();
}
async function writeConfigFile(cfg, options = {}) {
const io = createConfigIO();
const sameConfigPath = options.expectedConfigPath === void 0 || options.expectedConfigPath === io.configPath;
await io.writeConfigFile(cfg, {
envSnapshotForRestore: sameConfigPath ? options.envSnapshotForRestore : void 0,
unsetPaths: options.unsetPaths
});
}
//#endregion
//#region src/config/legacy-migrate.ts
function migrateLegacyConfig(raw) {
const { next, changes } = applyLegacyMigrations(raw);
if (!next) return {
config: null,
changes: []
};
const validated = validateConfigObjectWithPlugins(next);
if (!validated.ok) {
changes.push("Migration applied, but config still invalid; fix remaining issues manually.");
return {
config: null,
changes
};
}
return {
config: validated.config,
changes
};
}
//#endregion
//#region src/config/config.ts
var config_exports = /* @__PURE__ */ __exportAll({
CONFIG_PATH: () => CONFIG_PATH,
DEFAULT_GATEWAY_PORT: () => DEFAULT_GATEWAY_PORT,
STATE_DIR: () => STATE_DIR,
TOOLS_BY_SENDER_KEY_TYPES: () => TOOLS_BY_SENDER_KEY_TYPES,
applyConfigOverrides: () => applyConfigOverrides,
getConfigOverrides: () => getConfigOverrides,
isNixMode: () => isNixMode,
loadConfig: () => loadConfig,
parseToolsBySenderTypedKey: () => parseToolsBySenderTypedKey,
resetConfigOverrides: () => resetConfigOverrides,
resolveCanonicalConfigPath: () => resolveCanonicalConfigPath,
resolveConfigPath: () => resolveConfigPath,
resolveConfigPathCandidate: () => resolveConfigPathCandidate,
resolveDefaultConfigCandidates: () => resolveDefaultConfigCandidates,
resolveGatewayLockDir: () => resolveGatewayLockDir,
resolveGatewayPort: () => resolveGatewayPort,
resolveIsNixMode: () => resolveIsNixMode,
resolveLegacyStateDirs: () => resolveLegacyStateDirs,
resolveNewStateDir: () => resolveNewStateDir,
resolveOAuthDir: () => resolveOAuthDir,
resolveOAuthPath: () => resolveOAuthPath,
resolveStateDir: () => resolveStateDir,
setConfigOverride: () => setConfigOverride,
unsetConfigOverride: () => unsetConfigOverride
});
//#endregion
export { isWindowsPlatform as $, isAvatarImageDataUrl as A, resolveAgentMaxConcurrent as At, unsetConfigOverride as B, isDangerousNetworkMode as C, resolveSlackNativeStreaming as Ct, AVATAR_MAX_BYTES as D, MAX_INCLUDE_DEPTH as Dt, parseByteSize as E, INCLUDE_KEY as Et, resolveAvatarMime as F, getTrustedSafeBinDirs as G, parseConfigPath as H, validateJsonSchemaValue as I, normalizeTrustedSafeBinDirs as J, isTrustedSafeBinPath as K, getConfigOverrides as L, isSupportedLocalAvatarExtension as M, loadDotEnv as Mt, isWorkspaceRelativeAvatarPath as N, resolveOwnerDisplaySetting as Nt, isAvatarDataUrl as O, buildTalkConfigResponse as Ot, looksLikeAvatarPath as P, buildEnforcedShellCommand as Q, resetConfigOverrides as R, getBlockedNetworkModeReason as S, resolveDiscordPreviewStreamMode as St, parseDurationMs as T, resolveTelegramPreviewStreamMode as Tt, setConfigValueAtPath as U, getConfigValueAtPath as V, unsetConfigValueAtPath as W, analyzeArgvCommand as X, validateSafeBinArgv as Y, analyzeShellCommand as Z, mergeInboundPathRoots as _, resolveSafeBinProfiles as _t, parseConfigJson5 as a, extractShellWrapperCommand as at, normalizeScpRemoteHost as b, isSafeExecutableValue as bt, resolveConfigSnapshotHash as c, isDispatchWrapperExecutable as ct, OpenClawSchema as d, unwrapDispatchWrappersForResolution as dt, splitCommandChain as et, TELEGRAM_COMMAND_NAME_PATTERN as f, unwrapKnownDispatchWrapperInvocation as ft, isInboundPathAllowed as g, normalizeSafeBinProfileFixtures as gt, DEFAULT_IMESSAGE_ATTACHMENT_ROOTS as h, SAFE_BIN_PROFILES as ht, loadConfig as i, resolveCommandResolutionFromArgv as it, isPathWithinRoot as j, resolveSubagentMaxConcurrent as jt, isAvatarHttpUrl as k, DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH as kt, writeConfigFile as l, isShellWrapperExecutable as lt, resolveTelegramCustomCommands as m, splitShellArgs as mt, migrateLegacyConfig as n, matchAllowlist as nt, readConfigFileSnapshot as o, extractShellWrapperInlineCommand as ot, normalizeTelegramCommandName as p, unwrapKnownShellMultiplexerInvocation as pt, listWritableExplicitTrustedSafeBinDirs as q, createConfigIO as r, resolveAllowlistCandidatePath as rt, readConfigFileSnapshotForWrite as s, hasEnvManipulationBeforeShellWrapper as st, config_exports as t, DEFAULT_SAFE_BINS as tt, validateConfigObjectWithPlugins as u, normalizeExecutableToken as ut, resolveIMessageAttachmentRoots as v, applyMergePatch as vt, normalizeNetworkMode as w, resolveSlackStreamingMode as wt, sensitive as x, mapStreamingModeToSlackLegacyDraftStreamMode as xt, resolveIMessageRemoteAttachmentRoots as y, applyLegacyMigrations as yt, setConfigOverride as z };