remoteclaw 0.0.0 → 0.1.0-next.2abd2fa

package/dist/subsystem-COd61u0P.js

@@ -0,0 +1,1139 @@
+import { D as isVerbose, G as loggingState, J as normalizeLogLevel, R as getChildLogger, U as resolveNodeRequireFromMeta, V as isFileLogLevelEnabled, W as resolveEnvLogLevelOverride, X as readLoggingConfig, _ as resolveUserPath, k as logVerbose, q as levelToMinLevel, z as getLogger } from "./utils-LBKvDoPx.js";
+import { i as clearActiveProgressLine, n as defaultRuntime } from "./runtime-DJNp29jv.js";
+import { t as stripAnsi } from "./ansi-D04X81yq.js";
+import path from "node:path";
+import { Chalk } from "chalk";
+import util from "node:util";
+
+//#region src/hooks/internal-hooks.ts
+/** Registry of hook handlers by event key */
+const handlers = /* @__PURE__ */ new Map();
+const log = createSubsystemLogger("internal-hooks");
+/**
+* Register a hook handler for a specific event type or event:action combination
+*
+* @param eventKey - Event type (e.g., 'command') or specific action (e.g., 'command:new')
+* @param handler - Function to call when the event is triggered
+*
+* @example
+* ```ts
+* // Listen to all command events
+* registerInternalHook('command', async (event) => {
+*   console.log('Command:', event.action);
+* });
+*
+* // Listen only to /new commands
+* registerInternalHook('command:new', async (event) => {
+*   await saveSessionToMemory(event);
+* });
+* ```
+*/
+function registerInternalHook(eventKey, handler) {
+	if (!handlers.has(eventKey)) handlers.set(eventKey, []);
+	handlers.get(eventKey).push(handler);
+}
+/**
+* Clear all registered hooks (useful for testing)
+*/
+function clearInternalHooks() {
+	handlers.clear();
+}
+/**
+* Trigger a hook event
+*
+* Calls all handlers registered for:
+* 1. The general event type (e.g., 'command')
+* 2. The specific event:action combination (e.g., 'command:new')
+*
+* Handlers are called in registration order. Errors are caught and logged
+* but don't prevent other handlers from running.
+*
+* @param event - The event to trigger
+*/
+async function triggerInternalHook(event) {
+	const typeHandlers = handlers.get(event.type) ?? [];
+	const specificHandlers = handlers.get(`${event.type}:${event.action}`) ?? [];
+	const allHandlers = [...typeHandlers, ...specificHandlers];
+	if (allHandlers.length === 0) return;
+	for (const handler of allHandlers) try {
+		await handler(event);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		log.error(`Hook error [${event.type}:${event.action}]: ${message}`);
+	}
+}
+/**
+* Create a hook event with common fields filled in
+*
+* @param type - The event type
+* @param action - The action within that type
+* @param sessionKey - The session key
+* @param context - Additional context
+*/
+function createInternalHookEvent(type, action, sessionKey, context = {}) {
+	return {
+		type,
+		action,
+		sessionKey,
+		context,
+		timestamp: /* @__PURE__ */ new Date(),
+		messages: []
+	};
+}
+
+//#endregion
+//#region src/plugins/commands.ts
+const pluginCommands = /* @__PURE__ */ new Map();
+let registryLocked = false;
+const MAX_ARGS_LENGTH = 4096;
+/**
+* Reserved command names that plugins cannot override.
+* These are built-in commands from commands-registry.data.ts.
+*/
+const RESERVED_COMMANDS = new Set([
+	"help",
+	"commands",
+	"status",
+	"whoami",
+	"context",
+	"stop",
+	"restart",
+	"reset",
+	"new",
+	"compact",
+	"config",
+	"debug",
+	"allowlist",
+	"activation",
+	"skill",
+	"subagents",
+	"kill",
+	"steer",
+	"tell",
+	"model",
+	"models",
+	"queue",
+	"send",
+	"bash",
+	"think",
+	"verbose",
+	"reasoning",
+	"elevated",
+	"usage"
+]);
+/**
+* Validate a command name.
+* Returns an error message if invalid, or null if valid.
+*/
+function validateCommandName(name) {
+	const trimmed = name.trim().toLowerCase();
+	if (!trimmed) return "Command name cannot be empty";
+	if (!/^[a-z][a-z0-9_-]*$/.test(trimmed)) return "Command name must start with a letter and contain only letters, numbers, hyphens, and underscores";
+	if (RESERVED_COMMANDS.has(trimmed)) return `Command name "${trimmed}" is reserved by a built-in command`;
+	return null;
+}
+/**
+* Register a plugin command.
+* Returns an error if the command name is invalid or reserved.
+*/
+function registerPluginCommand(pluginId, command) {
+	if (registryLocked) return {
+		ok: false,
+		error: "Cannot register commands while processing is in progress"
+	};
+	if (typeof command.handler !== "function") return {
+		ok: false,
+		error: "Command handler must be a function"
+	};
+	const validationError = validateCommandName(command.name);
+	if (validationError) return {
+		ok: false,
+		error: validationError
+	};
+	const key = `/${command.name.toLowerCase()}`;
+	if (pluginCommands.has(key)) {
+		const existing = pluginCommands.get(key);
+		return {
+			ok: false,
+			error: `Command "${command.name}" already registered by plugin "${existing.pluginId}"`
+		};
+	}
+	pluginCommands.set(key, {
+		...command,
+		pluginId
+	});
+	logVerbose(`Registered plugin command: ${key} (plugin: ${pluginId})`);
+	return { ok: true };
+}
+/**
+* Clear all registered plugin commands.
+* Called during plugin reload.
+*/
+function clearPluginCommands() {
+	pluginCommands.clear();
+}
+/**
+* Check if a command body matches a registered plugin command.
+* Returns the command definition and parsed args if matched.
+*
+* Note: If a command has `acceptsArgs: false` and the user provides arguments,
+* the command will not match. This allows the message to fall through to
+* built-in handlers or the agent. Document this behavior to plugin authors.
+*/
+function matchPluginCommand(commandBody) {
+	const trimmed = commandBody.trim();
+	if (!trimmed.startsWith("/")) return null;
+	const spaceIndex = trimmed.indexOf(" ");
+	const commandName = spaceIndex === -1 ? trimmed : trimmed.slice(0, spaceIndex);
+	const args = spaceIndex === -1 ? void 0 : trimmed.slice(spaceIndex + 1).trim();
+	const key = commandName.toLowerCase();
+	const command = pluginCommands.get(key);
+	if (!command) return null;
+	if (args && !command.acceptsArgs) return null;
+	return {
+		command,
+		args: args || void 0
+	};
+}
+/**
+* Sanitize command arguments to prevent injection attacks.
+* Removes control characters and enforces length limits.
+*/
+function sanitizeArgs(args) {
+	if (!args) return;
+	if (args.length > MAX_ARGS_LENGTH) return args.slice(0, MAX_ARGS_LENGTH);
+	let sanitized = "";
+	for (const char of args) {
+		const code = char.charCodeAt(0);
+		if (!(code <= 31 && code !== 9 && code !== 10 || code === 127)) sanitized += char;
+	}
+	return sanitized;
+}
+/**
+* Execute a plugin command handler.
+*
+* Note: Plugin authors should still validate and sanitize ctx.args for their
+* specific use case. This function provides basic defense-in-depth sanitization.
+*/
+async function executePluginCommand(params) {
+	const { command, args, senderId, channel, isAuthorizedSender, commandBody, config } = params;
+	if (command.requireAuth !== false && !isAuthorizedSender) {
+		logVerbose(`Plugin command /${command.name} blocked: unauthorized sender ${senderId || "<unknown>"}`);
+		return { text: "⚠️ This command requires authorization." };
+	}
+	const sanitizedArgs = sanitizeArgs(args);
+	const ctx = {
+		senderId,
+		channel,
+		channelId: params.channelId,
+		isAuthorizedSender,
+		args: sanitizedArgs,
+		commandBody,
+		config,
+		from: params.from,
+		to: params.to,
+		accountId: params.accountId,
+		messageThreadId: params.messageThreadId
+	};
+	registryLocked = true;
+	try {
+		const result = await command.handler(ctx);
+		logVerbose(`Plugin command /${command.name} executed successfully for ${senderId || "unknown"}`);
+		return result;
+	} catch (err) {
+		const error = err;
+		logVerbose(`Plugin command /${command.name} error: ${error.message}`);
+		return { text: "⚠️ Command failed. Please try again later." };
+	} finally {
+		registryLocked = false;
+	}
+}
+/**
+* List all registered plugin commands.
+* Used for /help and /commands output.
+*/
+function listPluginCommands() {
+	return Array.from(pluginCommands.values()).map((cmd) => ({
+		name: cmd.name,
+		description: cmd.description,
+		pluginId: cmd.pluginId
+	}));
+}
+/**
+* Get plugin command specs for native command registration (e.g., Telegram).
+*/
+function getPluginCommandSpecs() {
+	return Array.from(pluginCommands.values()).map((cmd) => ({
+		name: cmd.name,
+		description: cmd.description
+	}));
+}
+
+//#endregion
+//#region src/plugins/http-path.ts
+function normalizePluginHttpPath(path, fallback) {
+	const trimmed = path?.trim();
+	if (!trimmed) {
+		const fallbackTrimmed = fallback?.trim();
+		if (!fallbackTrimmed) return null;
+		return fallbackTrimmed.startsWith("/") ? fallbackTrimmed : `/${fallbackTrimmed}`;
+	}
+	return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+//#endregion
+//#region src/plugins/registry.ts
+function createEmptyPluginRegistry() {
+	return {
+		plugins: [],
+		tools: [],
+		hooks: [],
+		typedHooks: [],
+		channels: [],
+		providers: [],
+		gatewayHandlers: {},
+		httpHandlers: [],
+		httpRoutes: [],
+		cliRegistrars: [],
+		services: [],
+		commands: [],
+		diagnostics: []
+	};
+}
+/**
+* Hooks that belonged to the in-process LLM execution pipeline.
+* Their trigger points no longer exist in CLI-only mode — registrations
+* are silently dropped with a diagnostic warning.
+*/
+const DEAD_HOOKS = new Set([
+	"before_model_resolve",
+	"before_prompt_build",
+	"before_agent_start",
+	"llm_input",
+	"llm_output",
+	"before_compaction",
+	"after_compaction",
+	"tool_result_persist"
+]);
+function createPluginRegistry(registryParams) {
+	const registry = createEmptyPluginRegistry();
+	const coreGatewayMethods = new Set(Object.keys(registryParams.coreGatewayHandlers ?? {}));
+	const pushDiagnostic = (diag) => {
+		registry.diagnostics.push(diag);
+	};
+	const registerTool = (record, tool, opts) => {
+		const names = opts?.names ?? (opts?.name ? [opts.name] : []);
+		const optional = opts?.optional === true;
+		const factory = typeof tool === "function" ? tool : (_ctx) => tool;
+		if (typeof tool !== "function") names.push(tool.name);
+		const normalized = names.map((name) => name.trim()).filter(Boolean);
+		if (normalized.length > 0) record.toolNames.push(...normalized);
+		registry.tools.push({
+			pluginId: record.id,
+			factory,
+			names: normalized,
+			optional,
+			source: record.source
+		});
+	};
+	const registerHook = (record, events, handler, opts, config) => {
+		const trimmedEvents = (Array.isArray(events) ? events : [events]).map((event) => event.trim()).filter(Boolean);
+		const normalizedEvents = [];
+		for (const event of trimmedEvents) {
+			if (DEAD_HOOKS.has(event)) {
+				pushDiagnostic({
+					level: "warn",
+					pluginId: record.id,
+					source: record.source,
+					message: `Hook "${event}" is not available in CLI-only mode. LLM pipeline hooks are managed by the CLI agent runtime. This hook will not fire.`
+				});
+				continue;
+			}
+			normalizedEvents.push(event);
+		}
+		if (normalizedEvents.length === 0) return;
+		const entry = opts?.entry ?? null;
+		const name = entry?.hook.name ?? opts?.name?.trim();
+		if (!name) {
+			pushDiagnostic({
+				level: "warn",
+				pluginId: record.id,
+				source: record.source,
+				message: "hook registration missing name"
+			});
+			return;
+		}
+		const description = entry?.hook.description ?? opts?.description ?? "";
+		const hookEntry = entry ? {
+			...entry,
+			hook: {
+				...entry.hook,
+				name,
+				description,
+				source: "remoteclaw-plugin",
+				pluginId: record.id
+			},
+			metadata: {
+				...entry.metadata,
+				events: normalizedEvents
+			}
+		} : {
+			hook: {
+				name,
+				description,
+				source: "remoteclaw-plugin",
+				pluginId: record.id,
+				filePath: record.source,
+				baseDir: path.dirname(record.source),
+				handlerPath: record.source
+			},
+			frontmatter: {},
+			metadata: { events: normalizedEvents },
+			invocation: { enabled: true }
+		};
+		record.hookNames.push(name);
+		registry.hooks.push({
+			pluginId: record.id,
+			entry: hookEntry,
+			events: normalizedEvents,
+			source: record.source
+		});
+		if (!(config?.hooks?.internal?.enabled === true) || opts?.register === false) return;
+		for (const event of normalizedEvents) registerInternalHook(event, handler);
+	};
+	const registerGatewayMethod = (record, method, handler) => {
+		const trimmed = method.trim();
+		if (!trimmed) return;
+		if (coreGatewayMethods.has(trimmed) || registry.gatewayHandlers[trimmed]) {
+			pushDiagnostic({
+				level: "error",
+				pluginId: record.id,
+				source: record.source,
+				message: `gateway method already registered: ${trimmed}`
+			});
+			return;
+		}
+		registry.gatewayHandlers[trimmed] = handler;
+		record.gatewayMethods.push(trimmed);
+	};
+	const registerHttpHandler = (record, handler) => {
+		record.httpHandlers += 1;
+		registry.httpHandlers.push({
+			pluginId: record.id,
+			handler,
+			source: record.source
+		});
+	};
+	const registerHttpRoute = (record, params) => {
+		const normalizedPath = normalizePluginHttpPath(params.path);
+		if (!normalizedPath) {
+			pushDiagnostic({
+				level: "warn",
+				pluginId: record.id,
+				source: record.source,
+				message: "http route registration missing path"
+			});
+			return;
+		}
+		if (registry.httpRoutes.some((entry) => entry.path === normalizedPath)) {
+			pushDiagnostic({
+				level: "error",
+				pluginId: record.id,
+				source: record.source,
+				message: `http route already registered: ${normalizedPath}`
+			});
+			return;
+		}
+		record.httpHandlers += 1;
+		registry.httpRoutes.push({
+			pluginId: record.id,
+			path: normalizedPath,
+			handler: params.handler,
+			source: record.source
+		});
+	};
+	const registerChannel = (record, registration) => {
+		const normalized = typeof registration.plugin === "object" ? registration : { plugin: registration };
+		const plugin = normalized.plugin;
+		const id = typeof plugin?.id === "string" ? plugin.id.trim() : String(plugin?.id ?? "").trim();
+		if (!id) {
+			pushDiagnostic({
+				level: "error",
+				pluginId: record.id,
+				source: record.source,
+				message: "channel registration missing id"
+			});
+			return;
+		}
+		record.channelIds.push(id);
+		registry.channels.push({
+			pluginId: record.id,
+			plugin,
+			dock: normalized.dock,
+			source: record.source
+		});
+	};
+	const registerCli = (record, registrar, opts) => {
+		const commands = (opts?.commands ?? []).map((cmd) => cmd.trim()).filter(Boolean);
+		record.cliCommands.push(...commands);
+		registry.cliRegistrars.push({
+			pluginId: record.id,
+			register: registrar,
+			commands,
+			source: record.source
+		});
+	};
+	const registerService = (record, service) => {
+		const id = service.id.trim();
+		if (!id) return;
+		record.services.push(id);
+		registry.services.push({
+			pluginId: record.id,
+			service,
+			source: record.source
+		});
+	};
+	const registerCommand = (record, command) => {
+		const name = command.name.trim();
+		if (!name) {
+			pushDiagnostic({
+				level: "error",
+				pluginId: record.id,
+				source: record.source,
+				message: "command registration missing name"
+			});
+			return;
+		}
+		const result = registerPluginCommand(record.id, command);
+		if (!result.ok) {
+			pushDiagnostic({
+				level: "error",
+				pluginId: record.id,
+				source: record.source,
+				message: `command registration failed: ${result.error}`
+			});
+			return;
+		}
+		record.commands.push(name);
+		registry.commands.push({
+			pluginId: record.id,
+			command,
+			source: record.source
+		});
+	};
+	const registerTypedHook = (record, hookName, handler, opts) => {
+		record.hookCount += 1;
+		registry.typedHooks.push({
+			pluginId: record.id,
+			hookName,
+			handler,
+			priority: opts?.priority,
+			source: record.source
+		});
+	};
+	const normalizeLogger = (logger) => ({
+		info: logger.info,
+		warn: logger.warn,
+		error: logger.error,
+		debug: logger.debug
+	});
+	const createApi = (record, params) => {
+		return {
+			id: record.id,
+			name: record.name,
+			version: record.version,
+			description: record.description,
+			source: record.source,
+			config: params.config,
+			pluginConfig: params.pluginConfig,
+			runtime: registryParams.runtime,
+			logger: normalizeLogger(registryParams.logger),
+			registerTool: (tool, opts) => registerTool(record, tool, opts),
+			registerHook: (events, handler, opts) => registerHook(record, events, handler, opts, params.config),
+			registerHttpHandler: (handler) => registerHttpHandler(record, handler),
+			registerHttpRoute: (params) => registerHttpRoute(record, params),
+			registerChannel: (registration) => registerChannel(record, registration),
+			registerGatewayMethod: (method, handler) => registerGatewayMethod(record, method, handler),
+			registerCli: (registrar, opts) => registerCli(record, registrar, opts),
+			registerService: (service) => registerService(record, service),
+			registerCommand: (command) => registerCommand(record, command),
+			resolvePath: (input) => resolveUserPath(input),
+			on: (hookName, handler, opts) => {
+				if (DEAD_HOOKS.has(hookName)) {
+					pushDiagnostic({
+						level: "warn",
+						pluginId: record.id,
+						source: record.source,
+						message: `Hook "${hookName}" is not available in CLI-only mode. LLM pipeline hooks are managed by the CLI agent runtime. This hook will not fire.`
+					});
+					return;
+				}
+				registerTypedHook(record, hookName, handler, opts);
+			}
+		};
+	};
+	return {
+		registry,
+		createApi,
+		pushDiagnostic,
+		registerTool,
+		registerChannel,
+		registerGatewayMethod,
+		registerCli,
+		registerService,
+		registerCommand,
+		registerHook,
+		registerTypedHook
+	};
+}
+
+//#endregion
+//#region src/plugins/runtime.ts
+const REGISTRY_STATE = Symbol.for("remoteclaw.pluginRegistryState");
+const state = (() => {
+	const globalState = globalThis;
+	if (!globalState[REGISTRY_STATE]) globalState[REGISTRY_STATE] = {
+		registry: createEmptyPluginRegistry(),
+		key: null
+	};
+	return globalState[REGISTRY_STATE];
+})();
+function setActivePluginRegistry(registry, cacheKey) {
+	state.registry = registry;
+	state.key = cacheKey ?? null;
+}
+function getActivePluginRegistry() {
+	return state.registry;
+}
+function requireActivePluginRegistry() {
+	if (!state.registry) state.registry = createEmptyPluginRegistry();
+	return state.registry;
+}
+
+//#endregion
+//#region src/channels/registry.ts
+const CHAT_CHANNEL_ORDER = [
+	"telegram",
+	"whatsapp",
+	"discord",
+	"irc",
+	"googlechat",
+	"slack",
+	"signal",
+	"imessage"
+];
+const CHANNEL_IDS = [...CHAT_CHANNEL_ORDER];
+const CHAT_CHANNEL_META = {
+	telegram: {
+		id: "telegram",
+		label: "Telegram",
+		selectionLabel: "Telegram (Bot API)",
+		detailLabel: "Telegram Bot",
+		docsPath: "/channels/telegram",
+		docsLabel: "telegram",
+		blurb: "simplest way to get started — register a bot with @BotFather and get going.",
+		systemImage: "paperplane",
+		selectionDocsPrefix: "",
+		selectionDocsOmitLabel: true,
+		selectionExtras: ["https://remoteclaw.org"]
+	},
+	whatsapp: {
+		id: "whatsapp",
+		label: "WhatsApp",
+		selectionLabel: "WhatsApp (QR link)",
+		detailLabel: "WhatsApp Web",
+		docsPath: "/channels/whatsapp",
+		docsLabel: "whatsapp",
+		blurb: "works with your own number; recommend a separate phone + eSIM.",
+		systemImage: "message"
+	},
+	discord: {
+		id: "discord",
+		label: "Discord",
+		selectionLabel: "Discord (Bot API)",
+		detailLabel: "Discord Bot",
+		docsPath: "/channels/discord",
+		docsLabel: "discord",
+		blurb: "very well supported right now.",
+		systemImage: "bubble.left.and.bubble.right"
+	},
+	irc: {
+		id: "irc",
+		label: "IRC",
+		selectionLabel: "IRC (Server + Nick)",
+		detailLabel: "IRC",
+		docsPath: "/channels/irc",
+		docsLabel: "irc",
+		blurb: "classic IRC networks with DM/channel routing and pairing controls.",
+		systemImage: "network"
+	},
+	googlechat: {
+		id: "googlechat",
+		label: "Google Chat",
+		selectionLabel: "Google Chat (Chat API)",
+		detailLabel: "Google Chat",
+		docsPath: "/channels/googlechat",
+		docsLabel: "googlechat",
+		blurb: "Google Workspace Chat app with HTTP webhook.",
+		systemImage: "message.badge"
+	},
+	slack: {
+		id: "slack",
+		label: "Slack",
+		selectionLabel: "Slack (Socket Mode)",
+		detailLabel: "Slack Bot",
+		docsPath: "/channels/slack",
+		docsLabel: "slack",
+		blurb: "supported (Socket Mode).",
+		systemImage: "number"
+	},
+	signal: {
+		id: "signal",
+		label: "Signal",
+		selectionLabel: "Signal (signal-cli)",
+		detailLabel: "Signal REST",
+		docsPath: "/channels/signal",
+		docsLabel: "signal",
+		blurb: "signal-cli linked device; more setup (David Reagans: \"Hop on Discord.\").",
+		systemImage: "antenna.radiowaves.left.and.right"
+	},
+	imessage: {
+		id: "imessage",
+		label: "iMessage",
+		selectionLabel: "iMessage (imsg)",
+		detailLabel: "iMessage",
+		docsPath: "/channels/imessage",
+		docsLabel: "imessage",
+		blurb: "this is still a work in progress.",
+		systemImage: "message.fill"
+	}
+};
+const CHAT_CHANNEL_ALIASES = {
+	imsg: "imessage",
+	"internet-relay-chat": "irc",
+	"google-chat": "googlechat",
+	gchat: "googlechat"
+};
+const normalizeChannelKey = (raw) => {
+	return raw?.trim().toLowerCase() || void 0;
+};
+function listChatChannels() {
+	return CHAT_CHANNEL_ORDER.map((id) => CHAT_CHANNEL_META[id]);
+}
+function getChatChannelMeta(id) {
+	return CHAT_CHANNEL_META[id];
+}
+function normalizeChatChannelId(raw) {
+	const normalized = normalizeChannelKey(raw);
+	if (!normalized) return null;
+	const resolved = CHAT_CHANNEL_ALIASES[normalized] ?? normalized;
+	return CHAT_CHANNEL_ORDER.includes(resolved) ? resolved : null;
+}
+function normalizeChannelId(raw) {
+	return normalizeChatChannelId(raw);
+}
+function normalizeAnyChannelId(raw) {
+	const key = normalizeChannelKey(raw);
+	if (!key) return null;
+	return requireActivePluginRegistry().channels.find((entry) => {
+		const id = String(entry.plugin.id ?? "").trim().toLowerCase();
+		if (id && id === key) return true;
+		return (entry.plugin.meta.aliases ?? []).some((alias) => alias.trim().toLowerCase() === key);
+	})?.plugin.id ?? null;
+}
+function formatChannelPrimerLine(meta) {
+	return `${meta.label}: ${meta.blurb}`;
+}
+function formatChannelSelectionLine(meta, docsLink) {
+	const docsPrefix = meta.selectionDocsPrefix ?? "Docs:";
+	const docsLabel = meta.docsLabel ?? meta.id;
+	const docs = meta.selectionDocsOmitLabel ? docsLink(meta.docsPath) : docsLink(meta.docsPath, docsLabel);
+	const extras = (meta.selectionExtras ?? []).filter(Boolean).join(" ");
+	return `${meta.label} — ${meta.blurb} ${docsPrefix ? `${docsPrefix} ` : ""}${docs}${extras ? ` ${extras}` : ""}`;
+}
+
+//#endregion
+//#region src/logging/timestamps.ts
+function formatLocalIsoWithOffset(now) {
+	const year = now.getFullYear();
+	const month = String(now.getMonth() + 1).padStart(2, "0");
+	const day = String(now.getDate()).padStart(2, "0");
+	const h = String(now.getHours()).padStart(2, "0");
+	const m = String(now.getMinutes()).padStart(2, "0");
+	const s = String(now.getSeconds()).padStart(2, "0");
+	const ms = String(now.getMilliseconds()).padStart(3, "0");
+	const tzOffset = now.getTimezoneOffset();
+	return `${year}-${month}-${day}T${h}:${m}:${s}.${ms}${tzOffset <= 0 ? "+" : "-"}${String(Math.floor(Math.abs(tzOffset) / 60)).padStart(2, "0")}:${String(Math.abs(tzOffset) % 60).padStart(2, "0")}`;
+}
+
+//#endregion
+//#region src/logging/console.ts
+const requireConfig = resolveNodeRequireFromMeta(import.meta.url);
+const loadConfigFallbackDefault = () => {
+	try {
+		return (requireConfig?.("../config/config.js"))?.loadConfig?.().logging;
+	} catch {
+		return;
+	}
+};
+let loadConfigFallback = loadConfigFallbackDefault;
+function normalizeConsoleLevel(level) {
+	if (isVerbose()) return "debug";
+	if (!level && process.env.VITEST === "true" && process.env.REMOTECLAW_TEST_CONSOLE !== "1") return "silent";
+	return normalizeLogLevel(level, "info");
+}
+function normalizeConsoleStyle(style) {
+	if (style === "compact" || style === "json" || style === "pretty") return style;
+	if (!process.stdout.isTTY) return "compact";
+	return "pretty";
+}
+function resolveConsoleSettings() {
+	let cfg = loggingState.overrideSettings ?? readLoggingConfig();
+	if (!cfg) if (loggingState.resolvingConsoleSettings) cfg = void 0;
+	else {
+		loggingState.resolvingConsoleSettings = true;
+		try {
+			cfg = loadConfigFallback();
+		} finally {
+			loggingState.resolvingConsoleSettings = false;
+		}
+	}
+	return {
+		level: resolveEnvLogLevelOverride() ?? normalizeConsoleLevel(cfg?.consoleLevel),
+		style: normalizeConsoleStyle(cfg?.consoleStyle)
+	};
+}
+function consoleSettingsChanged(a, b) {
+	if (!a) return true;
+	return a.level !== b.level || a.style !== b.style;
+}
+function getConsoleSettings() {
+	const settings = resolveConsoleSettings();
+	const cached = loggingState.cachedConsoleSettings;
+	if (!cached || consoleSettingsChanged(cached, settings)) loggingState.cachedConsoleSettings = settings;
+	return loggingState.cachedConsoleSettings;
+}
+function routeLogsToStderr() {
+	loggingState.forceConsoleToStderr = true;
+}
+function setConsoleSubsystemFilter(filters) {
+	if (!filters || filters.length === 0) {
+		loggingState.consoleSubsystemFilter = null;
+		return;
+	}
+	const normalized = filters.map((value) => value.trim()).filter((value) => value.length > 0);
+	loggingState.consoleSubsystemFilter = normalized.length > 0 ? normalized : null;
+}
+function setConsoleTimestampPrefix(enabled) {
+	loggingState.consoleTimestampPrefix = enabled;
+}
+function shouldLogSubsystemToConsole(subsystem) {
+	const filter = loggingState.consoleSubsystemFilter;
+	if (!filter || filter.length === 0) return true;
+	return filter.some((prefix) => subsystem === prefix || subsystem.startsWith(`${prefix}/`));
+}
+const SUPPRESSED_CONSOLE_PREFIXES = [
+	"Closing session:",
+	"Opening session:",
+	"Removing old closed session:",
+	"Session already closed",
+	"Session already open"
+];
+function shouldSuppressConsoleMessage(message) {
+	if (isVerbose()) return false;
+	if (SUPPRESSED_CONSOLE_PREFIXES.some((prefix) => message.startsWith(prefix))) return true;
+	if (message.startsWith("[EventQueue] Slow listener detected") && message.includes("DiscordMessageListener")) return true;
+	return false;
+}
+function isEpipeError(err) {
+	const code = err?.code;
+	return code === "EPIPE" || code === "EIO";
+}
+function formatConsoleTimestamp(style) {
+	const now = /* @__PURE__ */ new Date();
+	if (style === "pretty") return `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`;
+	return formatLocalIsoWithOffset(now);
+}
+function hasTimestampPrefix(value) {
+	return /^(?:\d{2}:\d{2}:\d{2}|\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)/.test(value);
+}
+function isJsonPayload(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return false;
+	try {
+		JSON.parse(trimmed);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Route console.* calls through file logging while still emitting to stdout/stderr.
+* This keeps user-facing output unchanged but guarantees every console call is captured in log files.
+*/
+function enableConsoleCapture() {
+	if (loggingState.consolePatched) return;
+	loggingState.consolePatched = true;
+	if (!loggingState.streamErrorHandlersInstalled) {
+		loggingState.streamErrorHandlersInstalled = true;
+		for (const stream of [process.stdout, process.stderr]) stream.on("error", (err) => {
+			if (isEpipeError(err)) return;
+			throw err;
+		});
+	}
+	let logger = null;
+	const getLoggerLazy = () => {
+		if (!logger) logger = getLogger();
+		return logger;
+	};
+	const original = {
+		log: console.log,
+		info: console.info,
+		warn: console.warn,
+		error: console.error,
+		debug: console.debug,
+		trace: console.trace
+	};
+	loggingState.rawConsole = {
+		log: original.log,
+		info: original.info,
+		warn: original.warn,
+		error: original.error
+	};
+	const forward = (level, orig) => (...args) => {
+		const formatted = util.format(...args);
+		if (shouldSuppressConsoleMessage(formatted)) return;
+		const trimmed = stripAnsi(formatted).trimStart();
+		const timestamp = loggingState.consoleTimestampPrefix && trimmed.length > 0 && !hasTimestampPrefix(trimmed) && !isJsonPayload(trimmed) ? formatConsoleTimestamp(getConsoleSettings().style) : "";
+		try {
+			const resolvedLogger = getLoggerLazy();
+			if (level === "trace") resolvedLogger.trace(formatted);
+			else if (level === "debug") resolvedLogger.debug(formatted);
+			else if (level === "info") resolvedLogger.info(formatted);
+			else if (level === "warn") resolvedLogger.warn(formatted);
+			else if (level === "error" || level === "fatal") resolvedLogger.error(formatted);
+			else resolvedLogger.info(formatted);
+		} catch {}
+		if (loggingState.forceConsoleToStderr) try {
+			const line = timestamp ? `${timestamp} ${formatted}` : formatted;
+			process.stderr.write(`${line}\n`);
+		} catch (err) {
+			if (isEpipeError(err)) return;
+			throw err;
+		}
+		else try {
+			if (!timestamp) {
+				orig.apply(console, args);
+				return;
+			}
+			if (args.length === 0) {
+				orig.call(console, timestamp);
+				return;
+			}
+			if (typeof args[0] === "string") {
+				orig.call(console, `${timestamp} ${args[0]}`, ...args.slice(1));
+				return;
+			}
+			orig.call(console, timestamp, ...args);
+		} catch (err) {
+			if (isEpipeError(err)) return;
+			throw err;
+		}
+	};
+	console.log = forward("info", original.log);
+	console.info = forward("info", original.info);
+	console.warn = forward("warn", original.warn);
+	console.error = forward("error", original.error);
+	console.debug = forward("debug", original.debug);
+	console.trace = forward("trace", original.trace);
+}
+
+//#endregion
+//#region src/logging/subsystem.ts
+function shouldLogToConsole(level, settings) {
+	if (settings.level === "silent") return false;
+	return levelToMinLevel(level) <= levelToMinLevel(settings.level);
+}
+const inspectValue = (() => {
+	const getBuiltinModule = process.getBuiltinModule;
+	if (typeof getBuiltinModule !== "function") return null;
+	try {
+		const utilNamespace = getBuiltinModule("util");
+		return typeof utilNamespace.inspect === "function" ? utilNamespace.inspect : null;
+	} catch {
+		return null;
+	}
+})();
+function formatRuntimeArg(arg) {
+	if (typeof arg === "string") return arg;
+	if (inspectValue) return inspectValue(arg);
+	try {
+		return JSON.stringify(arg);
+	} catch {
+		return String(arg);
+	}
+}
+function isRichConsoleEnv() {
+	const term = (process.env.TERM ?? "").toLowerCase();
+	if (process.env.COLORTERM || process.env.TERM_PROGRAM) return true;
+	return term.length > 0 && term !== "dumb";
+}
+function getColorForConsole() {
+	const hasForceColor = typeof process.env.FORCE_COLOR === "string" && process.env.FORCE_COLOR.trim().length > 0 && process.env.FORCE_COLOR.trim() !== "0";
+	if (process.env.NO_COLOR && !hasForceColor) return new Chalk({ level: 0 });
+	return Boolean(process.stdout.isTTY || process.stderr.isTTY) || isRichConsoleEnv() ? new Chalk({ level: 1 }) : new Chalk({ level: 0 });
+}
+const SUBSYSTEM_COLORS = [
+	"cyan",
+	"green",
+	"yellow",
+	"blue",
+	"magenta",
+	"red"
+];
+const SUBSYSTEM_COLOR_OVERRIDES = { "gmail-watcher": "blue" };
+const SUBSYSTEM_PREFIXES_TO_DROP = [
+	"gateway",
+	"channels",
+	"providers"
+];
+const SUBSYSTEM_MAX_SEGMENTS = 2;
+const CHANNEL_SUBSYSTEM_PREFIXES = new Set(CHAT_CHANNEL_ORDER);
+function pickSubsystemColor(color, subsystem) {
+	const override = SUBSYSTEM_COLOR_OVERRIDES[subsystem];
+	if (override) return color[override];
+	let hash = 0;
+	for (let i = 0; i < subsystem.length; i += 1) hash = hash * 31 + subsystem.charCodeAt(i) | 0;
+	return color[SUBSYSTEM_COLORS[Math.abs(hash) % SUBSYSTEM_COLORS.length]];
+}
+function formatSubsystemForConsole(subsystem) {
+	const parts = subsystem.split("/").filter(Boolean);
+	const original = parts.join("/") || subsystem;
+	while (parts.length > 0 && SUBSYSTEM_PREFIXES_TO_DROP.includes(parts[0])) parts.shift();
+	if (parts.length === 0) return original;
+	if (CHANNEL_SUBSYSTEM_PREFIXES.has(parts[0])) return parts[0];
+	if (parts.length > SUBSYSTEM_MAX_SEGMENTS) return parts.slice(-SUBSYSTEM_MAX_SEGMENTS).join("/");
+	return parts.join("/");
+}
+function stripRedundantSubsystemPrefixForConsole(message, displaySubsystem) {
+	if (!displaySubsystem) return message;
+	if (message.startsWith("[")) {
+		const closeIdx = message.indexOf("]");
+		if (closeIdx > 1) {
+			if (message.slice(1, closeIdx).toLowerCase() === displaySubsystem.toLowerCase()) {
+				let i = closeIdx + 1;
+				while (message[i] === " ") i += 1;
+				return message.slice(i);
+			}
+		}
+	}
+	if (message.slice(0, displaySubsystem.length).toLowerCase() !== displaySubsystem.toLowerCase()) return message;
+	const next = message.slice(displaySubsystem.length, displaySubsystem.length + 1);
+	if (next !== ":" && next !== " ") return message;
+	let i = displaySubsystem.length;
+	while (message[i] === " ") i += 1;
+	if (message[i] === ":") i += 1;
+	while (message[i] === " ") i += 1;
+	return message.slice(i);
+}
+function formatConsoleLine(opts) {
+	const displaySubsystem = opts.style === "json" ? opts.subsystem : formatSubsystemForConsole(opts.subsystem);
+	if (opts.style === "json") return JSON.stringify({
+		time: (/* @__PURE__ */ new Date()).toISOString(),
+		level: opts.level,
+		subsystem: displaySubsystem,
+		message: opts.message,
+		...opts.meta
+	});
+	const color = getColorForConsole();
+	const prefix = `[${displaySubsystem}]`;
+	const prefixColor = pickSubsystemColor(color, displaySubsystem);
+	const levelColor = opts.level === "error" || opts.level === "fatal" ? color.red : opts.level === "warn" ? color.yellow : opts.level === "debug" || opts.level === "trace" ? color.gray : color.cyan;
+	const displayMessage = stripRedundantSubsystemPrefixForConsole(opts.message, displaySubsystem);
+	return `${[(() => {
+		if (opts.style === "pretty") return color.gray((/* @__PURE__ */ new Date()).toISOString().slice(11, 19));
+		if (loggingState.consoleTimestampPrefix) return color.gray((/* @__PURE__ */ new Date()).toISOString());
+		return "";
+	})(), prefixColor(prefix)].filter(Boolean).join(" ")} ${levelColor(displayMessage)}`;
+}
+function writeConsoleLine(level, line) {
+	clearActiveProgressLine();
+	const sanitized = process.platform === "win32" && process.env.GITHUB_ACTIONS === "true" ? line.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "?").replace(/[\uD800-\uDFFF]/g, "?") : line;
+	const sink = loggingState.rawConsole ?? console;
+	if (loggingState.forceConsoleToStderr || level === "error" || level === "fatal") (sink.error ?? console.error)(sanitized);
+	else if (level === "warn") (sink.warn ?? console.warn)(sanitized);
+	else (sink.log ?? console.log)(sanitized);
+}
+function logToFile(fileLogger, level, message, meta) {
+	if (level === "silent") return;
+	const method = fileLogger[level];
+	if (typeof method !== "function") return;
+	if (meta && Object.keys(meta).length > 0) method.call(fileLogger, meta, message);
+	else method.call(fileLogger, message);
+}
+function createSubsystemLogger(subsystem) {
+	let fileLogger = null;
+	const getFileLogger = () => {
+		if (!fileLogger) fileLogger = getChildLogger({ subsystem });
+		return fileLogger;
+	};
+	const emit = (level, message, meta) => {
+		const consoleSettings = getConsoleSettings();
+		let consoleMessageOverride;
+		let fileMeta = meta;
+		if (meta && Object.keys(meta).length > 0) {
+			const { consoleMessage, ...rest } = meta;
+			if (typeof consoleMessage === "string") consoleMessageOverride = consoleMessage;
+			fileMeta = Object.keys(rest).length > 0 ? rest : void 0;
+		}
+		logToFile(getFileLogger(), level, message, fileMeta);
+		if (!shouldLogToConsole(level, { level: consoleSettings.level })) return;
+		if (!shouldLogSubsystemToConsole(subsystem)) return;
+		const consoleMessage = consoleMessageOverride ?? message;
+		if (!isVerbose() && subsystem === "agent/embedded" && /(sessionId|runId)=probe-/.test(consoleMessage)) return;
+		writeConsoleLine(level, formatConsoleLine({
+			level,
+			subsystem,
+			message: consoleSettings.style === "json" ? message : consoleMessage,
+			style: consoleSettings.style,
+			meta: fileMeta
+		}));
+	};
+	const isConsoleEnabled = (level) => {
+		return shouldLogToConsole(level, { level: getConsoleSettings().level }) && shouldLogSubsystemToConsole(subsystem);
+	};
+	const isFileEnabled = (level) => isFileLogLevelEnabled(level);
+	return {
+		subsystem,
+		isEnabled: (level, target = "any") => {
+			if (target === "console") return isConsoleEnabled(level);
+			if (target === "file") return isFileEnabled(level);
+			return isConsoleEnabled(level) || isFileEnabled(level);
+		},
+		trace: (message, meta) => emit("trace", message, meta),
+		debug: (message, meta) => emit("debug", message, meta),
+		info: (message, meta) => emit("info", message, meta),
+		warn: (message, meta) => emit("warn", message, meta),
+		error: (message, meta) => emit("error", message, meta),
+		fatal: (message, meta) => emit("fatal", message, meta),
+		raw: (message) => {
+			logToFile(getFileLogger(), "info", message, { raw: true });
+			if (shouldLogSubsystemToConsole(subsystem)) {
+				if (!isVerbose() && subsystem === "agent/embedded" && /(sessionId|runId)=probe-/.test(message)) return;
+				writeConsoleLine("info", message);
+			}
+		},
+		child: (name) => createSubsystemLogger(`${subsystem}/${name}`)
+	};
+}
+function runtimeForLogger(logger, exit = defaultRuntime.exit) {
+	const formatArgs = (...args) => args.map((arg) => formatRuntimeArg(arg)).join(" ").trim();
+	return {
+		log: (...args) => logger.info(formatArgs(...args)),
+		error: (...args) => logger.error(formatArgs(...args)),
+		exit
+	};
+}
+
+//#endregion
+export { createInternalHookEvent as A, normalizePluginHttpPath as C, listPluginCommands as D, getPluginCommandSpecs as E, triggerInternalHook as M, matchPluginCommand as O, createPluginRegistry as S, executePluginCommand as T, normalizeChatChannelId as _, setConsoleSubsystemFilter as a, setActivePluginRegistry as b, formatLocalIsoWithOffset as c, formatChannelPrimerLine as d, formatChannelSelectionLine as f, normalizeChannelId as g, normalizeAnyChannelId as h, routeLogsToStderr as i, registerInternalHook as j, clearInternalHooks as k, CHANNEL_IDS as l, listChatChannels as m, runtimeForLogger as n, setConsoleTimestampPrefix as o, getChatChannelMeta as p, enableConsoleCapture as r, shouldLogSubsystemToConsole as s, createSubsystemLogger as t, CHAT_CHANNEL_ORDER as u, getActivePluginRegistry as v, clearPluginCommands as w, createEmptyPluginRegistry as x, requireActivePluginRegistry as y };