@spacebar_ai/moldclaw-core 2026.3.43 → 2026.3.45

package/dist/channel-hlzhFHDl.js

@@ -0,0 +1,497 @@
+import { Cv as processLineMessage, HT as clearAccountEntryFields, KC as buildComputedAccountStatusSnapshot, LT as collectAllowlistProviderRestrictSendersWarnings, YC as buildTokenChannelStatusSummary, dT as createScopedAccountConfigAccessors, fT as createScopedChannelConfigBase, pT as createScopedDmSecurityResolver } from "./auth-profiles-C-Ul-Qkn.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-BuyZMNja.js";
+import { r as buildChannelConfigSchema } from "./config-schema-BNU4GQh_.js";
+import { n as lineSetupWizard, r as lineSetupAdapter, t as LineConfigSchema } from "./line-BBiBiGgL.js";
+import { t as createPluginRuntimeStore } from "./runtime-store-DTqHvPYo.js";
+//#region extensions/line/src/runtime.ts
+const { setRuntime: setLineRuntime, getRuntime: getLineRuntime } = createPluginRuntimeStore("LINE runtime not initialized - plugin not registered");
+//#endregion
+//#region extensions/line/src/channel.ts
+const meta = {
+	id: "line",
+	label: "LINE",
+	selectionLabel: "LINE (Messaging API)",
+	detailLabel: "LINE Bot",
+	docsPath: "/channels/line",
+	docsLabel: "line",
+	blurb: "LINE Messaging API bot for Japan/Taiwan/Thailand markets.",
+	systemImage: "message.fill"
+};
+const lineConfigAccessors = createScopedAccountConfigAccessors({
+	resolveAccount: ({ cfg, accountId }) => getLineRuntime().channel.line.resolveLineAccount({
+		cfg,
+		accountId: accountId ?? void 0
+	}),
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	formatAllowFrom: (allowFrom) => allowFrom.map((entry) => String(entry).trim()).filter(Boolean).map((entry) => entry.replace(/^line:(?:user:)?/i, ""))
+});
+const lineConfigBase = createScopedChannelConfigBase({
+	sectionKey: "line",
+	listAccountIds: (cfg) => getLineRuntime().channel.line.listLineAccountIds(cfg),
+	resolveAccount: (cfg, accountId) => getLineRuntime().channel.line.resolveLineAccount({
+		cfg,
+		accountId: accountId ?? void 0
+	}),
+	defaultAccountId: (cfg) => getLineRuntime().channel.line.resolveDefaultLineAccountId(cfg),
+	clearBaseFields: [
+		"channelSecret",
+		"tokenFile",
+		"secretFile"
+	]
+});
+const resolveLineDmPolicy = createScopedDmSecurityResolver({
+	channelKey: "line",
+	resolvePolicy: (account) => account.config.dmPolicy,
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	policyPathSuffix: "dmPolicy",
+	approveHint: "moldclaw pairing approve line <code>",
+	normalizeEntry: (raw) => raw.replace(/^line:(?:user:)?/i, "")
+});
+const linePlugin = {
+	id: "line",
+	meta: {
+		...meta,
+		quickstartAllowFrom: true
+	},
+	pairing: {
+		idLabel: "lineUserId",
+		normalizeAllowEntry: (entry) => {
+			return entry.replace(/^line:(?:user:)?/i, "");
+		},
+		notifyApproval: async ({ cfg, id }) => {
+			const line = getLineRuntime().channel.line;
+			const account = line.resolveLineAccount({ cfg });
+			if (!account.channelAccessToken) throw new Error("LINE channel access token not configured");
+			await line.pushMessageLine(id, "MoldClaw: your access has been approved.", { channelAccessToken: account.channelAccessToken });
+		}
+	},
+	capabilities: {
+		chatTypes: ["direct", "group"],
+		reactions: false,
+		threads: false,
+		media: true,
+		nativeCommands: false,
+		blockStreaming: true
+	},
+	reload: { configPrefixes: ["channels.line"] },
+	configSchema: buildChannelConfigSchema(LineConfigSchema),
+	setupWizard: lineSetupWizard,
+	config: {
+		...lineConfigBase,
+		isConfigured: (account) => Boolean(account.channelAccessToken?.trim() && account.channelSecret?.trim()),
+		describeAccount: (account) => ({
+			accountId: account.accountId,
+			name: account.name,
+			enabled: account.enabled,
+			configured: Boolean(account.channelAccessToken?.trim() && account.channelSecret?.trim()),
+			tokenSource: account.tokenSource ?? void 0
+		}),
+		...lineConfigAccessors
+	},
+	security: {
+		resolveDmPolicy: resolveLineDmPolicy,
+		collectWarnings: ({ account, cfg }) => {
+			return collectAllowlistProviderRestrictSendersWarnings({
+				cfg,
+				providerConfigPresent: cfg.channels?.line !== void 0,
+				configuredGroupPolicy: account.config.groupPolicy,
+				surface: "LINE groups",
+				openScope: "any member in groups",
+				groupPolicyPath: "channels.line.groupPolicy",
+				groupAllowFromPath: "channels.line.groupAllowFrom",
+				mentionGated: false
+			});
+		}
+	},
+	groups: { resolveRequireMention: ({ cfg, accountId, groupId }) => {
+		const groups = getLineRuntime().channel.line.resolveLineAccount({
+			cfg,
+			accountId: accountId ?? void 0
+		}).config.groups;
+		if (!groups || !groupId) return false;
+		return (groups[groupId] ?? groups["*"])?.requireMention ?? false;
+	} },
+	messaging: {
+		normalizeTarget: (target) => {
+			const trimmed = target.trim();
+			if (!trimmed) return;
+			return trimmed.replace(/^line:(group|room|user):/i, "").replace(/^line:/i, "");
+		},
+		targetResolver: {
+			looksLikeId: (id) => {
+				const trimmed = id?.trim();
+				if (!trimmed) return false;
+				return /^[UCR][a-f0-9]{32}$/i.test(trimmed) || /^line:/i.test(trimmed);
+			},
+			hint: "<userId|groupId|roomId>"
+		}
+	},
+	directory: {
+		self: async () => null,
+		listPeers: async () => [],
+		listGroups: async () => []
+	},
+	setup: lineSetupAdapter,
+	outbound: {
+		deliveryMode: "direct",
+		chunker: (text, limit) => getLineRuntime().channel.text.chunkMarkdownText(text, limit),
+		textChunkLimit: 5e3,
+		sendPayload: async ({ to, payload, accountId, cfg }) => {
+			const runtime = getLineRuntime();
+			const lineData = payload.channelData?.line ?? {};
+			const sendText = runtime.channel.line.pushMessageLine;
+			const sendBatch = runtime.channel.line.pushMessagesLine;
+			const sendFlex = runtime.channel.line.pushFlexMessage;
+			const sendTemplate = runtime.channel.line.pushTemplateMessage;
+			const sendLocation = runtime.channel.line.pushLocationMessage;
+			const sendQuickReplies = runtime.channel.line.pushTextMessageWithQuickReplies;
+			const buildTemplate = runtime.channel.line.buildTemplateMessageFromPayload;
+			const createQuickReplyItems = runtime.channel.line.createQuickReplyItems;
+			let lastResult = null;
+			const quickReplies = lineData.quickReplies ?? [];
+			const hasQuickReplies = quickReplies.length > 0;
+			const quickReply = hasQuickReplies ? createQuickReplyItems(quickReplies) : void 0;
+			const sendMessageBatch = async (messages) => {
+				if (messages.length === 0) return;
+				for (let i = 0; i < messages.length; i += 5) {
+					const result = await sendBatch(to, messages.slice(i, i + 5), {
+						verbose: false,
+						cfg,
+						accountId: accountId ?? void 0
+					});
+					lastResult = {
+						messageId: result.messageId,
+						chatId: result.chatId
+					};
+				}
+			};
+			const processed = payload.text ? processLineMessage(payload.text) : {
+				text: "",
+				flexMessages: []
+			};
+			const chunkLimit = runtime.channel.text.resolveTextChunkLimit?.(cfg, "line", accountId ?? void 0, { fallbackLimit: 5e3 }) ?? 5e3;
+			const chunks = processed.text ? runtime.channel.text.chunkMarkdownText(processed.text, chunkLimit) : [];
+			const mediaUrls = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+			const shouldSendQuickRepliesInline = chunks.length === 0 && hasQuickReplies;
+			const sendMediaMessages = async () => {
+				for (const url of mediaUrls) lastResult = await runtime.channel.line.sendMessageLine(to, "", {
+					verbose: false,
+					mediaUrl: url,
+					cfg,
+					accountId: accountId ?? void 0
+				});
+			};
+			if (!shouldSendQuickRepliesInline) {
+				if (lineData.flexMessage) {
+					const flexContents = lineData.flexMessage.contents;
+					lastResult = await sendFlex(to, lineData.flexMessage.altText, flexContents, {
+						verbose: false,
+						cfg,
+						accountId: accountId ?? void 0
+					});
+				}
+				if (lineData.templateMessage) {
+					const template = buildTemplate(lineData.templateMessage);
+					if (template) lastResult = await sendTemplate(to, template, {
+						verbose: false,
+						cfg,
+						accountId: accountId ?? void 0
+					});
+				}
+				if (lineData.location) lastResult = await sendLocation(to, lineData.location, {
+					verbose: false,
+					cfg,
+					accountId: accountId ?? void 0
+				});
+				for (const flexMsg of processed.flexMessages) {
+					const flexContents = flexMsg.contents;
+					lastResult = await sendFlex(to, flexMsg.altText, flexContents, {
+						verbose: false,
+						cfg,
+						accountId: accountId ?? void 0
+					});
+				}
+			}
+			const sendMediaAfterText = !(hasQuickReplies && chunks.length > 0);
+			if (mediaUrls.length > 0 && !shouldSendQuickRepliesInline && !sendMediaAfterText) await sendMediaMessages();
+			if (chunks.length > 0) for (let i = 0; i < chunks.length; i += 1) if (i === chunks.length - 1 && hasQuickReplies) lastResult = await sendQuickReplies(to, chunks[i], quickReplies, {
+				verbose: false,
+				cfg,
+				accountId: accountId ?? void 0
+			});
+			else lastResult = await sendText(to, chunks[i], {
+				verbose: false,
+				cfg,
+				accountId: accountId ?? void 0
+			});
+			else if (shouldSendQuickRepliesInline) {
+				const quickReplyMessages = [];
+				if (lineData.flexMessage) quickReplyMessages.push({
+					type: "flex",
+					altText: lineData.flexMessage.altText.slice(0, 400),
+					contents: lineData.flexMessage.contents
+				});
+				if (lineData.templateMessage) {
+					const template = buildTemplate(lineData.templateMessage);
+					if (template) quickReplyMessages.push(template);
+				}
+				if (lineData.location) quickReplyMessages.push({
+					type: "location",
+					title: lineData.location.title.slice(0, 100),
+					address: lineData.location.address.slice(0, 100),
+					latitude: lineData.location.latitude,
+					longitude: lineData.location.longitude
+				});
+				for (const flexMsg of processed.flexMessages) quickReplyMessages.push({
+					type: "flex",
+					altText: flexMsg.altText.slice(0, 400),
+					contents: flexMsg.contents
+				});
+				for (const url of mediaUrls) {
+					const trimmed = url?.trim();
+					if (!trimmed) continue;
+					quickReplyMessages.push({
+						type: "image",
+						originalContentUrl: trimmed,
+						previewImageUrl: trimmed
+					});
+				}
+				if (quickReplyMessages.length > 0 && quickReply) {
+					const lastIndex = quickReplyMessages.length - 1;
+					quickReplyMessages[lastIndex] = {
+						...quickReplyMessages[lastIndex],
+						quickReply
+					};
+					await sendMessageBatch(quickReplyMessages);
+				}
+			}
+			if (mediaUrls.length > 0 && !shouldSendQuickRepliesInline && sendMediaAfterText) await sendMediaMessages();
+			if (lastResult) return {
+				channel: "line",
+				...lastResult
+			};
+			return {
+				channel: "line",
+				messageId: "empty",
+				chatId: to
+			};
+		},
+		sendText: async ({ cfg, to, text, accountId }) => {
+			const runtime = getLineRuntime();
+			const sendText = runtime.channel.line.pushMessageLine;
+			const sendFlex = runtime.channel.line.pushFlexMessage;
+			const processed = processLineMessage(text);
+			let result;
+			if (processed.text.trim()) result = await sendText(to, processed.text, {
+				verbose: false,
+				cfg,
+				accountId: accountId ?? void 0
+			});
+			else result = {
+				messageId: "processed",
+				chatId: to
+			};
+			for (const flexMsg of processed.flexMessages) {
+				const flexContents = flexMsg.contents;
+				await sendFlex(to, flexMsg.altText, flexContents, {
+					verbose: false,
+					cfg,
+					accountId: accountId ?? void 0
+				});
+			}
+			return {
+				channel: "line",
+				...result
+			};
+		},
+		sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
+			const send = getLineRuntime().channel.line.sendMessageLine;
+			return {
+				channel: "line",
+				...await send(to, text, {
+					verbose: false,
+					mediaUrl,
+					cfg,
+					accountId: accountId ?? void 0
+				})
+			};
+		}
+	},
+	status: {
+		defaultRuntime: {
+			accountId: DEFAULT_ACCOUNT_ID,
+			running: false,
+			lastStartAt: null,
+			lastStopAt: null,
+			lastError: null
+		},
+		collectStatusIssues: (accounts) => {
+			const issues = [];
+			for (const account of accounts) {
+				const accountId = account.accountId ?? "default";
+				if (!account.channelAccessToken?.trim()) issues.push({
+					channel: "line",
+					accountId,
+					kind: "config",
+					message: "LINE channel access token not configured"
+				});
+				if (!account.channelSecret?.trim()) issues.push({
+					channel: "line",
+					accountId,
+					kind: "config",
+					message: "LINE channel secret not configured"
+				});
+			}
+			return issues;
+		},
+		buildChannelSummary: ({ snapshot }) => buildTokenChannelStatusSummary(snapshot),
+		probeAccount: async ({ account, timeoutMs }) => getLineRuntime().channel.line.probeLineBot(account.channelAccessToken, timeoutMs),
+		buildAccountSnapshot: ({ account, runtime, probe }) => {
+			const configured = Boolean(account.channelAccessToken?.trim() && account.channelSecret?.trim());
+			return {
+				...buildComputedAccountStatusSnapshot({
+					accountId: account.accountId,
+					name: account.name,
+					enabled: account.enabled,
+					configured,
+					runtime,
+					probe
+				}),
+				tokenSource: account.tokenSource,
+				mode: "webhook"
+			};
+		}
+	},
+	gateway: {
+		startAccount: async (ctx) => {
+			const account = ctx.account;
+			const token = account.channelAccessToken.trim();
+			const secret = account.channelSecret.trim();
+			if (!token) throw new Error(`LINE webhook mode requires a non-empty channel access token for account "${account.accountId}".`);
+			if (!secret) throw new Error(`LINE webhook mode requires a non-empty channel secret for account "${account.accountId}".`);
+			let lineBotLabel = "";
+			try {
+				const probe = await getLineRuntime().channel.line.probeLineBot(token, 2500);
+				const displayName = probe.ok ? probe.bot?.displayName?.trim() : null;
+				if (displayName) lineBotLabel = ` (${displayName})`;
+			} catch (err) {
+				if (getLineRuntime().logging.shouldLogVerbose()) ctx.log?.debug?.(`[${account.accountId}] bot probe failed: ${String(err)}`);
+			}
+			ctx.log?.info(`[${account.accountId}] starting LINE provider${lineBotLabel}`);
+			return await getLineRuntime().channel.line.monitorLineProvider({
+				channelAccessToken: token,
+				channelSecret: secret,
+				accountId: account.accountId,
+				config: ctx.cfg,
+				runtime: ctx.runtime,
+				abortSignal: ctx.abortSignal,
+				webhookPath: account.config.webhookPath
+			});
+		},
+		logoutAccount: async ({ accountId, cfg }) => {
+			const envToken = process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim() ?? "";
+			const nextCfg = { ...cfg };
+			const nextLine = { ...cfg.channels?.line ?? {} };
+			let cleared = false;
+			let changed = false;
+			if (accountId === "default") {
+				if (nextLine.channelAccessToken || nextLine.channelSecret || nextLine.tokenFile || nextLine.secretFile) {
+					delete nextLine.channelAccessToken;
+					delete nextLine.channelSecret;
+					delete nextLine.tokenFile;
+					delete nextLine.secretFile;
+					cleared = true;
+					changed = true;
+				}
+			}
+			const accountCleanup = clearAccountEntryFields({
+				accounts: nextLine.accounts,
+				accountId,
+				fields: [
+					"channelAccessToken",
+					"channelSecret",
+					"tokenFile",
+					"secretFile"
+				],
+				markClearedOnFieldPresence: true
+			});
+			if (accountCleanup.changed) {
+				changed = true;
+				if (accountCleanup.cleared) cleared = true;
+				if (accountCleanup.nextAccounts) nextLine.accounts = accountCleanup.nextAccounts;
+				else delete nextLine.accounts;
+			}
+			if (changed) {
+				if (Object.keys(nextLine).length > 0) nextCfg.channels = {
+					...nextCfg.channels,
+					line: nextLine
+				};
+				else {
+					const nextChannels = { ...nextCfg.channels };
+					delete nextChannels.line;
+					if (Object.keys(nextChannels).length > 0) nextCfg.channels = nextChannels;
+					else delete nextCfg.channels;
+				}
+				await getLineRuntime().config.writeConfigFile(nextCfg);
+			}
+			const loggedOut = getLineRuntime().channel.line.resolveLineAccount({
+				cfg: changed ? nextCfg : cfg,
+				accountId
+			}).tokenSource === "none";
+			return {
+				cleared,
+				envToken: Boolean(envToken),
+				loggedOut
+			};
+		}
+	},
+	agentPrompt: { messageToolHints: () => [
+		"",
+		"### LINE Rich Messages",
+		"LINE supports rich visual messages. Use these directives in your reply when appropriate:",
+		"",
+		"**Quick Replies** (bottom button suggestions):",
+		"  [[quick_replies: Option 1, Option 2, Option 3]]",
+		"",
+		"**Location** (map pin):",
+		"  [[location: Place Name | Address | latitude | longitude]]",
+		"",
+		"**Confirm Dialog** (yes/no prompt):",
+		"  [[confirm: Question text? | Yes Label | No Label]]",
+		"",
+		"**Button Menu** (title + text + buttons):",
+		"  [[buttons: Title | Description | Btn1:action1, Btn2:https://url.com]]",
+		"",
+		"**Media Player Card** (music status):",
+		"  [[media_player: Song Title | Artist Name | Source | https://albumart.url | playing]]",
+		"  - Status: 'playing' or 'paused' (optional)",
+		"",
+		"**Event Card** (calendar events, meetings):",
+		"  [[event: Event Title | Date | Time | Location | Description]]",
+		"  - Time, Location, Description are optional",
+		"",
+		"**Agenda Card** (multiple events/schedule):",
+		"  [[agenda: Schedule Title | Event1:9:00 AM, Event2:12:00 PM, Event3:3:00 PM]]",
+		"",
+		"**Device Control Card** (smart devices, TVs, etc.):",
+		"  [[device: Device Name | Device Type | Status | Control1:data1, Control2:data2]]",
+		"",
+		"**Apple TV Remote** (full D-pad + transport):",
+		"  [[appletv_remote: Apple TV | Playing]]",
+		"",
+		"**Auto-converted**: Markdown tables become Flex cards, code blocks become styled cards.",
+		"",
+		"When to use rich messages:",
+		"- Use [[quick_replies:...]] when offering 2-4 clear options",
+		"- Use [[confirm:...]] for yes/no decisions",
+		"- Use [[buttons:...]] for menus with actions/links",
+		"- Use [[location:...]] when sharing a place",
+		"- Use [[media_player:...]] when showing what's playing",
+		"- Use [[event:...]] for calendar event details",
+		"- Use [[agenda:...]] for a day's schedule or event list",
+		"- Use [[device:...]] for smart device status/controls",
+		"- Tables/code in your response auto-convert to visual cards"
+	] }
+};
+//#endregion
+export { setLineRuntime as n, linePlugin as t };

package/dist/channel-options-PwBzYYtq.js

@@ -0,0 +1,50 @@
+import { t as isTruthyEnvValue } from "./env-D42cffog.js";
+import { Fw as listChannelPluginCatalogEntries, T as listChannelPlugins } from "./auth-profiles-C-Ul-Qkn.js";
+import { u as CHAT_CHANNEL_ORDER } from "./registry-C1pRrsQl.js";
+import { t as ensurePluginRegistryLoaded } from "./plugin-registry-QtjVXmj3.js";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cli/channel-options.ts
+function dedupe(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const value of values) {
+		if (!value || seen.has(value)) continue;
+		seen.add(value);
+		resolved.push(value);
+	}
+	return resolved;
+}
+let precomputedChannelOptions;
+function loadPrecomputedChannelOptions() {
+	if (precomputedChannelOptions !== void 0) return precomputedChannelOptions;
+	try {
+		const metadataPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "cli-startup-metadata.json");
+		const raw = fs.readFileSync(metadataPath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed.channelOptions)) {
+			precomputedChannelOptions = dedupe(parsed.channelOptions.filter((value) => typeof value === "string"));
+			return precomputedChannelOptions;
+		}
+	} catch {}
+	precomputedChannelOptions = null;
+	return null;
+}
+function resolveCliChannelOptions() {
+	if (isTruthyEnvValue(process.env.MOLDCLAW_EAGER_CHANNEL_OPTIONS)) {
+		const catalog = listChannelPluginCatalogEntries().map((entry) => entry.id);
+		const base = dedupe([...CHAT_CHANNEL_ORDER, ...catalog]);
+		ensurePluginRegistryLoaded();
+		const pluginIds = listChannelPlugins().map((plugin) => plugin.id);
+		return dedupe([...base, ...pluginIds]);
+	}
+	const precomputed = loadPrecomputedChannelOptions();
+	const catalog = listChannelPluginCatalogEntries().map((entry) => entry.id);
+	return precomputed ? dedupe([...precomputed, ...catalog]) : dedupe([...CHAT_CHANNEL_ORDER, ...catalog]);
+}
+function formatCliChannelOptions(extra = []) {
+	return [...extra, ...resolveCliChannelOptions()].join("|");
+}
+//#endregion
+export { resolveCliChannelOptions as n, formatCliChannelOptions as t };

package/dist/channel-plugin-ids-TZIY4hFs.js

@@ -0,0 +1,26 @@
+import { n as loadPluginManifestRegistry } from "./manifest-registry-CS_p1OBQ.js";
+import { R as listPotentialConfiguredChannelIds } from "./lazy-runtime-BoGB4usD.js";
+//#region src/plugins/channel-plugin-ids.ts
+function resolveChannelPluginIds(params) {
+	return loadPluginManifestRegistry({
+		config: params.config,
+		workspaceDir: params.workspaceDir,
+		env: params.env
+	}).plugins.filter((plugin) => plugin.channels.length > 0).map((plugin) => plugin.id);
+}
+function resolveConfiguredChannelPluginIds(params) {
+	const configuredChannelIds = new Set(listPotentialConfiguredChannelIds(params.config, params.env).map((id) => id.trim()));
+	if (configuredChannelIds.size === 0) return [];
+	return resolveChannelPluginIds(params).filter((pluginId) => configuredChannelIds.has(pluginId));
+}
+function resolveConfiguredDeferredChannelPluginIds(params) {
+	const configuredChannelIds = new Set(listPotentialConfiguredChannelIds(params.config, params.env).map((id) => id.trim()));
+	if (configuredChannelIds.size === 0) return [];
+	return loadPluginManifestRegistry({
+		config: params.config,
+		workspaceDir: params.workspaceDir,
+		env: params.env
+	}).plugins.filter((plugin) => plugin.channels.some((channelId) => configuredChannelIds.has(channelId)) && plugin.startupDeferConfiguredChannelFullLoadUntilAfterListen === true).map((plugin) => plugin.id);
+}
+//#endregion
+export { resolveConfiguredChannelPluginIds as n, resolveConfiguredDeferredChannelPluginIds as r, resolveChannelPluginIds as t };

package/dist/channel-summary-CCEAV13o.js

@@ -0,0 +1,111 @@
+import "./redact-fatrROh9.js";
+import "./errors-DOJWZqNo.js";
+import "./unhandled-rejections-CTvNvnT0.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 "./runtime-_tQz41uA.js";
+import "./ansi-BPhP6LBZ.js";
+import "./subsystem-CPmDTJ2P.js";
+import "./boolean-B6zcAynR.js";
+import "./env-D42cffog.js";
+import "./warning-filter-B1UOeM0G.js";
+import "./utils-C7ykRPCQ.js";
+import "./links-BcahUP5U.js";
+import "./setup-binary-CcAv8NXz.js";
+import { vc as buildChannelSummary } from "./auth-profiles-C-Ul-Qkn.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 "./provider-web-search-CcUC9ktE.js";
+import "./text-runtime-Cfq-Uyx0.js";
+import "./workspace-dirs-CGeIPpGN.js";
+import "./config-BwkGZjD5.js";
+import "./tailnet-fFTz5Twr.js";
+import "./net-K181nxTH.js";
+import "./credentials-D-5Pb-aZ.js";
+import "./routes-CcJNnwTF.js";
+import "./frontmatter-Cgg0ICvh.js";
+import "./env-overrides-DBQl3LRc.js";
+import "./path-alias-guards-BtSO7sk7.js";
+import "./skills-DE_MXFSN.js";
+import "./ports-Ca74cFb2.js";
+import "./ports-lsof-CoiADo0p.js";
+import "./ssh-tunnel-DsY-9yao.js";
+import "./image-ops-Ck_D_vpe.js";
+import "./fs-safe-CRXFoBmh.js";
+import "./mime-DGFQe4XX.js";
+import "./server-middleware-Djfoa1s0.js";
+import "./message-channel-DFE4FuE_.js";
+import "./resolve-route-DdX-HBVt.js";
+import "./internal-hooks-83AcmxP3.js";
+import "./lazy-runtime-BoGB4usD.js";
+import "./config-schema-BNU4GQh_.js";
+import "./method-scopes-B2ZKSsxQ.js";
+import "./session-cost-usage-DWgQk6XT.js";
+import "./paths-ApLcu1Uu.js";
+import "./routing-DQ-fpTaA.js";
+import "./send-B1pX9_Oc.js";
+import "./node-resolve-BYC2FbO2.js";
+import "./provider-stream-Chz_EFw3.js";
+import "./identity-file-Diub2a0t.js";
+import "./provider-models-xnyxy6mO.js";
+import "./secret-file-p1IhQzwJ.js";
+import "./logging-Dy7UYzIN.js";
+import "./runtime-env-BlEtPF6b.js";
+import "./registry-BFMbkmgR.js";
+import "./provider-onboard-B9ionepI.js";
+import "./model-definitions-Cyyzm6Kr.js";
+import "./usage-Czgwvg0h.js";
+import "./device-identity-IG5DngWM.js";
+import "./auth-Ch3Rchm4.js";
+import "./subscription-DaA1urx-.js";
+import "./diagnostic-DTPopFvh.js";
+import "./message-hook-mappers-CeiHXgSQ.js";
+import "./json-store--7cBPxTG.js";
+import "./call-gdDAt07d.js";
+import "./multimodal-BJBBn_4F.js";
+import "./memory-search-tTD5o_rU.js";
+import "./query-expansion-D_Mm5Hhi.js";
+import "./search-manager-D-G9UaXe.js";
+import "./core-BwKq3krw.js";
+import "./issue-format-B0SI57Es.js";
+import "./logging-CdisccbY.js";
+import "./note-dOl5kPAy.js";
+import "./state-paths-DsMoTg25.js";
+import "./config-value-DT3-5958.js";
+import "./command-secret-targets-BFF4x_RB.js";
+import "./brave-w4Fo8WZ3.js";
+import "./provider-usage-kxemdMp2.js";
+import "./perplexity-CXwMDD3u.js";
+import "./restart-stale-pids-CPF1_61W.js";
+import "./delivery-queue-BOf5wYIc.js";
+import "./pairing-token-bu1e6z6X.js";
+import "./accounts-J2OhhhQi.js";
+import "./process-runtime-D27SftX_.js";
+import "./audit-ChWS6RiF.js";
+import "./cli-runtime-DTCHPjCi.js";
+import "./cli-utils-BCuSS4l6.js";
+import "./help-format-BFzPm_8V.js";
+import "./progress-Cwq59vgZ.js";
+import "./gateway-runtime-CBm3CCoA.js";
+export { buildChannelSummary };