kaijibot 2026.5.28 → 2026.5.30

package/dist/.buildstamp

@@ -1 +1 @@
-{"builtAt":1779974780871,"head":"73bb700db65987ee146c8f099f997abac7c85d8d"}
+{"builtAt":1780123067504,"head":"dc50aa353d2005c345b2bb72450987036701c9d6"}

package/dist/abort-DBCNkKwZ.js

@@ -0,0 +1,202 @@
+import { r as formatErrorMessage } from "./errors-CGMew-1w.js";
+import { o as normalizeOptionalLowercaseString, s as normalizeOptionalString } from "./string-coerce-CIT1-v_a.js";
+import { S as parseAgentSessionKey } from "./session-key-NGoeHrFI.js";
+import { v as resolveSessionAgentId } from "./agent-scope-Bwe-3h82.js";
+import { r as logVerbose } from "./globals-D7B2Z7Cq.js";
+import { a as resolveSessionStoreEntry, c as updateSessionStore } from "./store-DKYfdKsO.js";
+import "./sessions-cD3jqfYn.js";
+import { l as resolveStorePath } from "./paths-DjA1ZhOF.js";
+import { t as loadSessionStore } from "./store-load-zIQ9BlB5.js";
+import { o as getLatestSubagentRunByChildSessionKey, p as markSubagentRunTerminated, u as listSubagentRunsForController } from "./subagent-registry-DH4A2pOI.js";
+import { b as resolveMainSessionAlias, y as resolveInternalSessionKey } from "./subagents-format-D6WpXIuq.js";
+import { i as clearSessionQueues } from "./queue-CCZjtlcE.js";
+import { h as replyRunRegistry, t as abortEmbeddedPiRun } from "./runs-ZVLXCT6F.js";
+import { n as getAcpSessionManager } from "./manager-B1esDIp_.js";
+import "./pi-embedded-_V28ZxA9.js";
+import { i as setAbortMemory, n as isAbortRequestText } from "./abort-primitives-Cam9MYAV.js";
+import { o as stripMentions, s as stripStructuralPrefixes } from "./mentions-DhN_n6QL.js";
+import { t as resolveCommandAuthorization } from "./command-auth-eEcL9bo4.js";
+import { a as shouldPersistAbortCutoff, i as resolveAbortCutoffFromContext, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-CkEiIsna.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-cutoff.runtime-EZHf3_Xe.js

@@ -0,0 +1,20 @@
+import { c as updateSessionStore } from "./store-DKYfdKsO.js";
+import { n as hasAbortCutoff, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-CkEiIsna.js";
+//#region src/auto-reply/reply/abort-cutoff.runtime.ts
+async function clearAbortCutoffInSessionRuntime(params) {
+	const { sessionEntry, sessionStore, sessionKey, storePath } = params;
+	if (!sessionEntry || !sessionStore || !sessionKey || !hasAbortCutoff(sessionEntry)) return false;
+	applyAbortCutoffToSessionEntry(sessionEntry, void 0);
+	sessionEntry.updatedAt = Date.now();
+	sessionStore[sessionKey] = sessionEntry;
+	if (storePath) await updateSessionStore(storePath, (store) => {
+		const existing = store[sessionKey] ?? sessionEntry;
+		if (!existing) return;
+		applyAbortCutoffToSessionEntry(existing, void 0);
+		existing.updatedAt = Date.now();
+		store[sessionKey] = existing;
+	});
+	return true;
+}
+//#endregion
+export { clearAbortCutoffInSessionRuntime };

package/dist/abort-cutoff.runtime.js

@@ -1 +1 @@
-export * from "./abort-cutoff.runtime-NXmUwFY3.js";
+export * from "./abort-cutoff.runtime-EZHf3_Xe.js";

package/dist/abort-primitives-Cam9MYAV.js

@@ -0,0 +1,93 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-CIT1-v_a.js";
+import { p as normalizeCommandBody } from "./commands-registry-B1Nz97hm.js";
+//#region src/auto-reply/reply/abort-primitives.ts
+const ABORT_TRIGGERS = new Set([
+	"stop",
+	"esc",
+	"abort",
+	"wait",
+	"exit",
+	"interrupt",
+	"detente",
+	"deten",
+	"detén",
+	"arrete",
+	"arrête",
+	"停止",
+	"やめて",
+	"止めて",
+	"रुको",
+	"توقف",
+	"стоп",
+	"остановись",
+	"останови",
+	"остановить",
+	"прекрати",
+	"halt",
+	"anhalten",
+	"aufhören",
+	"hoer auf",
+	"stopp",
+	"pare",
+	"stop kaijibot",
+	"kaijibot stop",
+	"stop action",
+	"stop current action",
+	"stop run",
+	"stop current run",
+	"stop agent",
+	"stop the agent",
+	"stop don't do anything",
+	"stop dont do anything",
+	"stop do not do anything",
+	"stop doing anything",
+	"do not do that",
+	"please stop",
+	"stop please"
+]);
+const ABORT_MEMORY = /* @__PURE__ */ new Map();
+const ABORT_MEMORY_MAX = 2e3;
+const TRAILING_ABORT_PUNCTUATION_RE = /[.!?…,，。;；:：'"’”)\]}]+$/u;
+function normalizeAbortTriggerText(text) {
+	return normalizeLowercaseStringOrEmpty(text).replace(/[’`]/g, "'").replace(/\s+/g, " ").replace(TRAILING_ABORT_PUNCTUATION_RE, "").trim();
+}
+function isAbortTrigger(text) {
+	if (!text) return false;
+	const normalized = normalizeAbortTriggerText(text);
+	return ABORT_TRIGGERS.has(normalized);
+}
+function isAbortRequestText(text, options) {
+	if (!text) return false;
+	const normalized = normalizeCommandBody(text, options).trim();
+	if (!normalized) return false;
+	const normalizedLower = normalizeLowercaseStringOrEmpty(normalized);
+	return normalizedLower === "/stop" || normalizeAbortTriggerText(normalizedLower) === "/stop" || isAbortTrigger(normalizedLower);
+}
+function getAbortMemory(key) {
+	const normalized = key.trim();
+	if (!normalized) return;
+	return ABORT_MEMORY.get(normalized);
+}
+function pruneAbortMemory() {
+	if (ABORT_MEMORY.size <= ABORT_MEMORY_MAX) return;
+	const excess = ABORT_MEMORY.size - ABORT_MEMORY_MAX;
+	let removed = 0;
+	for (const entryKey of ABORT_MEMORY.keys()) {
+		ABORT_MEMORY.delete(entryKey);
+		removed += 1;
+		if (removed >= excess) break;
+	}
+}
+function setAbortMemory(key, value) {
+	const normalized = key.trim();
+	if (!normalized) return;
+	if (!value) {
+		ABORT_MEMORY.delete(normalized);
+		return;
+	}
+	if (ABORT_MEMORY.has(normalized)) ABORT_MEMORY.delete(normalized);
+	ABORT_MEMORY.set(normalized, true);
+	pruneAbortMemory();
+}
+//#endregion
+export { setAbortMemory as i, isAbortRequestText as n, isAbortTrigger as r, getAbortMemory as t };

package/dist/abort.runtime-CmIAJb2l.js

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

package/dist/abort.runtime.js

@@ -1 +1 @@
-export * from "./abort.runtime-DV89ceO0.js";
+export * from "./abort.runtime-CmIAJb2l.js";

package/dist/account-action-gate-BAD2nVDS.js

@@ -0,0 +1,114 @@
+import { s as normalizeOptionalString } from "./string-coerce-CIT1-v_a.js";
+import { n as normalizeAccountId, r as normalizeOptionalAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-Dw-dpL-T.js";
+import { n as resolveNormalizedAccountEntry, t as resolveAccountEntry } from "./account-lookup-RhAcGWBO.js";
+//#region src/channels/plugins/account-helpers.ts
+function createAccountListHelpers(channelKey, options) {
+	function resolveConfiguredDefaultAccountId(cfg) {
+		const channel = cfg.channels?.[channelKey];
+		const preferred = normalizeOptionalAccountId(typeof channel?.defaultAccount === "string" ? channel.defaultAccount : void 0);
+		if (!preferred) return;
+		const ids = listAccountIds(cfg);
+		if (options?.allowUnlistedDefaultAccount) return preferred;
+		if (ids.some((id) => normalizeAccountId(id) === preferred)) return preferred;
+	}
+	function listConfiguredAccountIds(cfg) {
+		const accounts = (cfg.channels?.[channelKey])?.accounts;
+		if (!accounts || typeof accounts !== "object") return [];
+		const ids = Object.keys(accounts).filter(Boolean);
+		const normalizeConfiguredAccountId = options?.normalizeAccountId;
+		if (!normalizeConfiguredAccountId) return ids;
+		return [...new Set(ids.map((id) => normalizeConfiguredAccountId(id)).filter(Boolean))];
+	}
+	function listAccountIds(cfg) {
+		return listCombinedAccountIds({
+			configuredAccountIds: listConfiguredAccountIds(cfg),
+			fallbackAccountIdWhenEmpty: DEFAULT_ACCOUNT_ID
+		});
+	}
+	function resolveDefaultAccountId(cfg) {
+		return resolveListedDefaultAccountId({
+			accountIds: listAccountIds(cfg),
+			configuredDefaultAccountId: resolveConfiguredDefaultAccountId(cfg),
+			allowUnlistedDefaultAccount: options?.allowUnlistedDefaultAccount
+		});
+	}
+	return {
+		listConfiguredAccountIds,
+		listAccountIds,
+		resolveDefaultAccountId
+	};
+}
+function listCombinedAccountIds(params) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const id of params.configuredAccountIds) if (id) ids.add(id);
+	for (const id of params.additionalAccountIds ?? []) if (id) ids.add(id);
+	if (params.implicitAccountId) ids.add(params.implicitAccountId);
+	if (ids.size === 0 && params.fallbackAccountIdWhenEmpty) return [params.fallbackAccountIdWhenEmpty];
+	return [...ids].toSorted((a, b) => a.localeCompare(b));
+}
+function resolveListedDefaultAccountId(params) {
+	const preferred = params.configuredDefaultAccountId;
+	const normalizeListedAccountId = params.normalizeListedAccountId ?? normalizeAccountId;
+	if (preferred && (params.allowUnlistedDefaultAccount || params.accountIds.some((accountId) => normalizeListedAccountId(accountId) === preferred))) return preferred;
+	if (params.accountIds.includes("default")) return DEFAULT_ACCOUNT_ID;
+	if (params.ambiguousFallbackAccountId && params.accountIds.length > 1) return params.ambiguousFallbackAccountId;
+	return params.accountIds[0] ?? "default";
+}
+function mergeAccountConfig(params) {
+	const omitKeys = new Set(["accounts", ...params.omitKeys ?? []]);
+	const base = Object.fromEntries(Object.entries(params.channelConfig ?? {}).filter(([key]) => !omitKeys.has(key)));
+	const merged = {
+		...base,
+		...params.accountConfig
+	};
+	for (const key of params.nestedObjectKeys ?? []) {
+		const baseValue = base[key];
+		const accountValue = params.accountConfig?.[key];
+		if (typeof baseValue === "object" && baseValue != null && !Array.isArray(baseValue) && typeof accountValue === "object" && accountValue != null && !Array.isArray(accountValue)) merged[key] = {
+			...baseValue,
+			...accountValue
+		};
+	}
+	return merged;
+}
+function resolveMergedAccountConfig(params) {
+	const accountConfig = params.normalizeAccountId ? resolveNormalizedAccountEntry(params.accounts, params.accountId, params.normalizeAccountId) : resolveAccountEntry(params.accounts, params.accountId);
+	return mergeAccountConfig({
+		channelConfig: params.channelConfig,
+		accountConfig,
+		omitKeys: params.omitKeys,
+		nestedObjectKeys: params.nestedObjectKeys
+	});
+}
+function describeAccountSnapshot(params) {
+	return {
+		accountId: String(params.account.accountId ?? "default"),
+		name: normalizeOptionalString(params.account.name),
+		enabled: params.account.enabled !== false,
+		configured: params.configured,
+		...params.extra
+	};
+}
+function describeWebhookAccountSnapshot(params) {
+	return describeAccountSnapshot({
+		account: params.account,
+		configured: params.configured,
+		extra: {
+			mode: params.mode ?? "webhook",
+			...params.extra
+		}
+	});
+}
+//#endregion
+//#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
+export { listCombinedAccountIds as a, resolveMergedAccountConfig as c, describeWebhookAccountSnapshot as i, createAccountListHelpers as n, mergeAccountConfig as o, describeAccountSnapshot as r, resolveListedDefaultAccountId as s, createAccountActionGate as t };

package/dist/account-resolution-N3pV1CaV.js

@@ -0,0 +1,2 @@
+import "./account-core-DOXohoT3.js";
+export {};

package/dist/account-summary-subu2u4W.js

@@ -0,0 +1,33 @@
+import { l as isRecord } from "./utils-CE5zxr9Z.js";
+import { s as normalizeStringEntries } from "./string-normalization-vTvIsBsq.js";
+import { i as projectSafeChannelAccountSnapshotFields } from "./account-snapshot-fields-BT_RikBZ.js";
+//#region src/channels/account-summary.ts
+function buildChannelAccountSnapshot(params) {
+	const described = params.plugin.config.describeAccount?.(params.account, params.cfg);
+	return {
+		enabled: params.enabled,
+		configured: params.configured,
+		...projectSafeChannelAccountSnapshotFields(params.account),
+		...described,
+		accountId: params.accountId
+	};
+}
+function formatChannelAllowFrom(params) {
+	if (params.plugin.config.formatAllowFrom) return params.plugin.config.formatAllowFrom({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		allowFrom: params.allowFrom
+	});
+	return normalizeStringEntries(params.allowFrom);
+}
+function resolveChannelAccountEnabled(params) {
+	if (params.plugin.config.isEnabled) return params.plugin.config.isEnabled(params.account, params.cfg);
+	return (isRecord(params.account) ? params.account.enabled : void 0) !== false;
+}
+async function resolveChannelAccountConfigured(params) {
+	if (params.plugin.config.isConfigured) return await params.plugin.config.isConfigured(params.account, params.cfg);
+	if (params.readAccountConfiguredField) return (isRecord(params.account) ? params.account.configured : void 0) !== false;
+	return true;
+}
+//#endregion
+export { resolveChannelAccountEnabled as i, formatChannelAllowFrom as n, resolveChannelAccountConfigured as r, buildChannelAccountSnapshot as t };