@spacebar_ai/moldclaw-core 2026.3.14 → 2026.3.16

package/dist/types.base-B_TkkSS8.d.ts

@@ -0,0 +1,188 @@
+import { t as ChatType } from "./chat-type-BlSN0vo4.js";
+
+//#region src/config/types.base.d.ts
+type ReplyMode = "text" | "command";
+type TypingMode = "never" | "instant" | "thinking" | "message";
+type SessionScope = "per-sender" | "global";
+type DmScope = "main" | "per-peer" | "per-channel-peer" | "per-account-channel-peer";
+type ReplyToMode = "off" | "first" | "all";
+type GroupPolicy = "open" | "disabled" | "allowlist";
+type DmPolicy = "pairing" | "allowlist" | "open" | "disabled";
+type OutboundRetryConfig = {
+  /** Max retry attempts for outbound requests (default: 3). */attempts?: number; /** Minimum retry delay in ms (default: 300-500ms depending on provider). */
+  minDelayMs?: number; /** Maximum retry delay cap in ms (default: 30000). */
+  maxDelayMs?: number; /** Jitter factor (0-1) applied to delays (default: 0.1). */
+  jitter?: number;
+};
+type BlockStreamingCoalesceConfig = {
+  minChars?: number;
+  maxChars?: number;
+  idleMs?: number;
+};
+type BlockStreamingChunkConfig = {
+  minChars?: number;
+  maxChars?: number;
+  breakPreference?: "paragraph" | "newline" | "sentence";
+};
+type MarkdownTableMode = "off" | "bullets" | "code";
+type MarkdownConfig = {
+  /** Table rendering mode (off|bullets|code). */tables?: MarkdownTableMode;
+};
+type HumanDelayConfig = {
+  /** Delay style for block replies (off|natural|custom). */mode?: "off" | "natural" | "custom"; /** Minimum delay in milliseconds (default: 800). */
+  minMs?: number; /** Maximum delay in milliseconds (default: 2500). */
+  maxMs?: number;
+};
+type SessionSendPolicyAction = "allow" | "deny";
+type SessionSendPolicyMatch = {
+  channel?: string;
+  chatType?: ChatType;
+  /**
+   * Session key prefix match.
+   * Note: some consumers match against a normalized key (for example, stripping `agent:<id>:`).
+   */
+  keyPrefix?: string; /** Optional raw session-key prefix match for consumers that normalize session keys. */
+  rawKeyPrefix?: string;
+};
+type SessionSendPolicyRule = {
+  action: SessionSendPolicyAction;
+  match?: SessionSendPolicyMatch;
+};
+type SessionSendPolicyConfig = {
+  default?: SessionSendPolicyAction;
+  rules?: SessionSendPolicyRule[];
+};
+type SessionResetMode = "daily" | "idle";
+type SessionResetConfig = {
+  mode?: SessionResetMode; /** Local hour (0-23) for the daily reset boundary. */
+  atHour?: number; /** Sliding idle window (minutes). When set with daily mode, whichever expires first wins. */
+  idleMinutes?: number;
+};
+type SessionResetByTypeConfig = {
+  direct?: SessionResetConfig; /** @deprecated Use `direct` instead. Kept for backward compatibility. */
+  dm?: SessionResetConfig;
+  group?: SessionResetConfig;
+  thread?: SessionResetConfig;
+};
+type SessionThreadBindingsConfig = {
+  /**
+   * Master switch for thread-bound session routing features.
+   * Channel/provider keys can override this default.
+   */
+  enabled?: boolean;
+  /**
+   * Inactivity window for thread-bound sessions (hours).
+   * Session auto-unfocuses after this amount of idle time. Set to 0 to disable. Default: 24.
+   */
+  idleHours?: number;
+  /**
+   * Optional hard max age for thread-bound sessions (hours).
+   * Session auto-unfocuses once this age is reached even if active. Set to 0 to disable. Default: 0.
+   */
+  maxAgeHours?: number;
+};
+type SessionConfig = {
+  scope?: SessionScope; /** DM session scoping (default: "main"). */
+  dmScope?: DmScope; /** Map platform-prefixed identities (e.g. "telegram:123") to canonical DM peers. */
+  identityLinks?: Record<string, string[]>;
+  resetTriggers?: string[];
+  idleMinutes?: number;
+  reset?: SessionResetConfig;
+  resetByType?: SessionResetByTypeConfig; /** Channel-specific reset overrides (e.g. { discord: { mode: "idle", idleMinutes: 10080 } }). */
+  resetByChannel?: Record<string, SessionResetConfig>;
+  store?: string;
+  typingIntervalSeconds?: number;
+  typingMode?: TypingMode;
+  /**
+   * Max parent transcript token count allowed for thread/session forking.
+   * If parent totalTokens is above this value, moldClaw skips parent fork and
+   * starts a fresh thread session instead. Set to 0 to disable this guard.
+   */
+  parentForkMaxTokens?: number;
+  mainKey?: string;
+  sendPolicy?: SessionSendPolicyConfig;
+  agentToAgent?: {
+    /** Max ping-pong turns between requester/target (0–5). Default: 5. */maxPingPongTurns?: number;
+  }; /** Shared defaults for thread-bound session routing across channels/providers. */
+  threadBindings?: SessionThreadBindingsConfig; /** Automatic session store maintenance (pruning, capping, file rotation). */
+  maintenance?: SessionMaintenanceConfig;
+};
+type SessionMaintenanceMode = "enforce" | "warn";
+type SessionMaintenanceConfig = {
+  /** Whether to enforce maintenance or warn only. Default: "warn". */mode?: SessionMaintenanceMode; /** Remove session entries older than this duration (e.g. "30d", "12h"). Default: "30d". */
+  pruneAfter?: string | number; /** Deprecated. Use pruneAfter instead. */
+  pruneDays?: number; /** Maximum number of session entries to keep. Default: 500. */
+  maxEntries?: number; /** Rotate sessions.json when it exceeds this size (e.g. "10mb"). Default: 10mb. */
+  rotateBytes?: number | string;
+  /**
+   * Retention for archived reset transcripts (`*.reset.<timestamp>`).
+   * Set `false` to disable reset-archive cleanup. Default: same as `pruneAfter` (30d).
+   */
+  resetArchiveRetention?: string | number | false;
+  /**
+   * Optional per-agent sessions-directory disk budget (e.g. "500mb").
+   * When exceeded, warn (mode=warn) or enforce oldest-first cleanup (mode=enforce).
+   */
+  maxDiskBytes?: number | string;
+  /**
+   * Target size after disk-budget cleanup (high-water mark), e.g. "400mb".
+   * Default: 80% of maxDiskBytes.
+   */
+  highWaterBytes?: number | string;
+};
+type LoggingConfig = {
+  level?: "silent" | "fatal" | "error" | "warn" | "info" | "debug" | "trace";
+  file?: string; /** Maximum size of a single log file in bytes before writes are suppressed. Default: 500 MB. */
+  maxFileBytes?: number;
+  consoleLevel?: "silent" | "fatal" | "error" | "warn" | "info" | "debug" | "trace";
+  consoleStyle?: "pretty" | "compact" | "json"; /** Redact sensitive tokens in tool summaries. Default: "tools". */
+  redactSensitive?: "off" | "tools"; /** Regex patterns used to redact sensitive tokens (defaults apply when unset). */
+  redactPatterns?: string[];
+};
+type DiagnosticsOtelConfig = {
+  enabled?: boolean;
+  endpoint?: string;
+  protocol?: "http/protobuf" | "grpc";
+  headers?: Record<string, string>;
+  serviceName?: string;
+  traces?: boolean;
+  metrics?: boolean;
+  logs?: boolean; /** Trace sample rate (0.0 - 1.0). */
+  sampleRate?: number; /** Metric export interval (ms). */
+  flushIntervalMs?: number;
+};
+type DiagnosticsCacheTraceConfig = {
+  enabled?: boolean;
+  filePath?: string;
+  includeMessages?: boolean;
+  includePrompt?: boolean;
+  includeSystem?: boolean;
+};
+type DiagnosticsConfig = {
+  enabled?: boolean; /** Optional ad-hoc diagnostics flags (e.g. "telegram.http"). */
+  flags?: string[]; /** Threshold in ms before a processing session logs "stuck session" diagnostics. */
+  stuckSessionWarnMs?: number;
+  otel?: DiagnosticsOtelConfig;
+  cacheTrace?: DiagnosticsCacheTraceConfig;
+};
+type WebReconnectConfig = {
+  initialMs?: number;
+  maxMs?: number;
+  factor?: number;
+  jitter?: number;
+  maxAttempts?: number;
+};
+type WebConfig = {
+  /** If false, do not start the WhatsApp web provider. Default: true. */enabled?: boolean;
+  heartbeatSeconds?: number;
+  reconnect?: WebReconnectConfig;
+};
+type AgentElevatedAllowFromConfig = Partial<Record<string, Array<string | number>>>;
+type IdentityConfig = {
+  name?: string;
+  theme?: string;
+  emoji?: string; /** Avatar image: workspace-relative path, http(s) URL, or data URI. */
+  avatar?: string;
+};
+//#endregion
+export { WebReconnectConfig as A, SessionSendPolicyAction as C, SessionThreadBindingsConfig as D, SessionSendPolicyRule as E, TypingMode as O, SessionResetConfig as S, SessionSendPolicyMatch as T, ReplyToMode as _, DiagnosticsConfig as a, SessionMaintenanceMode as b, DmScope as c, IdentityConfig as d, LoggingConfig as f, ReplyMode as g, OutboundRetryConfig as h, DiagnosticsCacheTraceConfig as i, WebConfig as k, GroupPolicy as l, MarkdownTableMode as m, BlockStreamingChunkConfig as n, DiagnosticsOtelConfig as o, MarkdownConfig as p, BlockStreamingCoalesceConfig as r, DmPolicy as s, AgentElevatedAllowFromConfig as t, HumanDelayConfig as u, SessionConfig as v, SessionSendPolicyConfig as w, SessionResetByTypeConfig as x, SessionMaintenanceConfig as y };

package/dist/types.secrets-Bojc4omL.js

@@ -0,0 +1,92 @@
+//#region src/config/types.secrets.ts
+const DEFAULT_SECRET_PROVIDER_ALIAS = "default";
+const ENV_SECRET_REF_ID_RE = /^[A-Z][A-Z0-9_]{0,127}$/;
+const ENV_SECRET_TEMPLATE_RE = /^\$\{([A-Z][A-Z0-9_]{0,127})\}$/;
+function isValidEnvSecretRefId(value) {
+	return ENV_SECRET_REF_ID_RE.test(value);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSecretRef(value) {
+	if (!isRecord(value)) return false;
+	if (Object.keys(value).length !== 3) return false;
+	return (value.source === "env" || value.source === "file" || value.source === "exec") && typeof value.provider === "string" && value.provider.trim().length > 0 && typeof value.id === "string" && value.id.trim().length > 0;
+}
+function isLegacySecretRefWithoutProvider(value) {
+	if (!isRecord(value)) return false;
+	return (value.source === "env" || value.source === "file" || value.source === "exec") && typeof value.id === "string" && value.id.trim().length > 0 && value.provider === void 0;
+}
+function parseEnvTemplateSecretRef(value, provider = DEFAULT_SECRET_PROVIDER_ALIAS) {
+	if (typeof value !== "string") return null;
+	const match = ENV_SECRET_TEMPLATE_RE.exec(value.trim());
+	if (!match) return null;
+	return {
+		source: "env",
+		provider: provider.trim() || "default",
+		id: match[1]
+	};
+}
+function coerceSecretRef(value, defaults) {
+	if (isSecretRef(value)) return value;
+	if (isLegacySecretRefWithoutProvider(value)) {
+		const provider = value.source === "env" ? defaults?.env ?? "default" : value.source === "file" ? defaults?.file ?? "default" : defaults?.exec ?? "default";
+		return {
+			source: value.source,
+			provider,
+			id: value.id
+		};
+	}
+	const envTemplate = parseEnvTemplateSecretRef(value, defaults?.env);
+	if (envTemplate) return envTemplate;
+	return null;
+}
+function hasConfiguredSecretInput(value, defaults) {
+	if (normalizeSecretInputString(value)) return true;
+	return coerceSecretRef(value, defaults) !== null;
+}
+/**
+* Normalize a secret input string value.
+*
+* SEC-1 FIX: If the value is a SEC-1 placeholder (__SECURE__), return undefined.
+* SEC-1 placeholders indicate the actual value is stored in OS Credential Store
+* and will be resolved via environment variables at runtime.
+*
+* @param value - The secret input value
+* @returns Normalized string or undefined if empty/placeholder
+*/
+function normalizeSecretInputString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return;
+	if (trimmed === "__SECURE__" || trimmed.startsWith("__SECURE__")) return;
+	return trimmed;
+}
+function formatSecretRefLabel(ref) {
+	return `${ref.source}:${ref.provider}:${ref.id}`;
+}
+function assertSecretInputResolved(params) {
+	const { ref } = resolveSecretInputRef({
+		value: params.value,
+		refValue: params.refValue,
+		defaults: params.defaults
+	});
+	if (!ref) return;
+	throw new Error(`${params.path}: unresolved SecretRef "${formatSecretRefLabel(ref)}". Resolve this command against an active gateway runtime snapshot before reading it.`);
+}
+function normalizeResolvedSecretInputString(params) {
+	const normalized = normalizeSecretInputString(params.value);
+	if (normalized) return normalized;
+	assertSecretInputResolved(params);
+}
+function resolveSecretInputRef(params) {
+	const explicitRef = coerceSecretRef(params.refValue, params.defaults);
+	const inlineRef = explicitRef ? null : coerceSecretRef(params.value, params.defaults);
+	return {
+		explicitRef,
+		inlineRef,
+		ref: explicitRef ?? inlineRef
+	};
+}
+//#endregion
+export { hasConfiguredSecretInput as a, normalizeResolvedSecretInputString as c, resolveSecretInputRef as d, coerceSecretRef as i, normalizeSecretInputString as l, ENV_SECRET_REF_ID_RE as n, isSecretRef as o, assertSecretInputResolved as r, isValidEnvSecretRefId as s, DEFAULT_SECRET_PROVIDER_ALIAS as t, parseEnvTemplateSecretRef as u };

package/dist/ui-1UpZZyI3.js

@@ -0,0 +1,31 @@
+import { mb as inspectDiscordAccount } from "./auth-profiles-9zZdaXJK.js";
+import { Container } from "@buape/carbon";
+//#region extensions/discord/src/ui.ts
+const DEFAULT_DISCORD_ACCENT_COLOR = "#5865F2";
+function normalizeDiscordAccentColor(raw) {
+	const trimmed = (raw ?? "").trim();
+	if (!trimmed) return null;
+	const normalized = trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+	if (!/^#[0-9a-fA-F]{6}$/.test(normalized)) return null;
+	return normalized.toUpperCase();
+}
+function resolveDiscordAccentColor(params) {
+	return normalizeDiscordAccentColor(inspectDiscordAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).config.ui?.components?.accentColor) ?? DEFAULT_DISCORD_ACCENT_COLOR;
+}
+var DiscordUiContainer = class extends Container {
+	constructor(params) {
+		const accentColor = normalizeDiscordAccentColor(params.accentColor) ?? resolveDiscordAccentColor({
+			cfg: params.cfg,
+			accountId: params.accountId
+		});
+		super(params.components, {
+			accentColor,
+			spoiler: params.spoiler
+		});
+	}
+};
+//#endregion
+export { DiscordUiContainer as t };