stableclaw 2026.5.7 → 2026.5.8

package/dist/accounts-O3HhBmp3.js

@@ -0,0 +1,107 @@
+import { _ as normalizeAccountId$1, g as DEFAULT_ACCOUNT_ID, v as normalizeOptionalAccountId } from "./session-key-Do__tq1E.js";
+import { t as resolveAccountEntry } from "./account-lookup-CLJxpfHr.js";
+import { i as tryReadSecretFileSync } from "./secret-file-82X1ac7s.js";
+import "./core-D0xWssw_.js";
+import "./account-resolution-BE2iK1d0.js";
+//#region extensions/line/src/accounts.ts
+function readFileIfExists(filePath) {
+	return tryReadSecretFileSync(filePath, "LINE credential file", { rejectSymlink: true });
+}
+function resolveToken(params) {
+	const { accountId, baseConfig, accountConfig } = params;
+	if (accountConfig?.channelAccessToken?.trim()) return {
+		token: accountConfig.channelAccessToken.trim(),
+		tokenSource: "config"
+	};
+	const accountFileToken = readFileIfExists(accountConfig?.tokenFile);
+	if (accountFileToken) return {
+		token: accountFileToken,
+		tokenSource: "file"
+	};
+	if (accountId === "default") {
+		if (baseConfig?.channelAccessToken?.trim()) return {
+			token: baseConfig.channelAccessToken.trim(),
+			tokenSource: "config"
+		};
+		const baseFileToken = readFileIfExists(baseConfig?.tokenFile);
+		if (baseFileToken) return {
+			token: baseFileToken,
+			tokenSource: "file"
+		};
+		const envToken = process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim();
+		if (envToken) return {
+			token: envToken,
+			tokenSource: "env"
+		};
+	}
+	return {
+		token: "",
+		tokenSource: "none"
+	};
+}
+function resolveSecret(params) {
+	const { accountId, baseConfig, accountConfig } = params;
+	if (accountConfig?.channelSecret?.trim()) return accountConfig.channelSecret.trim();
+	const accountFileSecret = readFileIfExists(accountConfig?.secretFile);
+	if (accountFileSecret) return accountFileSecret;
+	if (accountId === "default") {
+		if (baseConfig?.channelSecret?.trim()) return baseConfig.channelSecret.trim();
+		const baseFileSecret = readFileIfExists(baseConfig?.secretFile);
+		if (baseFileSecret) return baseFileSecret;
+		const envSecret = process.env.LINE_CHANNEL_SECRET?.trim();
+		if (envSecret) return envSecret;
+	}
+	return "";
+}
+function resolveLineAccount(params) {
+	const cfg = params.cfg;
+	const accountId = normalizeAccountId$1(params.accountId);
+	const lineConfig = cfg.channels?.line;
+	const accounts = lineConfig?.accounts;
+	const accountConfig = accountId !== "default" ? resolveAccountEntry(accounts, accountId) : void 0;
+	const { token, tokenSource } = resolveToken({
+		accountId,
+		baseConfig: lineConfig,
+		accountConfig
+	});
+	const secret = resolveSecret({
+		accountId,
+		baseConfig: lineConfig,
+		accountConfig
+	});
+	const { accounts: _ignoredAccounts, defaultAccount: _ignoredDefaultAccount, ...lineBase } = lineConfig ?? {};
+	const mergedConfig = {
+		...lineBase,
+		...accountConfig
+	};
+	const enabled = accountConfig?.enabled ?? (accountId === "default" ? lineConfig?.enabled ?? true : false);
+	return {
+		accountId,
+		name: accountConfig?.name ?? (accountId === "default" ? lineConfig?.name : void 0),
+		enabled,
+		channelAccessToken: token,
+		channelSecret: secret,
+		tokenSource,
+		config: mergedConfig
+	};
+}
+function listLineAccountIds(cfg) {
+	const lineConfig = cfg.channels?.line;
+	const accounts = lineConfig?.accounts;
+	const ids = /* @__PURE__ */ new Set();
+	if (lineConfig?.channelAccessToken?.trim() || lineConfig?.tokenFile || process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim()) ids.add(DEFAULT_ACCOUNT_ID);
+	if (accounts) for (const id of Object.keys(accounts)) ids.add(id);
+	return Array.from(ids);
+}
+function resolveDefaultLineAccountId(cfg) {
+	const preferred = normalizeOptionalAccountId((cfg.channels?.line)?.defaultAccount);
+	if (preferred && listLineAccountIds(cfg).some((accountId) => normalizeAccountId$1(accountId) === preferred)) return preferred;
+	const ids = listLineAccountIds(cfg);
+	if (ids.includes("default")) return DEFAULT_ACCOUNT_ID;
+	return ids[0] ?? "default";
+}
+function normalizeAccountId(accountId) {
+	return normalizeAccountId$1(accountId);
+}
+//#endregion
+export { resolveLineAccount as i, normalizeAccountId as n, resolveDefaultLineAccountId as r, listLineAccountIds as t };

package/dist/accounts-dfKIab-6.js

@@ -0,0 +1,137 @@
+import { t as createSubsystemLogger } from "./subsystem-C9VSlEcV.js";
+import { t as isTruthyEnvValue } from "./env-CK3eZNIX.js";
+import { _ as normalizeAccountId, g as DEFAULT_ACCOUNT_ID, v as normalizeOptionalAccountId } from "./session-key-Do__tq1E.js";
+import { t as resolveAccountEntry } from "./account-lookup-CLJxpfHr.js";
+import { i as listCombinedAccountIds, o as resolveListedDefaultAccountId } from "./account-helpers-B3XmfmJ0.js";
+import { t as createAccountActionGate } from "./account-action-gate-U0ieKQSn.js";
+import { n as resolveAccountWithDefaultFallback } from "./account-core-oOl1513K.js";
+import { i as resolveDefaultAgentBoundAccountId, r as listBoundAccountIds } from "./bindings-BlTpR5mO.js";
+import { n as formatSetExplicitDefaultInstruction } from "./default-account-warnings-Ko0NyGKz.js";
+import "./routing-BO-GF2kd.js";
+import { t as resolveTelegramToken } from "./token-DlP74SDv.js";
+import "./runtime-env-kT9i1SmC.js";
+import util from "node:util";
+//#region extensions/telegram/src/accounts.ts
+let log = null;
+function getLog() {
+	if (!log) log = createSubsystemLogger("telegram/accounts");
+	return log;
+}
+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.OPENCLAW_DEBUG_TELEGRAM_ACCOUNTS)) {
+		const parts = args.map((arg) => formatDebugArg(arg));
+		getLog().warn(parts.join(" ").trim());
+	}
+};
+function listConfiguredAccountIds(cfg) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(cfg.channels?.telegram?.accounts ?? {})) if (key) ids.add(normalizeAccountId(key));
+	return [...ids];
+}
+function listTelegramAccountIds(cfg) {
+	const ids = listCombinedAccountIds({
+		configuredAccountIds: listConfiguredAccountIds(cfg),
+		additionalAccountIds: listBoundAccountIds(cfg, "telegram"),
+		fallbackAccountIdWhenEmpty: DEFAULT_ACCOUNT_ID
+	});
+	debugAccounts("listTelegramAccountIds", ids);
+	return ids;
+}
+let emittedMissingDefaultWarn = false;
+/** @internal Reset the once-per-process warning flag. Exported for tests only. */
+function resetMissingDefaultWarnFlag() {
+	emittedMissingDefaultWarn = false;
+}
+function resolveDefaultTelegramAccountId(cfg) {
+	const boundDefault = resolveDefaultAgentBoundAccountId(cfg, "telegram");
+	if (boundDefault) return boundDefault;
+	const ids = listTelegramAccountIds(cfg);
+	const resolved = resolveListedDefaultAccountId({
+		accountIds: ids,
+		configuredDefaultAccountId: normalizeOptionalAccountId(cfg.channels?.telegram?.defaultAccount)
+	});
+	if (resolved !== ids[0] || ids.includes("default") || ids.length <= 1) return resolved;
+	if (ids.length > 1 && !emittedMissingDefaultWarn) {
+		emittedMissingDefaultWarn = true;
+		getLog().warn(`channels.telegram: accounts.default is missing; falling back to "${ids[0]}". ${formatSetExplicitDefaultInstruction("telegram")} to avoid routing surprises in multi-account setups.`);
+	}
+	return resolved;
+}
+function resolveTelegramAccountConfig(cfg, accountId) {
+	const normalized = normalizeAccountId(accountId);
+	return resolveAccountEntry(cfg.channels?.telegram?.accounts, normalized);
+}
+function mergeTelegramAccountConfig(cfg, accountId) {
+	const { accounts: _ignored, defaultAccount: _ignoredDefaultAccount, groups: channelGroups, ...base } = cfg.channels?.telegram ?? {};
+	const account = resolveTelegramAccountConfig(cfg, accountId) ?? {};
+	const isMultiAccount = Object.keys(cfg.channels?.telegram?.accounts ?? {}).length > 1;
+	const groups = account.groups ?? (isMultiAccount ? void 0 : channelGroups);
+	return {
+		...base,
+		...account,
+		groups
+	};
+}
+function createTelegramActionGate(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	return createAccountActionGate({
+		baseActions: params.cfg.channels?.telegram?.actions,
+		accountActions: resolveTelegramAccountConfig(params.cfg, accountId)?.actions
+	});
+}
+function resolveTelegramPollActionGateState(isActionEnabled) {
+	const sendMessageEnabled = isActionEnabled("sendMessage");
+	const pollEnabled = isActionEnabled("poll");
+	return {
+		sendMessageEnabled,
+		pollEnabled,
+		enabled: sendMessageEnabled && pollEnabled
+	};
+}
+function resolveTelegramAccount(params) {
+	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
+		};
+	};
+	return resolveAccountWithDefaultFallback({
+		accountId: params.accountId,
+		normalizeAccountId,
+		resolvePrimary: resolve,
+		hasCredential: (account) => account.tokenSource !== "none",
+		resolveDefaultAccountId: () => resolveDefaultTelegramAccountId(params.cfg)
+	});
+}
+function listEnabledTelegramAccounts(cfg) {
+	return listTelegramAccountIds(cfg).map((accountId) => resolveTelegramAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+//#endregion
+export { resetMissingDefaultWarnFlag as a, resolveTelegramAccountConfig as c, mergeTelegramAccountConfig as i, resolveTelegramPollActionGateState as l, listEnabledTelegramAccounts as n, resolveDefaultTelegramAccountId as o, listTelegramAccountIds as r, resolveTelegramAccount as s, createTelegramActionGate as t };