@sentry/junior 0.258.0 → 0.260.0

package/dist/adapter-Dj5BTJRd.js

@@ -0,0 +1,270 @@
+import { i as getChatConfig } from "./config-ULs6Zl9b.js";
+import { createMemoryState } from "@chat-adapter/state-memory";
+import { createRedisState } from "@chat-adapter/state-redis";
+import { setTimeout } from "node:timers/promises";
+// src/chat/state/locks.ts
+const ACTIVE_LOCK_TTL_MS = 9e4;
+const MUTATION_LOCK_TTL_MS = 1e4;
+/**
+* Acquire a lock for long-running work that the queued state adapter should
+* keep alive while the owning invocation is still making progress.
+*/
+async function acquireActiveLock(state, threadId) {
+	return await state.acquireLock(threadId, ACTIVE_LOCK_TTL_MS);
+}
+/**
+* Run work under one lock, optionally waiting for the current owner.
+* `keepAlive` is for multi-store mutations that must retain ownership until all
+* side effects finish; callers should still fence each blind write.
+*/
+async function withLock(state, key, run, options = {}) {
+	const startedAtMs = Date.now();
+	let lock;
+	while (true) {
+		lock = await state.acquireLock(key, options.ttlMs ?? 9e4);
+		if (lock) break;
+		if (Date.now() - startedAtMs >= (options.waitMs ?? 0)) return { acquired: false };
+		await setTimeout(options.retryMs ?? 25, void 0, { ref: false });
+	}
+	const ttlMs = options.ttlMs ?? 9e4;
+	const heartbeat = options.keepAlive ? setInterval(() => {
+		state.extendLock(lock, ttlMs);
+	}, Math.max(1, Math.floor(ttlMs / 3))) : void 0;
+	heartbeat?.unref();
+	try {
+		return {
+			acquired: true,
+			value: await run(lock)
+		};
+	} finally {
+		if (heartbeat) clearInterval(heartbeat);
+		await state.releaseLock(lock);
+	}
+}
+/**
+* Prove lock ownership immediately before a blind write.
+*
+* Whole-record mutations must stop if their lock expired rather than overwrite
+* state committed by a newer owner.
+*/
+async function fenceLock(state, lock, ttlMs = MUTATION_LOCK_TTL_MS) {
+	if (!await state.extendLock(lock, ttlMs)) throw new Error(`Lock ownership was lost before write for ${lock.threadId}`);
+}
+// src/chat/state/adapter.ts
+const ACTIVE_LOCK_HEARTBEAT_MS = 3e4;
+let stateAdapter;
+let redisStateAdapter;
+/** Lazily connect state operations, including queued-adapter lock heartbeats. */
+function createConnectingStateAdapter(base) {
+	const connected = async (operation) => {
+		await base.connect();
+		return await operation();
+	};
+	return {
+		appendToList: (key, value, options) => connected(() => base.appendToList(key, value, options)),
+		connect: () => base.connect(),
+		disconnect: () => base.disconnect(),
+		subscribe: (threadId) => connected(() => base.subscribe(threadId)),
+		unsubscribe: (threadId) => connected(() => base.unsubscribe(threadId)),
+		isSubscribed: (threadId) => connected(() => base.isSubscribed(threadId)),
+		acquireLock: (threadId, ttlMs) => connected(() => base.acquireLock(threadId, ttlMs)),
+		releaseLock: (lock) => connected(() => base.releaseLock(lock)),
+		extendLock: (lock, ttlMs) => connected(() => base.extendLock(lock, ttlMs)),
+		forceReleaseLock: (threadId) => connected(() => base.forceReleaseLock(threadId)),
+		enqueue: (threadId, entry, maxSize) => connected(() => base.enqueue(threadId, entry, maxSize)),
+		dequeue: (threadId) => connected(() => base.dequeue(threadId)),
+		queueDepth: (threadId) => connected(() => base.queueDepth(threadId)),
+		get: (key) => connected(() => base.get(key)),
+		getList: (key) => connected(() => base.getList(key)),
+		set: (key, value, ttlMs) => connected(() => base.set(key, value, ttlMs)),
+		setIfNotExists: (key, value, ttlMs) => connected(() => base.setIfNotExists(key, value, ttlMs)),
+		delete: (key) => connected(() => base.delete(key))
+	};
+}
+function createPrefixedStateAdapter(base, prefix) {
+	const prefixed = (value) => `${prefix}:${value}`;
+	const unprefixed = (value) => value.startsWith(`${prefix}:`) ? value.slice(prefix.length + 1) : value;
+	const prefixLock = (lock) => ({
+		...lock,
+		threadId: prefixed(lock.threadId)
+	});
+	const unprefixLock = (lock) => ({
+		...lock,
+		threadId: unprefixed(lock.threadId)
+	});
+	return {
+		appendToList: (key, value, options) => base.appendToList(prefixed(key), value, options),
+		connect: () => base.connect(),
+		disconnect: () => base.disconnect(),
+		subscribe: (threadId) => base.subscribe(prefixed(threadId)),
+		unsubscribe: (threadId) => base.unsubscribe(prefixed(threadId)),
+		isSubscribed: (threadId) => base.isSubscribed(prefixed(threadId)),
+		acquireLock: async (threadId, ttlMs) => {
+			const lock = await base.acquireLock(prefixed(threadId), ttlMs);
+			return lock ? unprefixLock(lock) : null;
+		},
+		releaseLock: (lock) => base.releaseLock(prefixLock(lock)),
+		extendLock: async (lock, ttlMs) => {
+			const prefixedLock = prefixLock(lock);
+			const extended = await base.extendLock(prefixedLock, ttlMs);
+			if (extended) lock.expiresAt = prefixedLock.expiresAt;
+			return extended;
+		},
+		forceReleaseLock: (threadId) => base.forceReleaseLock(prefixed(threadId)),
+		enqueue: (threadId, entry, maxSize) => base.enqueue(prefixed(threadId), entry, maxSize),
+		dequeue: (threadId) => base.dequeue(prefixed(threadId)),
+		queueDepth: (threadId) => base.queueDepth(prefixed(threadId)),
+		get: (key) => base.get(prefixed(key)),
+		getList: (key) => base.getList(prefixed(key)),
+		set: (key, value, ttlMs) => base.set(prefixed(key), value, ttlMs),
+		setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(prefixed(key), value, ttlMs),
+		delete: (key) => base.delete(prefixed(key))
+	};
+}
+function createQueuedStateAdapter(base, options) {
+	const heartbeats = /* @__PURE__ */ new Map();
+	const shouldHeartbeatLock = (ttlMs) => ttlMs === ACTIVE_LOCK_TTL_MS;
+	const heartbeatKey = (lock) => `${lock.threadId}:${lock.token}`;
+	const stopHeartbeatByKey = (key) => {
+		const heartbeat = heartbeats.get(key);
+		if (!heartbeat) return;
+		clearInterval(heartbeat.timer);
+		heartbeats.delete(key);
+	};
+	const stopHeartbeat = (lock) => {
+		stopHeartbeatByKey(heartbeatKey(lock));
+	};
+	const stopHeartbeatsForThread = (threadId) => {
+		for (const [key, heartbeat] of heartbeats) if (heartbeat.lock.threadId === threadId) stopHeartbeatByKey(key);
+	};
+	const stopAllHeartbeats = () => {
+		for (const key of heartbeats.keys()) stopHeartbeatByKey(key);
+	};
+	const runHeartbeat = async (key) => {
+		const heartbeat = heartbeats.get(key);
+		if (!heartbeat || heartbeat.inFlight) return;
+		heartbeat.inFlight = true;
+		try {
+			if (Date.now() - heartbeat.startedAtMs >= options.activeLockMaxAgeMs) {
+				stopHeartbeatByKey(key);
+				return;
+			}
+			if (!await base.extendLock(heartbeat.lock, heartbeat.ttlMs)) {
+				stopHeartbeatByKey(key);
+				return;
+			}
+			heartbeat.lock.expiresAt = Date.now() + heartbeat.ttlMs;
+		} catch {} finally {
+			const current = heartbeats.get(key);
+			if (current === heartbeat) current.inFlight = false;
+		}
+	};
+	const startOrUpdateHeartbeat = (lock, ttlMs) => {
+		const key = heartbeatKey(lock);
+		const existing = heartbeats.get(key);
+		if (existing) {
+			existing.ttlMs = ttlMs;
+			return;
+		}
+		const timer = setInterval(() => {
+			runHeartbeat(key);
+		}, ACTIVE_LOCK_HEARTBEAT_MS);
+		timer.unref?.();
+		heartbeats.set(key, {
+			inFlight: false,
+			lock,
+			startedAtMs: Date.now(),
+			timer,
+			ttlMs
+		});
+	};
+	const acquireLock = async (threadId, ttlMs) => {
+		const lock = await base.acquireLock(threadId, ttlMs);
+		if (lock && shouldHeartbeatLock(ttlMs)) startOrUpdateHeartbeat(lock, ttlMs);
+		return lock;
+	};
+	return {
+		appendToList: (key, value, options) => base.appendToList(key, value, options),
+		connect: () => base.connect(),
+		disconnect: async () => {
+			stopAllHeartbeats();
+			await base.disconnect();
+		},
+		subscribe: (threadId) => base.subscribe(threadId),
+		unsubscribe: (threadId) => base.unsubscribe(threadId),
+		isSubscribed: (threadId) => base.isSubscribed(threadId),
+		acquireLock,
+		releaseLock: async (lock) => {
+			stopHeartbeat(lock);
+			await base.releaseLock(lock);
+		},
+		extendLock: async (lock, ttlMs) => {
+			const extended = await base.extendLock(lock, ttlMs);
+			if (extended) {
+				lock.expiresAt = Date.now() + ttlMs;
+				if (shouldHeartbeatLock(ttlMs)) startOrUpdateHeartbeat(lock, ttlMs);
+				else stopHeartbeat(lock);
+			} else stopHeartbeat(lock);
+			return extended;
+		},
+		forceReleaseLock: async (threadId) => {
+			stopHeartbeatsForThread(threadId);
+			await base.forceReleaseLock(threadId);
+		},
+		enqueue: (threadId, entry, maxSize) => base.enqueue(threadId, entry, maxSize),
+		dequeue: (threadId) => base.dequeue(threadId),
+		queueDepth: (threadId) => base.queueDepth(threadId),
+		get: (key) => base.get(key),
+		getList: (key) => base.getList(key),
+		set: (key, value, ttlMs) => base.set(key, value, ttlMs),
+		setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(key, value, ttlMs),
+		delete: (key) => base.delete(key)
+	};
+}
+function withOptionalPrefix(base, prefix) {
+	return prefix ? createPrefixedStateAdapter(base, prefix) : base;
+}
+function createStateAdapter() {
+	const config = getChatConfig();
+	const activeLockMaxAgeMs = config.bot.turnTimeoutMs + ACTIVE_LOCK_TTL_MS;
+	if (config.state.adapter === "memory") {
+		redisStateAdapter = void 0;
+		return createQueuedStateAdapter(createConnectingStateAdapter(withOptionalPrefix(createMemoryState(), config.state.keyPrefix)), { activeLockMaxAgeMs });
+	}
+	if (!config.state.redisUrl) throw new Error("REDIS_URL is required for durable Slack thread state");
+	const redisState = createRedisState({ url: config.state.redisUrl });
+	redisStateAdapter = redisState;
+	return createQueuedStateAdapter(createConnectingStateAdapter(withOptionalPrefix(redisState, config.state.keyPrefix)), { activeLockMaxAgeMs });
+}
+function getOptionalRedisStateAdapter() {
+	getStateAdapter();
+	return redisStateAdapter;
+}
+async function getConnectedStateContext() {
+	const adapter = getStateAdapter();
+	await adapter.connect();
+	return {
+		redisStateAdapter: getOptionalRedisStateAdapter(),
+		stateAdapter: adapter
+	};
+}
+/** Return the Redis adapter only when the caller is using the default state adapter. */
+async function getDefaultRedisStateAdapterFor(adapter) {
+	if (adapter !== stateAdapter) return;
+	const context = await getConnectedStateContext();
+	return context.stateAdapter === adapter ? context.redisStateAdapter : void 0;
+}
+function getStateAdapter() {
+	if (!stateAdapter) stateAdapter = createStateAdapter();
+	return stateAdapter;
+}
+async function disconnectStateAdapter() {
+	if (!stateAdapter) return;
+	try {
+		await stateAdapter.disconnect();
+	} finally {
+		stateAdapter = void 0;
+		redisStateAdapter = void 0;
+	}
+}
+export { acquireActiveLock as a, MUTATION_LOCK_TTL_MS as i, getDefaultRedisStateAdapterFor as n, fenceLock as o, getStateAdapter as r, withLock as s, disconnectStateAdapter as t };

package/dist/{admin-My1SLGVO.js → admin-tzkZDqrH.js}

@@ -1,4 +1,4 @@
-import { a as setUserAdminFromSql, d as getDb, n as listAdminUsersFromSql } from "./viewer-CGvvRqKp.js";
+import { a as setUserAdminFromSql, d as getDb, n as listAdminUsersFromSql } from "./viewer-C-J0ewlH.js";
 import { CLI_USAGE } from "./cli/run.js";
 // src/cli/admin.ts
 /**