remoteclaw 0.1.0-next.4659fdb → 0.1.0-next.4bacc0a

package/README.md

@@ -2,8 +2,8 @@
 
 <p align="center">
     <picture>
-        <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/remoteclaw/remoteclaw/main/docs/assets/remoteclaw-logo-text.png">
-        <img src="https://raw.githubusercontent.com/remoteclaw/remoteclaw/main/docs/assets/remoteclaw-logo-text-dark.png" alt="RemoteClaw" width="500">
+        <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/remoteclaw/remoteclaw/main/docs/public/assets/remoteclaw-logo-text.png">
+        <img src="https://raw.githubusercontent.com/remoteclaw/remoteclaw/main/docs/public/assets/remoteclaw-logo-text-dark.png" alt="RemoteClaw" width="500">
     </picture>
 </p>
 
@@ -173,13 +173,13 @@ Run `remoteclaw doctor` to surface risky/misconfigured DM policies.
 - [Canvas](https://docs.remoteclaw.org/platforms/mac/canvas): [A2UI](https://docs.remoteclaw.org/platforms/mac/canvas#canvas-a2ui) push/reset, eval, snapshot.
 - [Nodes](https://docs.remoteclaw.org/nodes): camera snap/clip, screen record, [location.get](https://docs.remoteclaw.org/nodes/location-command), notifications.
 - [Cron + wakeups](https://docs.remoteclaw.org/automation/cron-jobs); [webhooks](https://docs.remoteclaw.org/automation/webhook); [Gmail Pub/Sub](https://docs.remoteclaw.org/automation/gmail-pubsub).
-- [Skills platform](https://docs.remoteclaw.org/tools/skills): bundled, managed, and workspace skills with install gating + UI.
+- [Skills platform](https://docs.remoteclaw.org/tools/skills): bundled and workspace skills.
 
 ### Runtime + safety
 
 - [Channel routing](https://docs.remoteclaw.org/channels/channel-routing), [retry policy](https://docs.remoteclaw.org/concepts/retry), and [streaming/chunking](https://docs.remoteclaw.org/concepts/streaming).
 - [Presence](https://docs.remoteclaw.org/concepts/presence), [typing indicators](https://docs.remoteclaw.org/concepts/typing-indicators), and [usage tracking](https://docs.remoteclaw.org/concepts/usage-tracking).
-- [Models](https://docs.remoteclaw.org/concepts/models), [model failover](https://docs.remoteclaw.org/concepts/model-failover), and [session pruning](https://docs.remoteclaw.org/concepts/session-pruning).
+- [Session pruning](https://docs.remoteclaw.org/concepts/session-pruning).
 - [Security](https://docs.remoteclaw.org/gateway/security) and [troubleshooting](https://docs.remoteclaw.org/channels/troubleshooting).
 
 ### Ops + packaging
@@ -255,7 +255,7 @@ The macOS app can run in **node mode** and advertises its capabilities + permiss
 Elevated bash (host permissions) is separate from macOS TCC:
 
 - Use `/elevated on|off` to toggle per‑session elevated access when enabled + allowlisted.
-- Gateway persists the per‑session toggle via `sessions.patch` (WS method) alongside `thinkingLevel`, `verboseLevel`, `model`, `sendPolicy`, and `groupActivation`.
+- Gateway persists the per‑session toggle via `sessions.patch` (WS method) alongside `verboseLevel`, `sendPolicy`, and `groupActivation`.
 
 Details: [Nodes](https://docs.remoteclaw.org/nodes) · [macOS app](https://docs.remoteclaw.org/platforms/macos) · [Gateway protocol](https://docs.remoteclaw.org/concepts/architecture)
 
@@ -275,7 +275,7 @@ Send these in WhatsApp/Telegram/Slack/Google Chat/Microsoft Teams/WebChat (group
 - `/status` — compact session status (model + tokens, cost when available)
 - `/new` or `/reset` — reset the session
 - `/compact` — compact session context (summary)
-- `/think <level>` — off|minimal|low|medium|high|xhigh (GPT-5.2 + Codex models only)
+- `/think <level>` — off|minimal|low|medium|high|xhigh (runtimes that support extended thinking)
 - `/verbose on|off`
 - `/usage off|tokens|full` — per-response usage footer
 - `/restart` — restart the gateway (owner-only in groups)
@@ -318,12 +318,14 @@ Runbook: [iOS connect](https://docs.remoteclaw.org/platforms/ios).
 
 ## Configuration
 
-Minimal `~/.remoteclaw/remoteclaw.json` (model + defaults):
+Minimal `~/.remoteclaw/remoteclaw.json`:
 
 ```json5
 {
-  agent: {
-    model: "anthropic/claude-opus-4-6",
+  channels: {
+    telegram: {
+      botToken: "YOUR_BOT_TOKEN",
+    },
   },
 }
 ```

package/dist/accounts-B1M3fOxL.js

@@ -0,0 +1,272 @@
+import { p as resolveOAuthDir } from "./paths-DHuXVC00.js";
+import { E as info, N as success, R as getChildLogger, _ as resolveUserPath, d as jidToE164 } from "./utils-DPoNpP7D.js";
+import { i as defaultRuntime } from "./ansi-DtaiOnt1.js";
+import { h as normalizeAccountId, m as DEFAULT_ACCOUNT_ID } from "./session-key-CgKWfjoZ.js";
+import { t as resolveAccountEntry } from "./account-lookup-CIY_RKhi.js";
+import { t as formatCliCommand } from "./command-format-Dntg_tnC.js";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+
+//#region src/channels/plugins/account-helpers.ts
+function createAccountListHelpers(channelKey) {
+	function listConfiguredAccountIds(cfg) {
+		const accounts = (cfg.channels?.[channelKey])?.accounts;
+		if (!accounts || typeof accounts !== "object") return [];
+		return Object.keys(accounts).filter(Boolean);
+	}
+	function listAccountIds(cfg) {
+		const ids = listConfiguredAccountIds(cfg);
+		if (ids.length === 0) return [DEFAULT_ACCOUNT_ID];
+		return ids.toSorted((a, b) => a.localeCompare(b));
+	}
+	function resolveDefaultAccountId(cfg) {
+		const ids = listAccountIds(cfg);
+		if (ids.includes(DEFAULT_ACCOUNT_ID)) return DEFAULT_ACCOUNT_ID;
+		return ids[0] ?? DEFAULT_ACCOUNT_ID;
+	}
+	return {
+		listConfiguredAccountIds,
+		listAccountIds,
+		resolveDefaultAccountId
+	};
+}
+
+//#endregion
+//#region src/web/auth-store.ts
+function resolveDefaultWebAuthDir() {
+	return path.join(resolveOAuthDir(), "whatsapp", DEFAULT_ACCOUNT_ID);
+}
+const WA_WEB_AUTH_DIR = resolveDefaultWebAuthDir();
+function resolveWebCredsPath(authDir) {
+	return path.join(authDir, "creds.json");
+}
+function resolveWebCredsBackupPath(authDir) {
+	return path.join(authDir, "creds.json.bak");
+}
+function hasWebCredsSync(authDir) {
+	try {
+		const stats = fs.statSync(resolveWebCredsPath(authDir));
+		return stats.isFile() && stats.size > 1;
+	} catch {
+		return false;
+	}
+}
+function readCredsJsonRaw(filePath) {
+	try {
+		if (!fs.existsSync(filePath)) return null;
+		const stats = fs.statSync(filePath);
+		if (!stats.isFile() || stats.size <= 1) return null;
+		return fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+function maybeRestoreCredsFromBackup(authDir) {
+	const logger = getChildLogger({ module: "web-session" });
+	try {
+		const credsPath = resolveWebCredsPath(authDir);
+		const backupPath = resolveWebCredsBackupPath(authDir);
+		const raw = readCredsJsonRaw(credsPath);
+		if (raw) {
+			JSON.parse(raw);
+			return;
+		}
+		const backupRaw = readCredsJsonRaw(backupPath);
+		if (!backupRaw) return;
+		JSON.parse(backupRaw);
+		fs.copyFileSync(backupPath, credsPath);
+		try {
+			fs.chmodSync(credsPath, 384);
+		} catch {}
+		logger.warn({ credsPath }, "restored corrupted WhatsApp creds.json from backup");
+	} catch {}
+}
+async function webAuthExists(authDir = resolveDefaultWebAuthDir()) {
+	const resolvedAuthDir = resolveUserPath(authDir);
+	maybeRestoreCredsFromBackup(resolvedAuthDir);
+	const credsPath = resolveWebCredsPath(resolvedAuthDir);
+	try {
+		await fs$1.access(resolvedAuthDir);
+	} catch {
+		return false;
+	}
+	try {
+		const stats = await fs$1.stat(credsPath);
+		if (!stats.isFile() || stats.size <= 1) return false;
+		const raw = await fs$1.readFile(credsPath, "utf-8");
+		JSON.parse(raw);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function clearLegacyBaileysAuthState(authDir) {
+	const entries = await fs$1.readdir(authDir, { withFileTypes: true });
+	const shouldDelete = (name) => {
+		if (name === "oauth.json") return false;
+		if (name === "creds.json" || name === "creds.json.bak") return true;
+		if (!name.endsWith(".json")) return false;
+		return /^(app-state-sync|session|sender-key|pre-key)-/.test(name);
+	};
+	await Promise.all(entries.map(async (entry) => {
+		if (!entry.isFile()) return;
+		if (!shouldDelete(entry.name)) return;
+		await fs$1.rm(path.join(authDir, entry.name), { force: true });
+	}));
+}
+async function logoutWeb(params) {
+	const runtime = params.runtime ?? defaultRuntime;
+	const resolvedAuthDir = resolveUserPath(params.authDir ?? resolveDefaultWebAuthDir());
+	if (!await webAuthExists(resolvedAuthDir)) {
+		runtime.log(info("No WhatsApp Web session found; nothing to delete."));
+		return false;
+	}
+	if (params.isLegacyAuthDir) await clearLegacyBaileysAuthState(resolvedAuthDir);
+	else await fs$1.rm(resolvedAuthDir, {
+		recursive: true,
+		force: true
+	});
+	runtime.log(success("Cleared WhatsApp Web credentials."));
+	return true;
+}
+function readWebSelfId(authDir = resolveDefaultWebAuthDir()) {
+	try {
+		const credsPath = resolveWebCredsPath(resolveUserPath(authDir));
+		if (!fs.existsSync(credsPath)) return {
+			e164: null,
+			jid: null
+		};
+		const raw = fs.readFileSync(credsPath, "utf-8");
+		const jid = JSON.parse(raw)?.me?.id ?? null;
+		return {
+			e164: jid ? jidToE164(jid, { authDir }) : null,
+			jid
+		};
+	} catch {
+		return {
+			e164: null,
+			jid: null
+		};
+	}
+}
+/**
+* Return the age (in milliseconds) of the cached WhatsApp web auth state, or null when missing.
+* Helpful for heartbeats/observability to spot stale credentials.
+*/
+function getWebAuthAgeMs(authDir = resolveDefaultWebAuthDir()) {
+	try {
+		const stats = fs.statSync(resolveWebCredsPath(resolveUserPath(authDir)));
+		return Date.now() - stats.mtimeMs;
+	} catch {
+		return null;
+	}
+}
+function logWebSelfId(authDir = resolveDefaultWebAuthDir(), runtime = defaultRuntime, includeChannelPrefix = false) {
+	const { e164, jid } = readWebSelfId(authDir);
+	const details = e164 || jid ? `${e164 ?? "unknown"}${jid ? ` (jid ${jid})` : ""}` : "unknown";
+	const prefix = includeChannelPrefix ? "Web Channel: " : "";
+	runtime.log(info(`${prefix}${details}`));
+}
+async function pickWebChannel(pref, authDir = resolveDefaultWebAuthDir()) {
+	const choice = pref === "auto" ? "web" : pref;
+	if (!await webAuthExists(authDir)) throw new Error(`No WhatsApp Web session found. Run \`${formatCliCommand("remoteclaw channels login --channel whatsapp --verbose")}\` to link.`);
+	return choice;
+}
+
+//#endregion
+//#region src/web/accounts.ts
+const { listConfiguredAccountIds, listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("whatsapp");
+const listWhatsAppAccountIds = listAccountIds;
+const resolveDefaultWhatsAppAccountId = resolveDefaultAccountId;
+function listWhatsAppAuthDirs(cfg) {
+	const oauthDir = resolveOAuthDir();
+	const whatsappDir = path.join(oauthDir, "whatsapp");
+	const authDirs = new Set([oauthDir, path.join(whatsappDir, DEFAULT_ACCOUNT_ID)]);
+	const accountIds = listConfiguredAccountIds(cfg);
+	for (const accountId of accountIds) authDirs.add(resolveWhatsAppAuthDir({
+		cfg,
+		accountId
+	}).authDir);
+	try {
+		const entries = fs.readdirSync(whatsappDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			authDirs.add(path.join(whatsappDir, entry.name));
+		}
+	} catch {}
+	return Array.from(authDirs);
+}
+function hasAnyWhatsAppAuth(cfg) {
+	return listWhatsAppAuthDirs(cfg).some((authDir) => hasWebCredsSync(authDir));
+}
+function resolveAccountConfig(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.whatsapp?.accounts, accountId);
+}
+function resolveDefaultAuthDir(accountId) {
+	return path.join(resolveOAuthDir(), "whatsapp", normalizeAccountId(accountId));
+}
+function resolveLegacyAuthDir() {
+	return resolveOAuthDir();
+}
+function legacyAuthExists(authDir) {
+	try {
+		return fs.existsSync(path.join(authDir, "creds.json"));
+	} catch {
+		return false;
+	}
+}
+function resolveWhatsAppAuthDir(params) {
+	const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+	const configured = resolveAccountConfig(params.cfg, accountId)?.authDir?.trim();
+	if (configured) return {
+		authDir: resolveUserPath(configured),
+		isLegacy: false
+	};
+	const defaultDir = resolveDefaultAuthDir(accountId);
+	if (accountId === DEFAULT_ACCOUNT_ID) {
+		const legacyDir = resolveLegacyAuthDir();
+		if (legacyAuthExists(legacyDir) && !legacyAuthExists(defaultDir)) return {
+			authDir: legacyDir,
+			isLegacy: true
+		};
+	}
+	return {
+		authDir: defaultDir,
+		isLegacy: false
+	};
+}
+function resolveWhatsAppAccount(params) {
+	const rootCfg = params.cfg.channels?.whatsapp;
+	const accountId = params.accountId?.trim() || resolveDefaultWhatsAppAccountId(params.cfg);
+	const accountCfg = resolveAccountConfig(params.cfg, accountId);
+	const enabled = accountCfg?.enabled !== false;
+	const { authDir, isLegacy } = resolveWhatsAppAuthDir({
+		cfg: params.cfg,
+		accountId
+	});
+	return {
+		accountId,
+		name: accountCfg?.name?.trim() || void 0,
+		enabled,
+		sendReadReceipts: accountCfg?.sendReadReceipts ?? rootCfg?.sendReadReceipts ?? true,
+		messagePrefix: accountCfg?.messagePrefix ?? rootCfg?.messagePrefix ?? params.cfg.messages?.messagePrefix,
+		authDir,
+		isLegacyAuthDir: isLegacy,
+		selfChatMode: accountCfg?.selfChatMode ?? rootCfg?.selfChatMode,
+		dmPolicy: accountCfg?.dmPolicy ?? rootCfg?.dmPolicy,
+		allowFrom: accountCfg?.allowFrom ?? rootCfg?.allowFrom,
+		groupAllowFrom: accountCfg?.groupAllowFrom ?? rootCfg?.groupAllowFrom,
+		groupPolicy: accountCfg?.groupPolicy ?? rootCfg?.groupPolicy,
+		textChunkLimit: accountCfg?.textChunkLimit ?? rootCfg?.textChunkLimit,
+		chunkMode: accountCfg?.chunkMode ?? rootCfg?.chunkMode,
+		mediaMaxMb: accountCfg?.mediaMaxMb ?? rootCfg?.mediaMaxMb,
+		blockStreaming: accountCfg?.blockStreaming ?? rootCfg?.blockStreaming,
+		ackReaction: accountCfg?.ackReaction ?? rootCfg?.ackReaction,
+		groups: accountCfg?.groups ?? rootCfg?.groups,
+		debounceMs: accountCfg?.debounceMs ?? rootCfg?.debounceMs
+	};
+}
+
+//#endregion
+export { webAuthExists as _, resolveWhatsAppAuthDir as a, logWebSelfId as c, pickWebChannel as d, readCredsJsonRaw as f, resolveWebCredsPath as g, resolveWebCredsBackupPath as h, resolveWhatsAppAccount as i, logoutWeb as l, resolveDefaultWebAuthDir as m, listWhatsAppAccountIds as n, WA_WEB_AUTH_DIR as o, readWebSelfId as p, resolveDefaultWhatsAppAccountId as r, getWebAuthAgeMs as s, hasAnyWhatsAppAuth as t, maybeRestoreCredsFromBackup as u, createAccountListHelpers as v };

package/dist/accounts-B2W5oxhg.js

@@ -0,0 +1,205 @@
+import { n as isTruthyEnvValue, o as createSubsystemLogger } from "./entry.js";
+import { h as normalizeAccountId, m as DEFAULT_ACCOUNT_ID } from "./session-key-BF-9YzxC.js";
+import { t as resolveAccountEntry } from "./account-lookup-C0ndrpt-.js";
+import { i as resolveDefaultAgentBoundAccountId, r as listBoundAccountIds } from "./bindings-C_CjV_Hn.js";
+import fs from "node:fs";
+import util from "node:util";
+
+//#region src/channels/plugins/account-action-gate.ts
+function createAccountActionGate(params) {
+	return (key, defaultValue = true) => {
+		const accountValue = params.accountActions?.[key];
+		if (accountValue !== void 0) return accountValue;
+		const baseValue = params.baseActions?.[key];
+		if (baseValue !== void 0) return baseValue;
+		return defaultValue;
+	};
+}
+
+//#endregion
+//#region src/telegram/token.ts
+function resolveTelegramToken(cfg, opts = {}) {
+	const accountId = normalizeAccountId(opts.accountId);
+	const telegramCfg = cfg?.channels?.telegram;
+	const resolveAccountCfg = (id) => {
+		const accounts = telegramCfg?.accounts;
+		if (!accounts || typeof accounts !== "object" || Array.isArray(accounts)) return;
+		const direct = accounts[id];
+		if (direct) return direct;
+		const matchKey = Object.keys(accounts).find((key) => normalizeAccountId(key) === id);
+		return matchKey ? accounts[matchKey] : void 0;
+	};
+	const accountCfg = resolveAccountCfg(accountId !== DEFAULT_ACCOUNT_ID ? accountId : DEFAULT_ACCOUNT_ID);
+	const accountTokenFile = accountCfg?.tokenFile?.trim();
+	if (accountTokenFile) {
+		if (!fs.existsSync(accountTokenFile)) {
+			opts.logMissingFile?.(`channels.telegram.accounts.${accountId}.tokenFile not found: ${accountTokenFile}`);
+			return {
+				token: "",
+				source: "none"
+			};
+		}
+		try {
+			const token = fs.readFileSync(accountTokenFile, "utf-8").trim();
+			if (token) return {
+				token,
+				source: "tokenFile"
+			};
+		} catch (err) {
+			opts.logMissingFile?.(`channels.telegram.accounts.${accountId}.tokenFile read failed: ${String(err)}`);
+			return {
+				token: "",
+				source: "none"
+			};
+		}
+		return {
+			token: "",
+			source: "none"
+		};
+	}
+	const accountToken = accountCfg?.botToken?.trim();
+	if (accountToken) return {
+		token: accountToken,
+		source: "config"
+	};
+	const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
+	const tokenFile = telegramCfg?.tokenFile?.trim();
+	if (tokenFile && allowEnv) {
+		if (!fs.existsSync(tokenFile)) {
+			opts.logMissingFile?.(`channels.telegram.tokenFile not found: ${tokenFile}`);
+			return {
+				token: "",
+				source: "none"
+			};
+		}
+		try {
+			const token = fs.readFileSync(tokenFile, "utf-8").trim();
+			if (token) return {
+				token,
+				source: "tokenFile"
+			};
+		} catch (err) {
+			opts.logMissingFile?.(`channels.telegram.tokenFile read failed: ${String(err)}`);
+			return {
+				token: "",
+				source: "none"
+			};
+		}
+	}
+	const configToken = telegramCfg?.botToken?.trim();
+	if (configToken && allowEnv) return {
+		token: configToken,
+		source: "config"
+	};
+	const envToken = allowEnv ? (opts.envToken ?? process.env.TELEGRAM_BOT_TOKEN)?.trim() : "";
+	if (envToken) return {
+		token: envToken,
+		source: "env"
+	};
+	return {
+		token: "",
+		source: "none"
+	};
+}
+
+//#endregion
+//#region src/telegram/accounts.ts
+const log = createSubsystemLogger("telegram/accounts");
+function formatDebugArg(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof Error) return value.stack ?? value.message;
+	return util.inspect(value, {
+		colors: false,
+		depth: null,
+		compact: true,
+		breakLength: Infinity
+	});
+}
+const debugAccounts = (...args) => {
+	if (isTruthyEnvValue(process.env.REMOTECLAW_DEBUG_TELEGRAM_ACCOUNTS)) {
+		const parts = args.map((arg) => formatDebugArg(arg));
+		log.warn(parts.join(" ").trim());
+	}
+};
+function listConfiguredAccountIds(cfg) {
+	const accounts = cfg.channels?.telegram?.accounts;
+	if (!accounts || typeof accounts !== "object") return [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(accounts)) {
+		if (!key) continue;
+		ids.add(normalizeAccountId(key));
+	}
+	return [...ids];
+}
+function listTelegramAccountIds(cfg) {
+	const ids = Array.from(new Set([...listConfiguredAccountIds(cfg), ...listBoundAccountIds(cfg, "telegram")]));
+	debugAccounts("listTelegramAccountIds", ids);
+	if (ids.length === 0) return [DEFAULT_ACCOUNT_ID];
+	return ids.toSorted((a, b) => a.localeCompare(b));
+}
+function resolveDefaultTelegramAccountId(cfg) {
+	const boundDefault = resolveDefaultAgentBoundAccountId(cfg, "telegram");
+	if (boundDefault) return boundDefault;
+	const ids = listTelegramAccountIds(cfg);
+	if (ids.includes(DEFAULT_ACCOUNT_ID)) return DEFAULT_ACCOUNT_ID;
+	return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function resolveAccountConfig(cfg, accountId) {
+	const normalized = normalizeAccountId(accountId);
+	return resolveAccountEntry(cfg.channels?.telegram?.accounts, normalized);
+}
+function mergeTelegramAccountConfig(cfg, accountId) {
+	const { accounts: _ignored, ...base } = cfg.channels?.telegram ?? {};
+	const account = resolveAccountConfig(cfg, accountId) ?? {};
+	return {
+		...base,
+		...account
+	};
+}
+function createTelegramActionGate(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	return createAccountActionGate({
+		baseActions: params.cfg.channels?.telegram?.actions,
+		accountActions: resolveAccountConfig(params.cfg, accountId)?.actions
+	});
+}
+function resolveTelegramAccount(params) {
+	const hasExplicitAccountId = Boolean(params.accountId?.trim());
+	const baseEnabled = params.cfg.channels?.telegram?.enabled !== false;
+	const resolve = (accountId) => {
+		const merged = mergeTelegramAccountConfig(params.cfg, accountId);
+		const accountEnabled = merged.enabled !== false;
+		const enabled = baseEnabled && accountEnabled;
+		const tokenResolution = resolveTelegramToken(params.cfg, { accountId });
+		debugAccounts("resolve", {
+			accountId,
+			enabled,
+			tokenSource: tokenResolution.source
+		});
+		return {
+			accountId,
+			enabled,
+			name: merged.name?.trim() || void 0,
+			token: tokenResolution.token,
+			tokenSource: tokenResolution.source,
+			config: merged
+		};
+	};
+	const primary = resolve(normalizeAccountId(params.accountId));
+	if (hasExplicitAccountId) return primary;
+	if (primary.tokenSource !== "none") return primary;
+	const fallbackId = resolveDefaultTelegramAccountId(params.cfg);
+	if (fallbackId === primary.accountId) return primary;
+	const fallback = resolve(fallbackId);
+	if (fallback.tokenSource === "none") return primary;
+	return fallback;
+}
+function listEnabledTelegramAccounts(cfg) {
+	return listTelegramAccountIds(cfg).map((accountId) => resolveTelegramAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+
+//#endregion
+export { resolveTelegramAccount as a, resolveDefaultTelegramAccountId as i, listEnabledTelegramAccounts as n, resolveTelegramToken as o, listTelegramAccountIds as r, createAccountActionGate as s, createTelegramActionGate as t };