sealclaw 2026.6.21 → 2026.6.22-beta.2

package/dist/accounts-4pnlTaiJ.js

@@ -0,0 +1,119 @@
+import { c as normalizeOptionalString } from "./string-coerce-Bje8XVt9.js";
+import { t as isTruthyEnvValue } from "./env-BHSV01ZN.js";
+import { n as normalizeAccountId, r as normalizeOptionalAccountId } from "./account-id-BcgJyVVC.js";
+import { t as createSubsystemLogger } from "./subsystem-esWnFs2r.js";
+import { t as createAccountActionGate } from "./account-action-gate-cvRyQoKT.js";
+import { t as resolveAccountWithDefaultFallback } from "./account-core-Y9DXUWer.js";
+import { n as formatSetExplicitDefaultInstruction } from "./default-account-warnings-CMLymeWs.js";
+import "./routing-CnyCtmde.js";
+import { t as resolveTelegramToken } from "./token-BtaXi75U.js";
+import "./runtime-env-B53_WH7U.js";
+import "./string-coerce-runtime-CE1nsPWZ.js";
+import { n as resolveTelegramAccountConfig, t as mergeTelegramAccountConfig } from "./account-config-CIvupTgR.js";
+import { r as resolveDefaultTelegramAccountSelection, t as listTelegramAccountIds$1 } from "./account-selection-PGEqBTaT.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 listTelegramAccountIds(cfg) {
+	const ids = listTelegramAccountIds$1(cfg);
+	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 selection = resolveDefaultTelegramAccountSelection(cfg);
+	if (selection.shouldWarnMissingDefault && !emittedMissingDefaultWarn) {
+		emittedMissingDefaultWarn = true;
+		getLog().warn(`channels.telegram: accounts.default is missing; falling back to "${selection.accountId}". ${formatSetExplicitDefaultInstruction("telegram")} to avoid routing surprises in multi-account setups.`);
+	}
+	return selection.accountId;
+}
+function createTelegramActionGate(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultTelegramAccountId(params.cfg));
+	return createAccountActionGate({
+		baseActions: params.cfg.channels?.telegram?.actions,
+		accountActions: resolveTelegramAccountConfig(params.cfg, accountId)?.actions
+	});
+}
+function resolveTelegramMediaRuntimeOptions(params) {
+	const normalizedAccountId = normalizeOptionalAccountId(params.accountId);
+	const accountCfg = normalizedAccountId ? mergeTelegramAccountConfig(params.cfg, normalizedAccountId) : params.cfg.channels?.telegram;
+	return {
+		token: params.token,
+		transport: params.transport,
+		apiRoot: accountCfg?.apiRoot,
+		trustedLocalFileRoots: accountCfg?.trustedLocalFileRoots,
+		dangerouslyAllowPrivateNetwork: accountCfg?.network?.dangerouslyAllowPrivateNetwork
+	};
+}
+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: normalizeOptionalString(merged.name),
+			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) {
+	if (!(cfg.channels?.telegram?.enabled !== false)) return [];
+	return listTelegramAccountIds(cfg).filter((accountId) => mergeTelegramAccountConfig(cfg, accountId).enabled !== false).map((accountId) => resolveTelegramAccount({
+		cfg,
+		accountId
+	}));
+}
+//#endregion
+export { resolveDefaultTelegramAccountId as a, resolveTelegramPollActionGateState as c, resetMissingDefaultWarnFlag as i, listEnabledTelegramAccounts as n, resolveTelegramAccount as o, listTelegramAccountIds as r, resolveTelegramMediaRuntimeOptions as s, createTelegramActionGate as t };

package/dist/accounts-CYl4A3pg.js

@@ -0,0 +1,104 @@
+import { c as normalizeOptionalString } from "./string-coerce-Bje8XVt9.js";
+import { l as normalizeResolvedSecretInputString, u as normalizeSecretInputString } from "./types.secrets-CwOir82x.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-BcgJyVVC.js";
+import { a as tryReadSecretFileSync } from "./secret-file-Bmx2xaIk.js";
+import { t as resolveAccountEntry } from "./account-lookup-CZ_epDYU.js";
+import "./text-runtime-B3IJ6cVE.js";
+import { s as resolveMergedAccountConfig, t as createAccountListHelpers } from "./account-helpers-DXsAF8sQ.js";
+import "./core-Bihhaqfo.js";
+import "./routing-CnyCtmde.js";
+import "./secret-input-DsPmsisH.js";
+//#region extensions/zalo/src/token.ts
+function readTokenFromFile(tokenFile) {
+	return tryReadSecretFileSync(tokenFile, "Zalo token file", { rejectSymlink: true }) ?? "";
+}
+function resolveZaloToken(config, accountId, options) {
+	const resolvedAccountId = normalizeAccountId(accountId ?? config?.defaultAccount);
+	const isDefaultAccount = resolvedAccountId === DEFAULT_ACCOUNT_ID;
+	const baseConfig = config;
+	const accountConfig = resolveAccountEntry(baseConfig?.accounts, normalizeAccountId(resolvedAccountId));
+	const accountHasBotToken = Boolean(accountConfig && Object.prototype.hasOwnProperty.call(accountConfig, "botToken"));
+	if (accountConfig && accountHasBotToken) {
+		const token = options?.allowUnresolvedSecretRef ? normalizeSecretInputString(accountConfig.botToken) : normalizeResolvedSecretInputString({
+			value: accountConfig.botToken,
+			path: `channels.zalo.accounts.${resolvedAccountId}.botToken`
+		});
+		if (token) return {
+			token,
+			source: "config"
+		};
+		const fileToken = readTokenFromFile(accountConfig.tokenFile);
+		if (fileToken) return {
+			token: fileToken,
+			source: "configFile"
+		};
+	}
+	if (!accountHasBotToken) {
+		const fileToken = readTokenFromFile(accountConfig?.tokenFile);
+		if (fileToken) return {
+			token: fileToken,
+			source: "configFile"
+		};
+	}
+	if (!accountHasBotToken) {
+		const token = options?.allowUnresolvedSecretRef ? normalizeSecretInputString(baseConfig?.botToken) : normalizeResolvedSecretInputString({
+			value: baseConfig?.botToken,
+			path: "channels.zalo.botToken"
+		});
+		if (token) return {
+			token,
+			source: "config"
+		};
+		const fileToken = readTokenFromFile(baseConfig?.tokenFile);
+		if (fileToken) return {
+			token: fileToken,
+			source: "configFile"
+		};
+	}
+	if (isDefaultAccount) {
+		const envToken = process.env.ZALO_BOT_TOKEN?.trim();
+		if (envToken) return {
+			token: envToken,
+			source: "env"
+		};
+	}
+	return {
+		token: "",
+		source: "none"
+	};
+}
+//#endregion
+//#region extensions/zalo/src/accounts.ts
+const { listAccountIds: listZaloAccountIds, resolveDefaultAccountId: resolveDefaultZaloAccountId } = createAccountListHelpers("zalo");
+function mergeZaloAccountConfig(cfg, accountId) {
+	return resolveMergedAccountConfig({
+		channelConfig: cfg.channels?.zalo,
+		accounts: (cfg.channels?.zalo)?.accounts,
+		accountId,
+		omitKeys: ["defaultAccount"]
+	});
+}
+function resolveZaloAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? (params.cfg.channels?.zalo)?.defaultAccount);
+	const baseEnabled = (params.cfg.channels?.zalo)?.enabled !== false;
+	const merged = mergeZaloAccountConfig(params.cfg, accountId);
+	const accountEnabled = merged.enabled !== false;
+	const enabled = baseEnabled && accountEnabled;
+	const tokenResolution = resolveZaloToken(params.cfg.channels?.zalo, accountId, { allowUnresolvedSecretRef: params.allowUnresolvedSecretRef });
+	return {
+		accountId,
+		name: normalizeOptionalString(merged.name),
+		enabled,
+		token: tokenResolution.token,
+		tokenSource: tokenResolution.source,
+		config: merged
+	};
+}
+function listEnabledZaloAccounts(cfg) {
+	return listZaloAccountIds(cfg).map((accountId) => resolveZaloAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+//#endregion
+export { resolveZaloToken as a, resolveZaloAccount as i, listZaloAccountIds as n, resolveDefaultZaloAccountId as r, listEnabledZaloAccounts as t };

package/dist/accounts-CeQjzCEG.js

@@ -0,0 +1,2 @@
+import { i as resolveZaloAccount } from "./accounts-CYl4A3pg.js";
+export { resolveZaloAccount };

package/dist/accounts-Ms0vFeii.js

@@ -0,0 +1,107 @@
+import { n as normalizeAccountId$1, r as normalizeOptionalAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-BcgJyVVC.js";
+import { a as tryReadSecretFileSync } from "./secret-file-Bmx2xaIk.js";
+import { t as resolveAccountEntry } from "./account-lookup-CZ_epDYU.js";
+import "./core-Bihhaqfo.js";
+import "./account-resolution-BDMGodS_.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 ?? resolveDefaultLineAccountId(cfg));
+	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/acp-runtime-D9jPYUAr.js

@@ -0,0 +1,26 @@
+import "./errors-DwkYlX0H.js";
+import { t as __testing$1 } from "./manager-Dth9AwGy.js";
+import { t as __testing$2 } from "./registry-DyJDiZHA.js";
+import "./session-meta-B03JMB75.js";
+import "./acp-runtime-backend-DdnMXsfK.js";
+//#region src/plugin-sdk/acp-runtime.ts
+const __testing = new Proxy({}, {
+	get(_target, prop, receiver) {
+		if (Reflect.has(__testing$1, prop)) return Reflect.get(__testing$1, prop, receiver);
+		return Reflect.get(__testing$2, prop, receiver);
+	},
+	has(_target, prop) {
+		return Reflect.has(__testing$1, prop) || Reflect.has(__testing$2, prop);
+	},
+	ownKeys() {
+		return Array.from(new Set([...Reflect.ownKeys(__testing$1), ...Reflect.ownKeys(__testing$2)]));
+	},
+	getOwnPropertyDescriptor(_target, prop) {
+		if (Reflect.has(__testing$1, prop) || Reflect.has(__testing$2, prop)) return {
+			configurable: true,
+			enumerable: true
+		};
+	}
+});
+//#endregion
+export { __testing as t };

package/dist/acp-spawn-CFHqN10S.js

@@ -0,0 +1,2 @@
+import { a as ACP_SPAWN_SESSION_ACCEPTED_NOTE, c as resolveAcpSpawnRuntimePolicyError, i as ACP_SPAWN_SANDBOX_MODES, l as spawnAcpDirect, n as ACP_SPAWN_ERROR_CODES, o as ACP_SPAWN_STREAM_TARGETS, r as ACP_SPAWN_MODES, s as isSpawnAcpAcceptedResult, t as ACP_SPAWN_ACCEPTED_NOTE } from "./acp-spawn-libpfd9W.js";
+export { ACP_SPAWN_ACCEPTED_NOTE, ACP_SPAWN_ERROR_CODES, ACP_SPAWN_MODES, ACP_SPAWN_SANDBOX_MODES, ACP_SPAWN_SESSION_ACCEPTED_NOTE, ACP_SPAWN_STREAM_TARGETS, isSpawnAcpAcceptedResult, resolveAcpSpawnRuntimePolicyError, spawnAcpDirect };