remoteclaw 0.1.0-next.cd6ddde → 0.1.0-next.cf9ccbe

package/dist/response-prefix-template-DBrUVx5V.js

@@ -0,0 +1,134 @@
+import { i as resolveAgentConfig } from "./agent-scope-CAQLm3LP.js";
+
+//#region src/agents/identity.ts
+const DEFAULT_ACK_REACTION = "👀";
+function resolveAgentIdentity(cfg, agentId) {
+	return resolveAgentConfig(cfg, agentId)?.identity;
+}
+function resolveAckReaction(cfg, agentId, opts) {
+	if (opts?.channel && opts?.accountId) {
+		const accountReaction = (getChannelConfig(cfg, opts.channel)?.accounts)?.[opts.accountId]?.ackReaction;
+		if (accountReaction !== void 0) return accountReaction.trim();
+	}
+	if (opts?.channel) {
+		const channelReaction = getChannelConfig(cfg, opts.channel)?.ackReaction;
+		if (channelReaction !== void 0) return channelReaction.trim();
+	}
+	const configured = cfg.messages?.ackReaction;
+	if (configured !== void 0) return configured.trim();
+	return resolveAgentIdentity(cfg, agentId)?.emoji?.trim() || DEFAULT_ACK_REACTION;
+}
+function resolveIdentityNamePrefix(cfg, agentId) {
+	const name = resolveAgentIdentity(cfg, agentId)?.name?.trim();
+	if (!name) return;
+	return `[${name}]`;
+}
+/** Returns just the identity name (without brackets) for template context. */
+function resolveIdentityName(cfg, agentId) {
+	return resolveAgentIdentity(cfg, agentId)?.name?.trim() || void 0;
+}
+function resolveMessagePrefix(cfg, agentId, opts) {
+	const configured = opts?.configured ?? cfg.messages?.messagePrefix;
+	if (configured !== void 0) return configured;
+	if (opts?.hasAllowFrom === true) return "";
+	return resolveIdentityNamePrefix(cfg, agentId) ?? opts?.fallback ?? "[remoteclaw]";
+}
+/** Helper to extract a channel config value by dynamic key. */
+function getChannelConfig(cfg, channel) {
+	const value = cfg.channels?.[channel];
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function resolveResponsePrefix(cfg, agentId, opts) {
+	if (opts?.channel && opts?.accountId) {
+		const accountPrefix = (getChannelConfig(cfg, opts.channel)?.accounts)?.[opts.accountId]?.responsePrefix;
+		if (accountPrefix !== void 0) {
+			if (accountPrefix === "auto") return resolveIdentityNamePrefix(cfg, agentId);
+			return accountPrefix;
+		}
+	}
+	if (opts?.channel) {
+		const channelPrefix = getChannelConfig(cfg, opts.channel)?.responsePrefix;
+		if (channelPrefix !== void 0) {
+			if (channelPrefix === "auto") return resolveIdentityNamePrefix(cfg, agentId);
+			return channelPrefix;
+		}
+	}
+	const configured = cfg.messages?.responsePrefix;
+	if (configured !== void 0) {
+		if (configured === "auto") return resolveIdentityNamePrefix(cfg, agentId);
+		return configured;
+	}
+}
+function resolveEffectiveMessagesConfig(cfg, agentId, opts) {
+	return {
+		messagePrefix: resolveMessagePrefix(cfg, agentId, {
+			hasAllowFrom: opts?.hasAllowFrom,
+			fallback: opts?.fallbackMessagePrefix
+		}),
+		responsePrefix: resolveResponsePrefix(cfg, agentId, {
+			channel: opts?.channel,
+			accountId: opts?.accountId
+		})
+	};
+}
+function resolveHumanDelayConfig(cfg, agentId) {
+	const defaults = cfg.agents?.defaults?.humanDelay;
+	const overrides = resolveAgentConfig(cfg, agentId)?.humanDelay;
+	if (!defaults && !overrides) return;
+	return {
+		mode: overrides?.mode ?? defaults?.mode,
+		minMs: overrides?.minMs ?? defaults?.minMs,
+		maxMs: overrides?.maxMs ?? defaults?.maxMs
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/response-prefix-template.ts
+const TEMPLATE_VAR_PATTERN = /\{([a-zA-Z][a-zA-Z0-9.]*)\}/g;
+/**
+* Interpolate template variables in a response prefix string.
+*
+* @param template - The template string with `{variable}` placeholders
+* @param context - Context object with values for interpolation
+* @returns The interpolated string, or undefined if template is undefined
+*
+* @example
+* resolveResponsePrefixTemplate("[{model} | {provider}]", {
+*   model: "gpt-5.2",
+*   provider: "openai-codex"
+* })
+* // Returns: "[gpt-5.2 | openai-codex]"
+*/
+function resolveResponsePrefixTemplate(template, context) {
+	if (!template) return;
+	return template.replace(TEMPLATE_VAR_PATTERN, (match, varName) => {
+		switch (varName.toLowerCase()) {
+			case "model": return context.model ?? match;
+			case "modelfull": return context.modelFull ?? match;
+			case "provider": return context.provider ?? match;
+			case "identity.name":
+			case "identityname": return context.identityName ?? match;
+			default: return match;
+		}
+	});
+}
+/**
+* Extract short model name from a full model string.
+*
+* Strips:
+* - Provider prefix (e.g., "openai/" from "openai/gpt-5.2")
+* - Date suffixes (e.g., "-20260205" from "claude-opus-4-6-20260205")
+* - Common version suffixes (e.g., "-latest")
+*
+* @example
+* extractShortModelName("openai-codex/gpt-5.2") // "gpt-5.2"
+* extractShortModelName("claude-opus-4-6-20260205") // "claude-opus-4-6"
+* extractShortModelName("gpt-5.2-latest") // "gpt-5.2"
+*/
+function extractShortModelName(fullModel) {
+	const slash = fullModel.lastIndexOf("/");
+	return (slash >= 0 ? fullModel.slice(slash + 1) : fullModel).replace(/-\d{8}$/, "").replace(/-latest$/, "");
+}
+
+//#endregion
+export { resolveEffectiveMessagesConfig as a, resolveIdentityNamePrefix as c, resolveAgentIdentity as i, resolveMessagePrefix as l, resolveResponsePrefixTemplate as n, resolveHumanDelayConfig as o, resolveAckReaction as r, resolveIdentityName as s, extractShortModelName as t };

package/dist/retry-CDrH81GP.js

@@ -0,0 +1,77 @@
+import { h as sleep } from "./subsystem-DGSHVL8I.js";
+
+//#region src/infra/retry.ts
+const DEFAULT_RETRY_CONFIG = {
+	attempts: 3,
+	minDelayMs: 300,
+	maxDelayMs: 3e4,
+	jitter: 0
+};
+const asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+const clampNumber = (value, fallback, min, max) => {
+	const next = asFiniteNumber(value);
+	if (next === void 0) return fallback;
+	const floor = typeof min === "number" ? min : Number.NEGATIVE_INFINITY;
+	const ceiling = typeof max === "number" ? max : Number.POSITIVE_INFINITY;
+	return Math.min(Math.max(next, floor), ceiling);
+};
+function resolveRetryConfig(defaults = DEFAULT_RETRY_CONFIG, overrides) {
+	const attempts = Math.max(1, Math.round(clampNumber(overrides?.attempts, defaults.attempts, 1)));
+	const minDelayMs = Math.max(0, Math.round(clampNumber(overrides?.minDelayMs, defaults.minDelayMs, 0)));
+	return {
+		attempts,
+		minDelayMs,
+		maxDelayMs: Math.max(minDelayMs, Math.round(clampNumber(overrides?.maxDelayMs, defaults.maxDelayMs, 0))),
+		jitter: clampNumber(overrides?.jitter, defaults.jitter, 0, 1)
+	};
+}
+function applyJitter(delayMs, jitter) {
+	if (jitter <= 0) return delayMs;
+	const offset = (Math.random() * 2 - 1) * jitter;
+	return Math.max(0, Math.round(delayMs * (1 + offset)));
+}
+async function retryAsync(fn, attemptsOrOptions = 3, initialDelayMs = 300) {
+	if (typeof attemptsOrOptions === "number") {
+		const attempts = Math.max(1, Math.round(attemptsOrOptions));
+		let lastErr;
+		for (let i = 0; i < attempts; i += 1) try {
+			return await fn();
+		} catch (err) {
+			lastErr = err;
+			if (i === attempts - 1) break;
+			await sleep(initialDelayMs * 2 ** i);
+		}
+		throw lastErr ?? /* @__PURE__ */ new Error("Retry failed");
+	}
+	const options = attemptsOrOptions;
+	const resolved = resolveRetryConfig(DEFAULT_RETRY_CONFIG, options);
+	const maxAttempts = resolved.attempts;
+	const minDelayMs = resolved.minDelayMs;
+	const maxDelayMs = Number.isFinite(resolved.maxDelayMs) && resolved.maxDelayMs > 0 ? resolved.maxDelayMs : Number.POSITIVE_INFINITY;
+	const jitter = resolved.jitter;
+	const shouldRetry = options.shouldRetry ?? (() => true);
+	let lastErr;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) try {
+		return await fn();
+	} catch (err) {
+		lastErr = err;
+		if (attempt >= maxAttempts || !shouldRetry(err, attempt)) break;
+		const retryAfterMs = options.retryAfterMs?.(err);
+		const baseDelay = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) ? Math.max(retryAfterMs, minDelayMs) : minDelayMs * 2 ** (attempt - 1);
+		let delay = Math.min(baseDelay, maxDelayMs);
+		delay = applyJitter(delay, jitter);
+		delay = Math.min(Math.max(delay, minDelayMs), maxDelayMs);
+		options.onRetry?.({
+			attempt,
+			maxAttempts,
+			delayMs: delay,
+			err,
+			label: options.label
+		});
+		await sleep(delay);
+	}
+	throw lastErr ?? /* @__PURE__ */ new Error("Retry failed");
+}
+
+//#endregion
+export { retryAsync as n, resolveRetryConfig as t };

package/dist/retry-Dar_7pCv.js

@@ -0,0 +1,77 @@
+import { x as sleep } from "./utils-DPoNpP7D.js";
+
+//#region src/infra/retry.ts
+const DEFAULT_RETRY_CONFIG = {
+	attempts: 3,
+	minDelayMs: 300,
+	maxDelayMs: 3e4,
+	jitter: 0
+};
+const asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+const clampNumber = (value, fallback, min, max) => {
+	const next = asFiniteNumber(value);
+	if (next === void 0) return fallback;
+	const floor = typeof min === "number" ? min : Number.NEGATIVE_INFINITY;
+	const ceiling = typeof max === "number" ? max : Number.POSITIVE_INFINITY;
+	return Math.min(Math.max(next, floor), ceiling);
+};
+function resolveRetryConfig(defaults = DEFAULT_RETRY_CONFIG, overrides) {
+	const attempts = Math.max(1, Math.round(clampNumber(overrides?.attempts, defaults.attempts, 1)));
+	const minDelayMs = Math.max(0, Math.round(clampNumber(overrides?.minDelayMs, defaults.minDelayMs, 0)));
+	return {
+		attempts,
+		minDelayMs,
+		maxDelayMs: Math.max(minDelayMs, Math.round(clampNumber(overrides?.maxDelayMs, defaults.maxDelayMs, 0))),
+		jitter: clampNumber(overrides?.jitter, defaults.jitter, 0, 1)
+	};
+}
+function applyJitter(delayMs, jitter) {
+	if (jitter <= 0) return delayMs;
+	const offset = (Math.random() * 2 - 1) * jitter;
+	return Math.max(0, Math.round(delayMs * (1 + offset)));
+}
+async function retryAsync(fn, attemptsOrOptions = 3, initialDelayMs = 300) {
+	if (typeof attemptsOrOptions === "number") {
+		const attempts = Math.max(1, Math.round(attemptsOrOptions));
+		let lastErr;
+		for (let i = 0; i < attempts; i += 1) try {
+			return await fn();
+		} catch (err) {
+			lastErr = err;
+			if (i === attempts - 1) break;
+			await sleep(initialDelayMs * 2 ** i);
+		}
+		throw lastErr ?? /* @__PURE__ */ new Error("Retry failed");
+	}
+	const options = attemptsOrOptions;
+	const resolved = resolveRetryConfig(DEFAULT_RETRY_CONFIG, options);
+	const maxAttempts = resolved.attempts;
+	const minDelayMs = resolved.minDelayMs;
+	const maxDelayMs = Number.isFinite(resolved.maxDelayMs) && resolved.maxDelayMs > 0 ? resolved.maxDelayMs : Number.POSITIVE_INFINITY;
+	const jitter = resolved.jitter;
+	const shouldRetry = options.shouldRetry ?? (() => true);
+	let lastErr;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) try {
+		return await fn();
+	} catch (err) {
+		lastErr = err;
+		if (attempt >= maxAttempts || !shouldRetry(err, attempt)) break;
+		const retryAfterMs = options.retryAfterMs?.(err);
+		const baseDelay = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) ? Math.max(retryAfterMs, minDelayMs) : minDelayMs * 2 ** (attempt - 1);
+		let delay = Math.min(baseDelay, maxDelayMs);
+		delay = applyJitter(delay, jitter);
+		delay = Math.min(Math.max(delay, minDelayMs), maxDelayMs);
+		options.onRetry?.({
+			attempt,
+			maxAttempts,
+			delayMs: delay,
+			err,
+			label: options.label
+		});
+		await sleep(delay);
+	}
+	throw lastErr ?? /* @__PURE__ */ new Error("Retry failed");
+}
+
+//#endregion
+export { retryAsync as n, resolveRetryConfig as t };

package/dist/run-main-DBFpx1kt.js

@@ -0,0 +1,308 @@
+import { $t as getCommandPath, Zt as normalizeWindowsArgv, _ as defaultRuntime, an as hasHelpOrVersion, c as enableConsoleCapture, en as getFlagValue, i as normalizeEnv, in as hasFlag, n as isTruthyEnvValue, nn as getPrimaryCommand, rn as getVerboseFlag, tn as getPositiveIntFlagValue } from "./entry.js";
+import { X as loadDotEnv } from "./config-BTH7fB_v.js";
+import "./host-env-security-axRnIi8d.js";
+import "./shell-env-DBS5su07.js";
+import { t as VERSION } from "./version-3QUZW8EP.js";
+import "./env-vars-CD2_baIP.js";
+import "./agent-scope-BA1HP4K6.js";
+import "./zod-schema-CvFqwpNE.js";
+import "./dock-B0bIIDS3.js";
+import "./message-channel-tuc9CdEw.js";
+import "./sessions-DtqrmUJS.js";
+import "./accounts-BwbvnKsW.js";
+import "./accounts-CIVjmTg9.js";
+import "./plugins-CaudBUbl.js";
+import "./accounts-DHkGVGUR.js";
+import "./accounts-XFgBY644.js";
+import "./bindings-DFAFatwT.js";
+import "./logging-DRwtiLIS.js";
+import "./targets-D2OQt8-7.js";
+import "./loader-BoP3JA-r.js";
+import "./chat-envelope-AJFUAuBM.js";
+import "./strip-inbound-meta-zmUXypSS.js";
+import "./client-B6h7bgbF.js";
+import "./call-D_NchaCs.js";
+import "./net-DSkFMHJ8.js";
+import "./logger-CPvz-aPM.js";
+import "./ip-MwCwRA7c.js";
+import "./tailnet-xt92Yaop.js";
+import "./lanes-1CBKdsiR.js";
+import "./subagent-registry-R1DiAM4R.js";
+import "./response-prefix-template-3LeqJx2X.js";
+import "./agent-helpers-Bs2nBXeI.js";
+import "./tool-images-BWhy6WRN.js";
+import "./exec-epNpA1aU.js";
+import "./image-ops-CX41n0v5.js";
+import "./tokens-Dw7ZdYwT.js";
+import "./reply-CL5VMSKN.js";
+import "./hook-runner-global-C1thol1d.js";
+import "./redact-BW8tobyp.js";
+import "./tool-display-Bxs_1jIn.js";
+import "./markdown-tables-NgPcfXoF.js";
+import "./chunk-BAMyFYtF.js";
+import "./media-4-qOIjO-.js";
+import "./render-BhKzKdV0.js";
+import "./tables-Cm9qvQ9D.js";
+import "./fs-safe-BjSd07M4.js";
+import "./mime-ViuhRuMM.js";
+import "./ssrf-CJIdPXuS.js";
+import "./fetch-Cky99wYB.js";
+import "./common-D4fL3S2m.js";
+import "./auth-C1zx1O24.js";
+import "./file-lock-DXW9h9ek.js";
+import "./commands-D93TXYhv.js";
+import "./commands-registry-De8JhZLG.js";
+import "./provider-auth-j-EQvvIk.js";
+import "./audio-DqlIYYTb.js";
+import "./targets-D94MtTiZ.js";
+import "./pairing-store-BoF0g-iN.js";
+import "./fetch-DTsU2XnC.js";
+import "./retry-BWv_fy4u.js";
+import "./client-D-R1YdRD.js";
+import { r as formatUncaughtError } from "./errors-0dfGxeYQ.js";
+import "./channel-activity-BhT7NQ_v.js";
+import "./send-DbafVwxp.js";
+import "./session-cost-usage-C-DsaOfN.js";
+import "./reply-directives-DQfJ001O.js";
+import "./provider-dispatcher-DhkvjhO5.js";
+import "./store-CzhBjUCN.js";
+import "./reply-prefix-DBTlMHLK.js";
+import { g as installUnhandledRejectionHandler } from "./ack-reactions-Diu9O24z.js";
+import "./resolve-route-C8ZsgWDQ.js";
+import { t as ensureRemoteClawCliOnPath } from "./path-env-GTM4HXCN.js";
+import "./catalog-k056Nh93.js";
+import "./preflight-Bq8rimP-.js";
+import "./prompt-style-CUuA6OCy.js";
+import "./note-D-EI0czq.js";
+import "./plugin-auto-enable-DghjlFCL.js";
+import "./send-DeZg8K7y.js";
+import "./send-DwkjxJlv.js";
+import "./send-BxOrO1Wv.js";
+import "./proxy-D-qGA1vm.js";
+import "./replies-BIx-MbQ7.js";
+import "./agent-Dd5Yfhmq.js";
+import "./channel-selection-ovohyJQZ.js";
+import "./deliver-EB272zWh.js";
+import "./outbound-attachment-CqZ7Qc_o.js";
+import "./delivery-queue-BDvalA10.js";
+import "./send-BFZPQE4j.js";
+import "./onboard-helpers-DTRrJLj-.js";
+import "./pairing-labels-CBmGQ31P.js";
+import { t as ensurePluginRegistryLoaded } from "./plugin-registry-BitdVPb4.js";
+import { t as assertSupportedRuntime } from "./runtime-guard-Bhx-pb8_.js";
+import { t as emitCliBanner } from "./banner-CBWZhANO.js";
+import "./doctor-config-flow-BDDsR2J1.js";
+import { n as ensureConfigReady } from "./config-guard-Bqak3bDc.js";
+import process$1 from "node:process";
+import { fileURLToPath } from "node:url";
+
+//#region src/cli/program/routes.ts
+const routeHealth = {
+	match: (path) => path[0] === "health",
+	loadPlugins: true,
+	run: async (argv) => {
+		const json = hasFlag(argv, "--json");
+		const verbose = getVerboseFlag(argv, { includeDebug: true });
+		const timeoutMs = getPositiveIntFlagValue(argv, "--timeout");
+		if (timeoutMs === null) return false;
+		const { healthCommand } = await import("./health-DdviISKg.js").then((n) => n.i);
+		await healthCommand({
+			json,
+			timeoutMs,
+			verbose
+		}, defaultRuntime);
+		return true;
+	}
+};
+const routeStatus = {
+	match: (path) => path[0] === "status",
+	loadPlugins: true,
+	run: async (argv) => {
+		const json = hasFlag(argv, "--json");
+		const deep = hasFlag(argv, "--deep");
+		const all = hasFlag(argv, "--all");
+		const usage = hasFlag(argv, "--usage");
+		const verbose = getVerboseFlag(argv, { includeDebug: true });
+		const timeoutMs = getPositiveIntFlagValue(argv, "--timeout");
+		if (timeoutMs === null) return false;
+		const { statusCommand } = await import("./status-BI_-xpDt.js").then((n) => n.t);
+		await statusCommand({
+			json,
+			deep,
+			all,
+			usage,
+			timeoutMs,
+			verbose
+		}, defaultRuntime);
+		return true;
+	}
+};
+const routeSessions = {
+	match: (path) => path[0] === "sessions" && !path[1],
+	run: async (argv) => {
+		const json = hasFlag(argv, "--json");
+		const allAgents = hasFlag(argv, "--all-agents");
+		const agent = getFlagValue(argv, "--agent");
+		if (agent === null) return false;
+		const store = getFlagValue(argv, "--store");
+		if (store === null) return false;
+		const active = getFlagValue(argv, "--active");
+		if (active === null) return false;
+		const { sessionsCommand } = await import("./sessions-gT-4fcX-.js").then((n) => n.n);
+		await sessionsCommand({
+			json,
+			store,
+			agent,
+			allAgents,
+			active
+		}, defaultRuntime);
+		return true;
+	}
+};
+const routeAgentsList = {
+	match: (path) => path[0] === "agents" && path[1] === "list",
+	run: async (argv) => {
+		const json = hasFlag(argv, "--json");
+		const bindings = hasFlag(argv, "--bindings");
+		const { agentsListCommand } = await import("./agents-2VlLHxv-.js").then((n) => n.t);
+		await agentsListCommand({
+			json,
+			bindings
+		}, defaultRuntime);
+		return true;
+	}
+};
+function getCommandPositionals(argv) {
+	const out = [];
+	const args = argv.slice(2);
+	for (const arg of args) {
+		if (!arg || arg === "--") break;
+		if (arg.startsWith("-")) continue;
+		out.push(arg);
+	}
+	return out;
+}
+const routes = [
+	routeHealth,
+	routeStatus,
+	routeSessions,
+	routeAgentsList,
+	{
+		match: (path) => path[0] === "config" && path[1] === "get",
+		run: async (argv) => {
+			const pathArg = getCommandPositionals(argv)[2];
+			if (!pathArg) return false;
+			const json = hasFlag(argv, "--json");
+			const { runConfigGet } = await import("./config-cli-rcMB3A3B.js");
+			await runConfigGet({
+				path: pathArg,
+				json
+			});
+			return true;
+		}
+	},
+	{
+		match: (path) => path[0] === "config" && path[1] === "unset",
+		run: async (argv) => {
+			const pathArg = getCommandPositionals(argv)[2];
+			if (!pathArg) return false;
+			const { runConfigUnset } = await import("./config-cli-rcMB3A3B.js");
+			await runConfigUnset({ path: pathArg });
+			return true;
+		}
+	}
+];
+function findRoutedCommand(path) {
+	for (const route of routes) if (route.match(path)) return route;
+	return null;
+}
+
+//#endregion
+//#region src/cli/route.ts
+async function prepareRoutedCommand(params) {
+	emitCliBanner(VERSION, { argv: params.argv });
+	await ensureConfigReady({
+		runtime: defaultRuntime,
+		commandPath: params.commandPath
+	});
+	if (params.loadPlugins) ensurePluginRegistryLoaded();
+}
+async function tryRouteCli(argv) {
+	if (isTruthyEnvValue(process.env.REMOTECLAW_DISABLE_ROUTE_FIRST)) return false;
+	if (hasHelpOrVersion(argv)) return false;
+	const path = getCommandPath(argv, 2);
+	if (!path[0]) return false;
+	const route = findRoutedCommand(path);
+	if (!route) return false;
+	await prepareRoutedCommand({
+		argv,
+		commandPath: path,
+		loadPlugins: route.loadPlugins
+	});
+	return route.run(argv);
+}
+
+//#endregion
+//#region src/cli/run-main.ts
+function rewriteUpdateFlagArgv(argv) {
+	const index = argv.indexOf("--update");
+	if (index === -1) return argv;
+	const next = [...argv];
+	next.splice(index, 1, "update");
+	return next;
+}
+function shouldSkipPluginCommandRegistration(params) {
+	if (params.hasBuiltinPrimary) return true;
+	if (!params.primary) return hasHelpOrVersion(params.argv);
+	return false;
+}
+function shouldEnsureCliPath(argv) {
+	if (hasHelpOrVersion(argv)) return false;
+	const [primary, secondary] = getCommandPath(argv, 2);
+	if (!primary) return true;
+	if (primary === "status" || primary === "health" || primary === "sessions") return false;
+	if (primary === "config" && (secondary === "get" || secondary === "unset")) return false;
+	if (primary === "models" && (secondary === "list" || secondary === "status")) return false;
+	return true;
+}
+async function runCli(argv = process$1.argv) {
+	const normalizedArgv = normalizeWindowsArgv(argv);
+	loadDotEnv({ quiet: true });
+	normalizeEnv();
+	if (shouldEnsureCliPath(normalizedArgv)) ensureRemoteClawCliOnPath();
+	assertSupportedRuntime();
+	if (await tryRouteCli(normalizedArgv)) return;
+	enableConsoleCapture();
+	const { buildProgram } = await import("./program-G8cGMPuz.js");
+	const program = buildProgram();
+	installUnhandledRejectionHandler();
+	process$1.on("uncaughtException", (error) => {
+		console.error("[remoteclaw] Uncaught exception:", formatUncaughtError(error));
+		process$1.exit(1);
+	});
+	const parseArgv = rewriteUpdateFlagArgv(normalizedArgv);
+	const primary = getPrimaryCommand(parseArgv);
+	if (primary) {
+		const { getProgramContext } = await import("./program-context-DlXnmuB7.js").then((n) => n.n);
+		const ctx = getProgramContext(program);
+		if (ctx) {
+			const { registerCoreCliByName } = await import("./command-registry-BV2MH_iw.js").then((n) => n.t);
+			await registerCoreCliByName(program, ctx, primary, parseArgv);
+		}
+		const { registerSubCliByName } = await import("./register.subclis-CQ_Pjkyv.js").then((n) => n.a);
+		await registerSubCliByName(program, primary);
+	}
+	if (!shouldSkipPluginCommandRegistration({
+		argv: parseArgv,
+		primary,
+		hasBuiltinPrimary: primary !== null && program.commands.some((command) => command.name() === primary)
+	})) {
+		const { registerPluginCliCommands } = await import("./cli-Di3p1tLN.js");
+		const { loadConfig } = await import("./config-BTH7fB_v.js").then((n) => n.t);
+		registerPluginCliCommands(program, loadConfig());
+	}
+	await program.parseAsync(parseArgv);
+}
+
+//#endregion
+export { runCli };

package/dist/secure-random-CLWSvf8A.js

@@ -0,0 +1,44 @@
+import { $ as resolveAccountEntry, Q as createAccountListHelpers, dt as normalizeAccountId } from "./media-DTwJhAbE.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/signal/accounts.ts
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("signal");
+function resolveAccountConfig(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.signal?.accounts, accountId);
+}
+function mergeSignalAccountConfig(cfg, accountId) {
+	const { accounts: _ignored, ...base } = cfg.channels?.signal ?? {};
+	const account = resolveAccountConfig(cfg, accountId) ?? {};
+	return {
+		...base,
+		...account
+	};
+}
+function resolveSignalAccount(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const baseEnabled = params.cfg.channels?.signal?.enabled !== false;
+	const merged = mergeSignalAccountConfig(params.cfg, accountId);
+	const accountEnabled = merged.enabled !== false;
+	const enabled = baseEnabled && accountEnabled;
+	const host = merged.httpHost?.trim() || "127.0.0.1";
+	const port = merged.httpPort ?? 8080;
+	const baseUrl = merged.httpUrl?.trim() || `http://${host}:${port}`;
+	const configured = Boolean(merged.account?.trim() || merged.httpUrl?.trim() || merged.cliPath?.trim() || merged.httpHost?.trim() || typeof merged.httpPort === "number" || typeof merged.autoStart === "boolean");
+	return {
+		accountId,
+		enabled,
+		name: merged.name?.trim() || void 0,
+		baseUrl,
+		configured,
+		config: merged
+	};
+}
+
+//#endregion
+//#region src/infra/secure-random.ts
+function generateSecureUuid() {
+	return randomUUID();
+}
+
+//#endregion
+export { resolveSignalAccount as n, generateSecureUuid as t };