@spacebar_ai/moldclaw-core 2026.3.41 → 2026.3.44

package/dist/subscription-DaA1urx-.js

@@ -0,0 +1,102 @@
+import { i as resolveAiProxyEndpoint } from "./usage-Czgwvg0h.js";
+//#region src/subscription/provider.ts
+/**
+* Subscription provider ID
+*/
+const SUBSCRIPTION_PROVIDER_ID = "moldclaw-subscription";
+/**
+* Default models available through the subscription service
+*/
+const SUBSCRIPTION_MODELS = [
+	{
+		id: "gemini-2.0-flash",
+		name: "Gemini 2.0 Flash (Subscription)",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 1e6,
+		maxTokens: 8192
+	},
+	{
+		id: "gemini-2.0-flash-lite",
+		name: "Gemini 2.0 Flash Lite (Subscription)",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 1e6,
+		maxTokens: 8192
+	},
+	{
+		id: "gemini-2.5-flash-preview-05-20",
+		name: "Gemini 2.5 Flash Preview (Subscription)",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536
+	},
+	{
+		id: "gemini-2.5-pro-preview-05-06",
+		name: "Gemini 2.5 Pro Preview (Subscription)",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536
+	}
+];
+/**
+* Build the subscription provider configuration
+*
+* This creates a provider config that:
+* - Uses the AI Proxy as baseUrl
+* - Uses Anthropic Messages API format (anthropic-messages)
+* - Includes X-Device-Identity header placeholder
+*
+* Note: The AI Proxy internally uses Vertex AI (Gemini) but returns
+* responses in Anthropic Messages API format. The actual X-Device-Identity
+* header value must be injected at runtime since it includes a timestamp
+* and signature.
+*
+* @param config - moldclaw config (optional)
+* @returns Provider configuration for moldclaw-subscription
+*/
+function buildSubscriptionProvider(config) {
+	return {
+		baseUrl: resolveAiProxyEndpoint(config),
+		api: "anthropic-messages",
+		apiKey: "MOLDCLAW_SUBSCRIPTION_AUTH",
+		models: SUBSCRIPTION_MODELS
+	};
+}
+/**
+* Check if a provider ID is the subscription provider
+*
+* @param providerId - Provider ID to check
+* @returns true if this is the subscription provider
+*/
+function isSubscriptionProvider(providerId) {
+	return providerId === SUBSCRIPTION_PROVIDER_ID;
+}
+//#endregion
+export { buildSubscriptionProvider as n, isSubscriptionProvider as r, SUBSCRIPTION_PROVIDER_ID as t };

package/dist/subscription-cli-Bvto9EmO.js

@@ -0,0 +1,134 @@
+import "./redact-fatrROh9.js";
+import "./errors-DOJWZqNo.js";
+import "./logger-BFfIIIKH.js";
+import "./paths-D6AgsMTU.js";
+import "./tmp-moldclaw-dir-DWF-d8qD.js";
+import "./theme-BSXzMzAA.js";
+import "./globals-DESrFYmC.js";
+import { n as defaultRuntime } from "./runtime-_tQz41uA.js";
+import "./ansi-BPhP6LBZ.js";
+import "./subsystem-CPmDTJ2P.js";
+import "./boolean-B6zcAynR.js";
+import "./env-D42cffog.js";
+import "./utils-C7ykRPCQ.js";
+import "./model-selection-bBBxfXdb.js";
+import "./agent-scope-lZlwP1At.js";
+import "./boundary-file-read-tPYh_8fH.js";
+import "./logger-BGzLUitz.js";
+import "./exec-CvEtXqTZ.js";
+import "./workspace-DJ_S272u.js";
+import "./io-BaBxjB1v.js";
+import "./host-env-security-DQ2i_W12.js";
+import "./safe-text-Cnulee_z.js";
+import "./version-T8nMYUnU.js";
+import "./env-substitution-68cyvF5h.js";
+import "./config-state-h5jUoHya.js";
+import "./network-mode-BtWXzwYn.js";
+import "./registry-C1pRrsQl.js";
+import "./manifest-registry-CS_p1OBQ.js";
+import "./ip-C4YAIpr4.js";
+import "./zod-schema.core-DvwgNmpd.js";
+import { a as resolveSubscriptionMode, r as isSubscriptionMode, t as fetchUsage } from "./usage-Czgwvg0h.js";
+import "./device-identity-IG5DngWM.js";
+import { a as hasDeviceIdentity, i as getDeviceIdentityToken, r as getDeviceId } from "./auth-Ch3Rchm4.js";
+import { n as runCommandWithRuntime } from "./cli-utils-BCuSS4l6.js";
+//#region src/cli/subscription-cli.ts
+async function subscriptionUsageCommand(opts, runtime) {
+	const result = await fetchUsage();
+	if (!result.success) {
+		if (opts.json) runtime.log(JSON.stringify({ error: result.error }));
+		else runtime.error(`Failed to fetch usage: ${result.error}`);
+		runtime.exit(1);
+		return;
+	}
+	const data = result.data;
+	if (opts.json) {
+		runtime.log(JSON.stringify(data));
+		return;
+	}
+	const formatNumber = (n) => {
+		if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+		if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+		return n.toString();
+	};
+	const formatPercent = (used, limit) => {
+		if (limit === 0) return "N/A";
+		const pct = Math.min(100, Math.round(used / limit * 100));
+		return `[${"█".repeat(Math.floor(pct / 5)) + "░".repeat(20 - Math.floor(pct / 5))}] ${pct}%`;
+	};
+	runtime.log(`📊 Subscription Usage (${data.tier.toUpperCase()})`);
+	runtime.log(`   Period: ${data.period}`);
+	runtime.log(`   Reset: ${data.resetDate}`);
+	runtime.log("");
+	runtime.log(`🔤 Tokens: ${formatNumber(data.tokens.used)} / ${formatNumber(data.tokens.limit)}`);
+	runtime.log(`   ${formatPercent(data.tokens.used, data.tokens.limit)}`);
+	runtime.log("");
+	runtime.log(`📡 Requests: ${formatNumber(data.requests.used)} / ${formatNumber(data.requests.limit)}`);
+	runtime.log(`   ${formatPercent(data.requests.used, data.requests.limit)}`);
+	runtime.log("");
+	runtime.log(`🖼️  Images: ${data.images.used} / ${data.images.limit}`);
+	runtime.log(`   ${formatPercent(data.images.used, data.images.limit)}`);
+}
+async function subscriptionStatusCommand(opts, runtime) {
+	const mode = resolveSubscriptionMode();
+	const isActive = isSubscriptionMode();
+	const deviceId = getDeviceId();
+	const hasIdentity = hasDeviceIdentity();
+	const status = {
+		mode,
+		isSubscriptionMode: isActive,
+		deviceId,
+		hasDeviceIdentity: hasIdentity
+	};
+	if (opts.json) {
+		runtime.log(JSON.stringify(status));
+		return;
+	}
+	runtime.log(`🔑 Subscription Status`);
+	runtime.log(`   Mode: ${mode}`);
+	runtime.log(`   Active: ${isActive ? "Yes" : "No"}`);
+	runtime.log(`   Device ID: ${deviceId || "(not created)"}`);
+	runtime.log(`   Identity: ${hasIdentity ? "Available" : "Not available"}`);
+}
+async function subscriptionIdentityCommand(opts, runtime) {
+	const token = getDeviceIdentityToken();
+	const deviceId = getDeviceId();
+	if (!token) {
+		if (opts.json) runtime.log(JSON.stringify({ error: "Failed to generate identity token" }));
+		else runtime.error("Failed to generate identity token");
+		runtime.exit(1);
+		return;
+	}
+	if (opts.json) {
+		runtime.log(JSON.stringify({
+			token,
+			deviceId
+		}));
+		return;
+	}
+	runtime.log(`🔑 Device Identity Token`);
+	runtime.log(`   Device ID: ${deviceId}`);
+	runtime.log(`   Token: ${token}`);
+	runtime.log("");
+	runtime.log(`Use this token as apiKey for AI Proxy authentication.`);
+}
+function registerSubscriptionCli(program) {
+	const subscription = program.command("subscription").description("Manage moldClaw subscription");
+	subscription.command("usage").description("Show current usage and limits").option("--json", "Output as JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await subscriptionUsageCommand(opts, defaultRuntime);
+		});
+	});
+	subscription.command("status").description("Show subscription status").option("--json", "Output as JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await subscriptionStatusCommand(opts, defaultRuntime);
+		});
+	});
+	subscription.command("identity").description("Get device identity token for AI Proxy authentication").option("--json", "Output as JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await subscriptionIdentityCommand(opts, defaultRuntime);
+		});
+	});
+}
+//#endregion
+export { registerSubscriptionCli };

package/dist/synology-chat-3nwk-Nj0.js

@@ -0,0 +1,297 @@
+import { t as formatDocsLink } from "./links-BcahUP5U.js";
+import { Mg as splitSetupEntries, Og as setSetupChannelEnabled, ug as mergeAllowFromEntries } from "./auth-profiles-smABVXzp.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-BuyZMNja.js";
+//#region extensions/synology-chat/src/accounts.ts
+/** Extract the channel config from the full MoldClaw config object. */
+function getChannelConfig$1(cfg) {
+	return cfg?.channels?.["synology-chat"];
+}
+/** Parse allowedUserIds from string or array to string[]. */
+function parseAllowedUserIds(raw) {
+	if (!raw) return [];
+	if (Array.isArray(raw)) return raw.filter(Boolean);
+	return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parseRateLimitPerMinute(raw) {
+	if (raw == null) return 30;
+	const trimmed = raw.trim();
+	if (!/^-?\d+$/.test(trimmed)) return 30;
+	return Number.parseInt(trimmed, 10);
+}
+/**
+* List all configured account IDs for this channel.
+* Returns ["default"] if there's a base config, plus any named accounts.
+*/
+function listAccountIds(cfg) {
+	const channelCfg = getChannelConfig$1(cfg);
+	if (!channelCfg) return [];
+	const ids = /* @__PURE__ */ new Set();
+	if (channelCfg.token || process.env.SYNOLOGY_CHAT_TOKEN) ids.add("default");
+	if (channelCfg.accounts) for (const id of Object.keys(channelCfg.accounts)) ids.add(id);
+	return Array.from(ids);
+}
+/**
+* Resolve a specific account by ID with full defaults applied.
+* Falls back to env vars for the "default" account.
+*/
+function resolveAccount(cfg, accountId) {
+	const channelCfg = getChannelConfig$1(cfg) ?? {};
+	const id = accountId || "default";
+	const accountOverride = channelCfg.accounts?.[id] ?? {};
+	const envToken = process.env.SYNOLOGY_CHAT_TOKEN ?? "";
+	const envIncomingUrl = process.env.SYNOLOGY_CHAT_INCOMING_URL ?? "";
+	const envNasHost = process.env.SYNOLOGY_NAS_HOST ?? "localhost";
+	const envAllowedUserIds = process.env.SYNOLOGY_ALLOWED_USER_IDS ?? "";
+	const envRateLimitValue = parseRateLimitPerMinute(process.env.SYNOLOGY_RATE_LIMIT);
+	const envBotName = process.env.MOLDCLAW_BOT_NAME ?? "MoldClaw";
+	return {
+		accountId: id,
+		enabled: accountOverride.enabled ?? channelCfg.enabled ?? true,
+		token: accountOverride.token ?? channelCfg.token ?? envToken,
+		incomingUrl: accountOverride.incomingUrl ?? channelCfg.incomingUrl ?? envIncomingUrl,
+		nasHost: accountOverride.nasHost ?? channelCfg.nasHost ?? envNasHost,
+		webhookPath: accountOverride.webhookPath ?? channelCfg.webhookPath ?? "/webhook/synology",
+		dmPolicy: accountOverride.dmPolicy ?? channelCfg.dmPolicy ?? "allowlist",
+		allowedUserIds: parseAllowedUserIds(accountOverride.allowedUserIds ?? channelCfg.allowedUserIds ?? envAllowedUserIds),
+		rateLimitPerMinute: accountOverride.rateLimitPerMinute ?? channelCfg.rateLimitPerMinute ?? envRateLimitValue,
+		botName: accountOverride.botName ?? channelCfg.botName ?? envBotName,
+		allowInsecureSsl: accountOverride.allowInsecureSsl ?? channelCfg.allowInsecureSsl ?? false
+	};
+}
+//#endregion
+//#region extensions/synology-chat/src/setup-surface.ts
+const channel = "synology-chat";
+const DEFAULT_WEBHOOK_PATH = "/webhook/synology";
+const SYNOLOGY_SETUP_HELP_LINES = [
+	"1) Create an incoming webhook in Synology Chat and copy its URL",
+	"2) Create an outgoing webhook and copy its secret token",
+	`3) Point the outgoing webhook to https://<gateway-host>${DEFAULT_WEBHOOK_PATH}`,
+	"4) Keep allowed user IDs handy for DM allowlisting",
+	`Docs: ${formatDocsLink("/channels/synology-chat", "channels/synology-chat")}`
+];
+const SYNOLOGY_ALLOW_FROM_HELP_LINES = [
+	"Allowlist Synology Chat DMs by numeric user id.",
+	"Examples:",
+	"- 123456",
+	"- synology-chat:123456",
+	"Multiple entries: comma-separated.",
+	`Docs: ${formatDocsLink("/channels/synology-chat", "channels/synology-chat")}`
+];
+function getChannelConfig(cfg) {
+	return cfg.channels?.[channel] ?? {};
+}
+function getRawAccountConfig(cfg, accountId) {
+	const channelConfig = getChannelConfig(cfg);
+	if (accountId === "default") return channelConfig;
+	return channelConfig.accounts?.[accountId] ?? {};
+}
+function patchSynologyChatAccountConfig(params) {
+	const channelConfig = getChannelConfig(params.cfg);
+	if (params.accountId === "default") {
+		const nextChannelConfig = { ...channelConfig };
+		for (const field of params.clearFields ?? []) delete nextChannelConfig[field];
+		return {
+			...params.cfg,
+			channels: {
+				...params.cfg.channels,
+				[channel]: {
+					...nextChannelConfig,
+					...params.enabled ? { enabled: true } : {},
+					...params.patch
+				}
+			}
+		};
+	}
+	const nextAccounts = { ...channelConfig.accounts ?? {} };
+	const nextAccountConfig = { ...nextAccounts[params.accountId] ?? {} };
+	for (const field of params.clearFields ?? []) delete nextAccountConfig[field];
+	nextAccounts[params.accountId] = {
+		...nextAccountConfig,
+		...params.enabled ? { enabled: true } : {},
+		...params.patch
+	};
+	return {
+		...params.cfg,
+		channels: {
+			...params.cfg.channels,
+			[channel]: {
+				...channelConfig,
+				...params.enabled ? { enabled: true } : {},
+				accounts: nextAccounts
+			}
+		}
+	};
+}
+function isSynologyChatConfigured(cfg, accountId) {
+	const account = resolveAccount(cfg, accountId);
+	return Boolean(account.token.trim() && account.incomingUrl.trim());
+}
+function validateWebhookUrl(value) {
+	try {
+		const parsed = new URL(value);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return "Incoming webhook must use http:// or https://.";
+	} catch {
+		return "Incoming webhook must be a valid URL.";
+	}
+}
+function validateWebhookPath(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return;
+	return trimmed.startsWith("/") ? void 0 : "Webhook path must start with /.";
+}
+function parseSynologyUserId(value) {
+	const cleaned = value.replace(/^synology-chat:/i, "").trim();
+	return /^\d+$/.test(cleaned) ? cleaned : null;
+}
+function resolveExistingAllowedUserIds(cfg, accountId) {
+	const raw = getRawAccountConfig(cfg, accountId).allowedUserIds;
+	if (Array.isArray(raw)) return raw.map((value) => String(value).trim()).filter(Boolean);
+	return String(raw ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+}
+const synologyChatSetupAdapter = {
+	resolveAccountId: ({ accountId }) => normalizeAccountId(accountId) ?? "default",
+	validateInput: ({ accountId, input }) => {
+		if (input.useEnv && accountId !== "default") return "Synology Chat env credentials only support the default account.";
+		if (!input.useEnv && !input.token?.trim()) return "Synology Chat requires --token or --use-env.";
+		if (!input.url?.trim()) return "Synology Chat requires --url for the incoming webhook.";
+		const urlError = validateWebhookUrl(input.url.trim());
+		if (urlError) return urlError;
+		if (input.webhookPath?.trim()) return validateWebhookPath(input.webhookPath.trim()) ?? null;
+		return null;
+	},
+	applyAccountConfig: ({ cfg, accountId, input }) => patchSynologyChatAccountConfig({
+		cfg,
+		accountId,
+		enabled: true,
+		clearFields: input.useEnv ? ["token"] : void 0,
+		patch: {
+			...input.useEnv ? {} : { token: input.token?.trim() },
+			incomingUrl: input.url?.trim(),
+			...input.webhookPath?.trim() ? { webhookPath: input.webhookPath.trim() } : {}
+		}
+	})
+};
+const synologyChatSetupWizard = {
+	channel,
+	status: {
+		configuredLabel: "configured",
+		unconfiguredLabel: "needs token + incoming webhook",
+		configuredHint: "configured",
+		unconfiguredHint: "needs token + incoming webhook",
+		configuredScore: 1,
+		unconfiguredScore: 0,
+		resolveConfigured: ({ cfg }) => listAccountIds(cfg).some((accountId) => isSynologyChatConfigured(cfg, accountId)),
+		resolveStatusLines: ({ cfg, configured }) => [`Synology Chat: ${configured ? "configured" : "needs token + incoming webhook"}`, `Accounts: ${listAccountIds(cfg).length || 0}`]
+	},
+	introNote: {
+		title: "Synology Chat webhook setup",
+		lines: SYNOLOGY_SETUP_HELP_LINES
+	},
+	credentials: [{
+		inputKey: "token",
+		providerHint: channel,
+		credentialLabel: "outgoing webhook token",
+		preferredEnvVar: "SYNOLOGY_CHAT_TOKEN",
+		helpTitle: "Synology Chat webhook token",
+		helpLines: SYNOLOGY_SETUP_HELP_LINES,
+		envPrompt: "SYNOLOGY_CHAT_TOKEN detected. Use env var?",
+		keepPrompt: "Synology Chat webhook token already configured. Keep it?",
+		inputPrompt: "Enter Synology Chat outgoing webhook token",
+		allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
+		inspect: ({ cfg, accountId }) => {
+			const account = resolveAccount(cfg, accountId);
+			const raw = getRawAccountConfig(cfg, accountId);
+			return {
+				accountConfigured: isSynologyChatConfigured(cfg, accountId),
+				hasConfiguredValue: Boolean(raw.token?.trim()),
+				resolvedValue: account.token.trim() || void 0,
+				envValue: accountId === "default" ? process.env.SYNOLOGY_CHAT_TOKEN?.trim() || void 0 : void 0
+			};
+		},
+		applyUseEnv: async ({ cfg, accountId }) => patchSynologyChatAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: ["token"],
+			patch: {}
+		}),
+		applySet: async ({ cfg, accountId, resolvedValue }) => patchSynologyChatAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			patch: { token: resolvedValue }
+		})
+	}],
+	textInputs: [{
+		inputKey: "url",
+		message: "Incoming webhook URL",
+		placeholder: "https://nas.example.com/webapi/entry.cgi?api=SYNO.Chat.External&method=incoming...",
+		helpTitle: "Synology Chat incoming webhook",
+		helpLines: ["Use the incoming webhook URL from Synology Chat integrations.", "This is the URL MoldClaw uses to send replies back to Chat."],
+		currentValue: ({ cfg, accountId }) => getRawAccountConfig(cfg, accountId).incomingUrl?.trim(),
+		keepPrompt: (value) => `Incoming webhook URL set (${value}). Keep it?`,
+		validate: ({ value }) => validateWebhookUrl(value),
+		applySet: async ({ cfg, accountId, value }) => patchSynologyChatAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			patch: { incomingUrl: value.trim() }
+		})
+	}, {
+		inputKey: "webhookPath",
+		message: "Outgoing webhook path (optional)",
+		placeholder: DEFAULT_WEBHOOK_PATH,
+		required: false,
+		applyEmptyValue: true,
+		helpTitle: "Synology Chat outgoing webhook path",
+		helpLines: [`Default path: ${DEFAULT_WEBHOOK_PATH}`, "Change this only if you need multiple Synology Chat webhook routes."],
+		currentValue: ({ cfg, accountId }) => getRawAccountConfig(cfg, accountId).webhookPath?.trim(),
+		keepPrompt: (value) => `Outgoing webhook path set (${value}). Keep it?`,
+		validate: ({ value }) => validateWebhookPath(value),
+		applySet: async ({ cfg, accountId, value }) => patchSynologyChatAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: value.trim() ? void 0 : ["webhookPath"],
+			patch: value.trim() ? { webhookPath: value.trim() } : {}
+		})
+	}],
+	allowFrom: {
+		helpTitle: "Synology Chat allowlist",
+		helpLines: SYNOLOGY_ALLOW_FROM_HELP_LINES,
+		message: "Allowed Synology Chat user ids",
+		placeholder: "123456, 987654",
+		invalidWithoutCredentialNote: "Synology Chat user ids must be numeric.",
+		parseInputs: splitSetupEntries,
+		parseId: parseSynologyUserId,
+		resolveEntries: async ({ entries }) => entries.map((entry) => {
+			const id = parseSynologyUserId(entry);
+			return {
+				input: entry,
+				resolved: Boolean(id),
+				id
+			};
+		}),
+		apply: async ({ cfg, accountId, allowFrom }) => patchSynologyChatAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			patch: {
+				dmPolicy: "allowlist",
+				allowedUserIds: mergeAllowFromEntries(resolveExistingAllowedUserIds(cfg, accountId), allowFrom)
+			}
+		})
+	},
+	completionNote: {
+		title: "Synology Chat access control",
+		lines: [
+			`Default outgoing webhook path: ${DEFAULT_WEBHOOK_PATH}`,
+			"Set allowed user IDs, or manually switch `channels.synology-chat.dmPolicy` to `\"open\"` for public DMs.",
+			"With `dmPolicy=\"allowlist\"`, an empty allowedUserIds list blocks the route from starting.",
+			`Docs: ${formatDocsLink("/channels/synology-chat", "channels/synology-chat")}`
+		]
+	},
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+export { resolveAccount as i, synologyChatSetupWizard as n, listAccountIds as r, synologyChatSetupAdapter as t };

package/dist/system-cli-BvNps8sl.js

@@ -0,0 +1,94 @@
+import "./logger-BFfIIIKH.js";
+import "./paths-D6AgsMTU.js";
+import "./tmp-moldclaw-dir-DWF-d8qD.js";
+import { r as theme } from "./theme-BSXzMzAA.js";
+import { t as danger } from "./globals-DESrFYmC.js";
+import { n as defaultRuntime } from "./runtime-_tQz41uA.js";
+import "./ansi-BPhP6LBZ.js";
+import "./subsystem-CPmDTJ2P.js";
+import "./boolean-B6zcAynR.js";
+import "./env-D42cffog.js";
+import "./utils-C7ykRPCQ.js";
+import { t as formatDocsLink } from "./links-BcahUP5U.js";
+import "./model-selection-bBBxfXdb.js";
+import "./agent-scope-lZlwP1At.js";
+import "./boundary-file-read-tPYh_8fH.js";
+import "./logger-BGzLUitz.js";
+import "./exec-CvEtXqTZ.js";
+import "./workspace-DJ_S272u.js";
+import "./io-BaBxjB1v.js";
+import "./host-env-security-DQ2i_W12.js";
+import "./safe-text-Cnulee_z.js";
+import "./version-T8nMYUnU.js";
+import "./env-substitution-68cyvF5h.js";
+import "./config-state-h5jUoHya.js";
+import "./network-mode-BtWXzwYn.js";
+import "./registry-C1pRrsQl.js";
+import "./manifest-registry-CS_p1OBQ.js";
+import "./ip-C4YAIpr4.js";
+import "./zod-schema.core-DvwgNmpd.js";
+import "./config-CwBv71QC.js";
+import "./audit-fs-CMb-YUHX.js";
+import "./resolve-PSlwZjg3.js";
+import "./tailnet-fFTz5Twr.js";
+import "./net-K181nxTH.js";
+import "./credentials-D-5Pb-aZ.js";
+import "./message-channel-DFE4FuE_.js";
+import "./method-scopes-B2ZKSsxQ.js";
+import "./device-identity-IG5DngWM.js";
+import "./call-gdDAt07d.js";
+import "./progress-Cwq59vgZ.js";
+import { n as callGatewayFromCli, t as addGatewayClientOptions } from "./gateway-rpc-C0Vk51W7.js";
+//#region src/cli/system-cli.ts
+const normalizeWakeMode = (raw) => {
+	const mode = typeof raw === "string" ? raw.trim() : "";
+	if (!mode) return "next-heartbeat";
+	if (mode === "now" || mode === "next-heartbeat") return mode;
+	throw new Error("--mode must be now or next-heartbeat");
+};
+async function runSystemGatewayCommand(opts, action, successText) {
+	try {
+		const result = await action();
+		if (opts.json || successText === void 0) defaultRuntime.log(JSON.stringify(result, null, 2));
+		else defaultRuntime.log(successText);
+	} catch (err) {
+		defaultRuntime.error(danger(String(err)));
+		defaultRuntime.exit(1);
+	}
+}
+function registerSystemCli(program) {
+	const system = program.command("system").description("System tools (events, heartbeat, presence)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/system", "docs.moldclaw.ai/cli/system")}\n`);
+	addGatewayClientOptions(system.command("event").description("Enqueue a system event and optionally trigger a heartbeat").requiredOption("--text <text>", "System event text").option("--mode <mode>", "Wake mode (now|next-heartbeat)", "next-heartbeat").option("--json", "Output JSON", false)).action(async (opts) => {
+		await runSystemGatewayCommand(opts, async () => {
+			const text = typeof opts.text === "string" ? opts.text.trim() : "";
+			if (!text) throw new Error("--text is required");
+			return await callGatewayFromCli("wake", opts, {
+				mode: normalizeWakeMode(opts.mode),
+				text
+			}, { expectFinal: false });
+		}, "ok");
+	});
+	const heartbeat = system.command("heartbeat").description("Heartbeat controls");
+	addGatewayClientOptions(heartbeat.command("last").description("Show the last heartbeat event").option("--json", "Output JSON", false)).action(async (opts) => {
+		await runSystemGatewayCommand(opts, async () => {
+			return await callGatewayFromCli("last-heartbeat", opts, void 0, { expectFinal: false });
+		});
+	});
+	addGatewayClientOptions(heartbeat.command("enable").description("Enable heartbeats").option("--json", "Output JSON", false)).action(async (opts) => {
+		await runSystemGatewayCommand(opts, async () => {
+			return await callGatewayFromCli("set-heartbeats", opts, { enabled: true }, { expectFinal: false });
+		});
+	});
+	addGatewayClientOptions(heartbeat.command("disable").description("Disable heartbeats").option("--json", "Output JSON", false)).action(async (opts) => {
+		await runSystemGatewayCommand(opts, async () => {
+			return await callGatewayFromCli("set-heartbeats", opts, { enabled: false }, { expectFinal: false });
+		});
+	});
+	addGatewayClientOptions(system.command("presence").description("List system presence entries").option("--json", "Output JSON", false)).action(async (opts) => {
+		await runSystemGatewayCommand(opts, async () => {
+			return await callGatewayFromCli("system-presence", opts, void 0, { expectFinal: false });
+		});
+	});
+}
+//#endregion
+export { registerSystemCli };

package/dist/telegram/audit.d.ts

@@ -1,2 +1,2 @@
-import { ep as AuditTelegramGroupMembershipParams, ip as collectTelegramUnmentionedGroupIds, np as TelegramGroupMembershipAuditEntry, rp as auditTelegramGroupMembership, tp as TelegramGroupMembershipAudit } from "../types-Ckufs_BY.js";
+import { ep as AuditTelegramGroupMembershipParams, ip as collectTelegramUnmentionedGroupIds, np as TelegramGroupMembershipAuditEntry, rp as auditTelegramGroupMembership, tp as TelegramGroupMembershipAudit } from "../types-ZKnGUchG.js";
 export { AuditTelegramGroupMembershipParams, TelegramGroupMembershipAudit, TelegramGroupMembershipAuditEntry, auditTelegramGroupMembership, collectTelegramUnmentionedGroupIds };

package/dist/telegram/audit.js

@@ -1,2 +1,2 @@
-import { n as collectTelegramUnmentionedGroupIds, t as auditTelegramGroupMembership } from "../audit-CIWW1Aqm.js";
+import { n as collectTelegramUnmentionedGroupIds, t as auditTelegramGroupMembership } from "../audit-CpfSjvyo.js";
 export { auditTelegramGroupMembership, collectTelegramUnmentionedGroupIds };

package/dist/telegram/token.d.ts

@@ -1,2 +1,2 @@
-import { Qf as resolveTelegramToken, Xf as TelegramTokenResolution, Zf as TelegramTokenSource } from "../types-Ckufs_BY.js";
+import { Qf as resolveTelegramToken, Xf as TelegramTokenResolution, Zf as TelegramTokenSource } from "../types-ZKnGUchG.js";
 export { TelegramTokenResolution, TelegramTokenSource, resolveTelegramToken };