@pixelzx/genesis 2026.5.3-5 → 2026.5.5

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Docs: https://docs.genesis.ai
 
+## 2026.5.5
+
+### Fixes
+
+- Control UI: run installed Vite and Vitest directly when `pnpm` is unavailable, and prefer an external Node binary over app-bundled Node on macOS so source checkouts can still build and test the browser UI.
+- Update: keep legacy SDK alias inventory entries in release packages so stable updates from `2026.5.3-5` do not fail package dist verification after postinstall repairs the alias.
+- Packaging: tighten stable release tarball validation on Blacksmith so missing Control UI assets or bundled plugin runtime mirrors are caught before npm publishes to `latest`.
+
 ## 2026.5.3-5
 
 ### Changes

package/dist/.buildstamp

@@ -1 +1 @@
-{"builtAt":1777905182239,"head":"098b75fc91ab8fe1977bb8356641c4a77a59af3e"}
+{"builtAt":1777945936091,"head":"3a5a74683aa593ae5b3b13e4a399c834090a6df7"}

package/dist/abort-t5XiT6Yl.js

@@ -0,0 +1,201 @@
+import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-C1IzJjqi.js";
+import { r as logVerbose } from "./globals-C5IxqXPj.js";
+import { o as parseAgentSessionKey } from "./session-key-utils-BT0y7mVK.js";
+import { p as resolveSessionAgentId } from "./agent-scope-CDjZLqNk.js";
+import { u as resolveStorePath } from "./paths-DD6L4IvS.js";
+import { t as loadSessionStore } from "./store-load-DevCJoMp.js";
+import { l as resolveSessionStoreEntry, o as updateSessionStore } from "./store-DsNJP7a2.js";
+import "./sessions-BsnttWP_.js";
+import { o as resolveInternalSessionKey, s as resolveMainSessionAlias } from "./sessions-helpers-YOu_5tl0.js";
+import { a as clearSessionQueues } from "./queue-C2h8xD0q.js";
+import { h as replyRunRegistry, t as abortEmbeddedPiRun } from "./runs-BeROanhp.js";
+import { f as markSubagentRunTerminated, o as getLatestSubagentRunByChildSessionKey, u as listSubagentRunsForController } from "./subagent-registry-BgQA8eP1.js";
+import { i as setAbortMemory, n as isAbortRequestText } from "./abort-primitives-B2NIccgr.js";
+import { o as stripMentions, s as stripStructuralPrefixes } from "./mentions-Dm5IQz51.js";
+import { t as resolveCommandAuthorization } from "./command-auth-Df2_EfEZ.js";
+import { a as shouldPersistAbortCutoff, i as resolveAbortCutoffFromContext, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-ICh6JSMK.js";
+import { n as getAcpSessionManager } from "./manager-Df8TC4rX.js";
+const abortDeps = {
+	getAcpSessionManager,
+	abortEmbeddedPiRun,
+	getLatestSubagentRunByChildSessionKey,
+	listSubagentRunsForController,
+	markSubagentRunTerminated
+};
+function formatAbortReplyText(stoppedSubagents) {
+	if (typeof stoppedSubagents !== "number" || stoppedSubagents <= 0) return "⚙️ Agent was aborted.";
+	return `⚙️ Agent was aborted. Stopped ${stoppedSubagents} ${stoppedSubagents === 1 ? "sub-agent" : "sub-agents"}.`;
+}
+function resolveSessionEntryForKey(store, sessionKey) {
+	if (!store || !sessionKey) return {};
+	const resolved = resolveSessionStoreEntry({
+		store,
+		sessionKey
+	});
+	if (resolved.existing) return resolved.legacyKeys.length > 0 ? {
+		entry: resolved.existing,
+		key: resolved.normalizedKey,
+		legacyKeys: resolved.legacyKeys
+	} : {
+		entry: resolved.existing,
+		key: resolved.normalizedKey
+	};
+	return {};
+}
+function normalizeRequesterSessionKey(cfg, key) {
+	const cleaned = normalizeOptionalString(key);
+	if (!cleaned) return;
+	const { mainKey, alias } = resolveMainSessionAlias(cfg);
+	return resolveInternalSessionKey({
+		key: cleaned,
+		alias,
+		mainKey
+	});
+}
+function stopSubagentsForRequester(params) {
+	const requesterKey = normalizeRequesterSessionKey(params.cfg, params.requesterSessionKey);
+	if (!requesterKey) return { stopped: 0 };
+	const dedupedRunsByChildKey = /* @__PURE__ */ new Map();
+	for (const run of abortDeps.listSubagentRunsForController(requesterKey)) {
+		const childKey = normalizeOptionalString(run.childSessionKey);
+		if (!childKey) continue;
+		const latest = abortDeps.getLatestSubagentRunByChildSessionKey(childKey);
+		if (!latest) {
+			const existing = dedupedRunsByChildKey.get(childKey);
+			if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
+			continue;
+		}
+		const latestControllerSessionKey = normalizeOptionalString(latest?.controllerSessionKey) ?? normalizeOptionalString(latest?.requesterSessionKey);
+		if (latest.runId !== run.runId || latestControllerSessionKey !== requesterKey) continue;
+		const existing = dedupedRunsByChildKey.get(childKey);
+		if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
+	}
+	const runs = Array.from(dedupedRunsByChildKey.values());
+	if (runs.length === 0) return { stopped: 0 };
+	const storeCache = /* @__PURE__ */ new Map();
+	const seenChildKeys = /* @__PURE__ */ new Set();
+	let stopped = 0;
+	for (const run of runs) {
+		const childKey = normalizeOptionalString(run.childSessionKey);
+		if (!childKey || seenChildKeys.has(childKey)) continue;
+		seenChildKeys.add(childKey);
+		if (!run.endedAt) {
+			const cleared = clearSessionQueues([childKey]);
+			const parsed = parseAgentSessionKey(childKey);
+			const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId });
+			let store = storeCache.get(storePath);
+			if (!store) {
+				store = loadSessionStore(storePath);
+				storeCache.set(storePath, store);
+			}
+			const entry = store[childKey];
+			const sessionId = replyRunRegistry.resolveSessionId(childKey) ?? entry?.sessionId;
+			const aborted = (childKey ? replyRunRegistry.abort(childKey) : false) || (sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false);
+			if (abortDeps.markSubagentRunTerminated({
+				runId: run.runId,
+				childSessionKey: childKey,
+				reason: "killed"
+			}) > 0 || aborted || cleared.followupCleared > 0 || cleared.laneCleared > 0) stopped += 1;
+		}
+		const cascadeResult = stopSubagentsForRequester({
+			cfg: params.cfg,
+			requesterSessionKey: childKey
+		});
+		stopped += cascadeResult.stopped;
+	}
+	if (stopped > 0) logVerbose(`abort: stopped ${stopped} subagent run(s) for ${requesterKey}`);
+	return { stopped };
+}
+async function tryFastAbortFromMessage(params) {
+	const { ctx, cfg } = params;
+	const targetKey = normalizeOptionalString(ctx.CommandTargetSessionKey) ?? normalizeOptionalString(ctx.SessionKey);
+	const raw = stripStructuralPrefixes(ctx.CommandBody ?? ctx.RawBody ?? ctx.Body ?? "");
+	if (!isAbortRequestText(normalizeOptionalLowercaseString(ctx.ChatType) === "group" ? stripMentions(raw, ctx, cfg, resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	})) : raw)) return {
+		handled: false,
+		aborted: false
+	};
+	const commandAuthorized = ctx.CommandAuthorized;
+	const auth = resolveCommandAuthorization({
+		ctx,
+		cfg,
+		commandAuthorized
+	});
+	if (!auth.isAuthorizedSender) return {
+		handled: false,
+		aborted: false
+	};
+	const agentId = resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	});
+	const abortKey = targetKey ?? auth.from ?? auth.to;
+	const requesterSessionKey = targetKey ?? ctx.SessionKey ?? abortKey;
+	if (targetKey) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		const store = loadSessionStore(storePath);
+		const { entry, key, legacyKeys } = resolveSessionEntryForKey(store, targetKey);
+		const resolvedTargetKey = key ?? targetKey;
+		const acpManager = abortDeps.getAcpSessionManager();
+		if (acpManager.resolveSession({
+			cfg,
+			sessionKey: resolvedTargetKey
+		}).kind !== "none") try {
+			await acpManager.cancelSession({
+				cfg,
+				sessionKey: resolvedTargetKey,
+				reason: "fast-abort"
+			});
+		} catch (error) {
+			logVerbose(`abort: ACP cancel failed for ${resolvedTargetKey}: ${formatErrorMessage(error)}`);
+		}
+		const sessionId = replyRunRegistry.resolveSessionId(resolvedTargetKey) ?? entry?.sessionId;
+		const aborted = replyRunRegistry.abort(resolvedTargetKey) || (sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false);
+		const cleared = clearSessionQueues([resolvedTargetKey, sessionId]);
+		if (cleared.followupCleared > 0 || cleared.laneCleared > 0) logVerbose(`abort: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+		const abortCutoff = shouldPersistAbortCutoff({
+			commandSessionKey: ctx.SessionKey,
+			targetSessionKey: resolvedTargetKey
+		}) ? resolveAbortCutoffFromContext(ctx) : void 0;
+		if (entry && key) {
+			entry.abortedLastRun = true;
+			applyAbortCutoffToSessionEntry(entry, abortCutoff);
+			entry.updatedAt = Date.now();
+			store[key] = entry;
+			for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete store[legacyKey];
+			await updateSessionStore(storePath, (nextStore) => {
+				const nextEntry = nextStore[key] ?? entry;
+				if (!nextEntry) return;
+				nextEntry.abortedLastRun = true;
+				applyAbortCutoffToSessionEntry(nextEntry, abortCutoff);
+				nextEntry.updatedAt = Date.now();
+				nextStore[key] = nextEntry;
+				for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete nextStore[legacyKey];
+			});
+		} else if (abortKey) setAbortMemory(abortKey, true);
+		const { stopped } = stopSubagentsForRequester({
+			cfg,
+			requesterSessionKey
+		});
+		return {
+			handled: true,
+			aborted,
+			stoppedSubagents: stopped
+		};
+	}
+	if (abortKey) setAbortMemory(abortKey, true);
+	const { stopped } = stopSubagentsForRequester({
+		cfg,
+		requesterSessionKey
+	});
+	return {
+		handled: true,
+		aborted: false,
+		stoppedSubagents: stopped
+	};
+}
+//#endregion
+export { tryFastAbortFromMessage as i, resolveSessionEntryForKey as n, stopSubagentsForRequester as r, formatAbortReplyText as t };

package/dist/abort.runtime-C_xk0DkL.js

@@ -0,0 +1,2 @@
+import { i as tryFastAbortFromMessage, t as formatAbortReplyText } from "./abort-t5XiT6Yl.js";
+export { formatAbortReplyText, tryFastAbortFromMessage };

package/dist/abort.runtime.js

@@ -1 +1 @@
-export * from "./abort.runtime-BrChEuUS.js";
+export * from "./abort.runtime-C_xk0DkL.js";

package/dist/accounts-B7yDKwxi.js

@@ -0,0 +1,104 @@
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { l as normalizeResolvedSecretInputString, u as normalizeSecretInputString } from "./types.secrets-ews2W8BF.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-C3j_3_su.js";
+import { t as resolveAccountEntry } from "./account-lookup-B3p3r-Uq.js";
+import "./text-runtime-7KpTTpVi.js";
+import { s as resolveMergedAccountConfig, t as createAccountListHelpers } from "./account-helpers-PRuprToh.js";
+import { o as tryReadSecretFileSync } from "./secret-file-CM0P-Rsm.js";
+import "./core-PXv1nsc-.js";
+import "./routing-lEBa2-AE.js";
+import "./secret-input-DnSXDYEn.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-CS7VL356.js

@@ -0,0 +1,107 @@
+import { n as normalizeAccountId$1, r as normalizeOptionalAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-C3j_3_su.js";
+import { t as resolveAccountEntry } from "./account-lookup-B3p3r-Uq.js";
+import { o as tryReadSecretFileSync } from "./secret-file-CM0P-Rsm.js";
+import "./core-PXv1nsc-.js";
+import "./account-resolution-CCoiqE4j.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/accounts-XvHcAtMf.js

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