@sentry/junior 0.257.0 → 0.259.0

package/dist/{actor-BTtLaeWy.js → actor-tlxzqaRe.js}

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import "@sentry/junior-plugin-api";
-//#region src/chat/slack/timestamp.ts
+// src/chat/slack/timestamp.ts
 /** Native Slack message timestamp, safe to pass as Slack Web API `message_ts`. */
 const slackMessageTsSchema = z.string().trim().regex(/^\d+(?:\.\d+)?$/).brand();
 /** Parse a native Slack message timestamp from untrusted message metadata. */
@@ -8,8 +8,7 @@ function parseSlackMessageTs(value) {
 	const parsed = slackMessageTsSchema.safeParse(value);
 	return parsed.success ? parsed.data : void 0;
 }
-//#endregion
-//#region src/chat/slack/ids.ts
+// src/chat/slack/ids.ts
 const slackChannelIdSchema = z.string().regex(/^[CDG][A-Z0-9]+$/).brand();
 const slackTeamIdSchema = z.string().regex(/^T[A-Z0-9]+$/).brand();
 const slackUserIdSchema = z.string().regex(/^[UW][A-Z0-9]+$/).brand();
@@ -54,8 +53,7 @@ function parseSlackUserId(value) {
 	const parsed = slackUserIdSchema.safeParse(value.trim());
 	return parsed.success ? parsed.data : void 0;
 }
-//#endregion
-//#region src/chat/actor.ts
+// src/chat/actor.ts
 /**
 * Canonical actor identity.
 *
@@ -199,5 +197,4 @@ function createSlackResumeActor(args) {
 	if (!actor || actor.platform !== "slack") throw new Error("Slack actor requires team and user ids");
 	return actor;
 }
-//#endregion
 export { slackMessageTsSchema as _, isUserActor as a, toStoredSlackActor as c, parseSlackTeamId as d, parseSlackUserId as f, parseSlackMessageTs as g, slackUserIdSchema as h, isActorUserId as i, parseSlackChannelId as l, slackTeamIdSchema as m, createSlackActor as n, parseActorUserId as o, slackChannelIdSchema as p, createSlackResumeActor as r, parseStoredSlackActor as s, createActor as t, parseSlackChannelReferenceId as u };

package/dist/adapter-Bn0gFVSF.js

@@ -0,0 +1,270 @@
+import { i as getChatConfig } from "./config-Deqpfpg9.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-DgIkm6Vy.js → admin-C8xz2f10.js}

@@ -1,6 +1,6 @@
-import { f as getDb, o as setUserAdminFromSql, r as listAdminUsersFromSql } from "./viewer-DSZXygMU.js";
+import { a as setUserAdminFromSql, d as getDb, n as listAdminUsersFromSql } from "./viewer-B2_ABsYi.js";
 import { CLI_USAGE } from "./cli/run.js";
-//#region src/cli/admin.ts
+// src/cli/admin.ts
 /**
 * Operator CLI for the Junior-wide admin role.
 *
@@ -29,5 +29,4 @@ async function runAdmin(argv) {
 	console.error(CLI_USAGE);
 	return 1;
 }
-//#endregion
 export { runAdmin };