jeopi-cli 16.5.6 → 16.6.2

package/src/messenger/http.ts

@@ -0,0 +1,87 @@
+export class MessengerHttpError extends Error {
+	constructor(
+		readonly status: number,
+		readonly retryAfterMs?: number,
+	) {
+		super(`Messenger request failed (HTTP ${status})`);
+		this.name = "MessengerHttpError";
+	}
+}
+
+/** Provider limits count UTF-16 units; do not bisect supplementary characters. */
+export function splitMessengerText(text: string, limit: number): string[] {
+	if (!Number.isSafeInteger(limit) || limit < 2)
+		throw new Error("Message chunk limit must be an integer of at least two");
+	const chunks: string[] = [];
+	for (let start = 0; start < text.length; ) {
+		let end = Math.min(start + limit, text.length);
+		const last = text.charCodeAt(end - 1);
+		if (end < text.length && last >= 0xd800 && last <= 0xdbff) end--;
+		chunks.push(text.slice(start, end));
+		start = end;
+	}
+	return chunks;
+}
+
+export async function messengerFetchJson(
+	url: string,
+	init: RequestInit,
+	signal?: AbortSignal,
+	fetchImpl: typeof fetch = fetch,
+): Promise<unknown> {
+	const signals = [AbortSignal.timeout(35_000)];
+	if (signal) signals.push(signal);
+	if (init.signal) signals.push(init.signal);
+	const requestSignal = AbortSignal.any(signals);
+	try {
+		const response = await fetchImpl(url, { ...init, redirect: "error", signal: requestSignal });
+		if (!response.ok) {
+			let retryAfterMs: number | undefined;
+			if (response.status === 429) {
+				let seconds = Number(response.headers.get("retry-after"));
+				if (!seconds) {
+					try {
+						const body: unknown = await response.json();
+						if (typeof body === "object" && body !== null) {
+							if ("retry_after" in body && typeof body.retry_after === "number") {
+								seconds = body.retry_after;
+							} else if (
+								"parameters" in body &&
+								typeof body.parameters === "object" &&
+								body.parameters !== null &&
+								"retry_after" in body.parameters &&
+								typeof body.parameters.retry_after === "number"
+							) {
+								seconds = body.parameters.retry_after;
+							}
+						}
+					} catch {
+						/* Retry metadata is optional; never surface provider response text. */
+					}
+				}
+				// Larger delays overflow native timers into immediate retries.
+				if (Number.isFinite(seconds) && seconds > 0) retryAfterMs = Math.min(seconds * 1000, 2_147_483_647);
+			}
+			if (!response.bodyUsed) await response.body?.cancel();
+			throw new MessengerHttpError(response.status, retryAfterMs);
+		}
+		return await response.json();
+	} catch (error) {
+		if (error instanceof MessengerHttpError) throw error;
+		if (signal?.aborted || init.signal?.aborted) throw new Error("Messenger request cancelled");
+		throw new Error("Messenger request failed");
+	}
+}
+
+export async function waitForMessengerRetry(ms: number, signal: AbortSignal): Promise<void> {
+	if (signal.aborted) return;
+	const { promise, resolve } = Promise.withResolvers<void>();
+	const done = (): void => {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", done);
+		resolve();
+	};
+	const timer = setTimeout(done, ms);
+	signal.addEventListener("abort", done, { once: true });
+	await promise;
+}

package/src/messenger/session.ts

@@ -0,0 +1,219 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { Model } from "jeopi-ai";
+import { isEnoent } from "jeopi-utils";
+import type { ModelRegistry } from "../config/model-registry";
+import { Settings } from "../config/settings";
+import { initializeExtensions } from "../modes/runtime-init";
+import { createAgentSession } from "../sdk";
+import type { AgentSession } from "../session/agent-session";
+import type { AuthStorage } from "../session/auth-storage";
+import { USER_INTERRUPT_LABEL } from "../session/messages";
+import { SessionManager } from "../session/session-manager";
+import { messengerConversationKey } from "./gateway";
+import { type MessengerConfig, MessengerFatalError, type MessengerReply } from "./types";
+
+const SUPPORTED_TOOLS: Record<string, true> = {
+	read: true,
+	grep: true,
+	glob: true,
+	bash: true,
+	edit: true,
+	write: true,
+};
+
+export interface MessengerSessionBridge {
+	reply: MessengerReply;
+	close(): Promise<void>;
+}
+
+/** Explicit SDK resources for embedded callers; security policy remains bridge-owned. */
+export interface MessengerSessionDependencies {
+	agentDir: string;
+	authStorage: AuthStorage;
+	modelRegistry: ModelRegistry;
+	model: Model;
+}
+
+/** One Main session owns the SDK's process-global lifecycle until gateway shutdown. */
+export function createMessengerSessionBridge(
+	config: MessengerConfig,
+	dependencies?: MessengerSessionDependencies,
+): MessengerSessionBridge {
+	const toolNames = [...config.toolNames];
+	if (new Set(toolNames).size !== toolNames.length || toolNames.some(name => !Object.hasOwn(SUPPORTED_TOOLS, name))) {
+		throw new Error("Unsupported messenger tools");
+	}
+	const cwd = path.resolve(config.cwd);
+	const sessionDir = path.resolve(config.sessionDir);
+	const settings = Settings.isolated({
+		"autolearn.enabled": false,
+		"async.enabled": false,
+		"bash.autoBackground.enabled": false,
+		"memory.backend": "off",
+		"advisor.enabled": false,
+		"goal.enabled": false,
+		"magicKeywords.enabled": false,
+		"todo.enabled": false,
+		"tools.discoveryMode": "off",
+		"mcp.discoveryMode": false,
+		"tools.approvalMode": "always-ask",
+		includeWorkspaceTree: false,
+	});
+	let session: AgentSession | undefined;
+	let initialization: Promise<void> | undefined;
+	let activeRoute: string | undefined;
+	let activeTurn: Promise<void> | undefined;
+	let closed = false;
+	let closing: Promise<void> | undefined;
+	let runtimeFailed = false;
+
+	async function constrainTools(current: AgentSession): Promise<void> {
+		settings.set(
+			"tools.approval",
+			Object.fromEntries(current.getAllToolNames().map(name => [name, toolNames.includes(name) ? "allow" : "deny"])),
+		);
+		await current.setActiveToolsByName(toolNames);
+		const actual = current.getActiveToolNames();
+		if (actual.length !== toolNames.length || actual.some(name => !toolNames.includes(name))) {
+			throw new Error("Messenger tool isolation failed");
+		}
+	}
+
+	async function initialize(route: string, file: string): Promise<void> {
+		const sessionManager = await SessionManager.open(file, sessionDir, undefined, {
+			initialCwd: cwd,
+			suppressBreadcrumb: true,
+		});
+		const result = await createAgentSession({
+			cwd,
+			agentDir: dependencies?.agentDir,
+			authStorage: dependencies?.authStorage,
+			modelRegistry: dependencies?.modelRegistry,
+			model: dependencies?.model,
+			sessionManager,
+			settings,
+			disableExtensionDiscovery: true,
+			preloadedCustomToolPaths: [],
+			customTools: [],
+			skills: [],
+			rules: [],
+			contextFiles: [],
+			promptTemplates: [],
+			slashCommands: [],
+			enableMCP: false,
+			enableLsp: false,
+			skipPythonPreflight: true,
+			toolNames,
+			hasUI: false,
+			autoApprove: false,
+		});
+		session = result.session;
+		await constrainTools(session);
+		const reportFailure = (): void => {
+			runtimeFailed = true;
+		};
+		await initializeExtensions(session, {
+			reportSendError: reportFailure,
+			reportRuntimeError: reportFailure,
+			onShutdown: reportFailure,
+		});
+		await constrainTools(session);
+		activeRoute = route;
+	}
+
+	const reply: MessengerReply = async (message, signal) => {
+		if (closed || signal.aborted) throw new Error("Messenger session is closed");
+		if (activeTurn) throw new Error("Messenger turns must be serialized");
+		const finished = Promise.withResolvers<void>();
+		activeTurn = finished.promise;
+		let aborting: Promise<void> | undefined;
+		const onAbort = (): void => {
+			if (session && !aborting) {
+				aborting = session.abort({ reason: USER_INTERRUPT_LABEL });
+				aborting.catch(() => {
+					runtimeFailed = true;
+				});
+			}
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		try {
+			await fs.mkdir(sessionDir, { recursive: true, mode: 0o700 });
+			const directory = await fs.lstat(sessionDir);
+			if (!directory.isDirectory() || directory.isSymbolicLink())
+				throw new Error("Invalid messenger session directory");
+			await fs.chmod(sessionDir, 0o700);
+			const route = new Bun.CryptoHasher("sha256")
+				.update(JSON.stringify([cwd, messengerConversationKey(message)]))
+				.digest("hex");
+			// Deterministic filenames are the route map; missing files are created atomically by SessionManager.
+			const file = path.join(sessionDir, `${route}.jsonl`);
+			const stat = await fs.lstat(file).catch((error: unknown) => {
+				if (isEnoent(error)) return undefined;
+				throw error;
+			});
+			if (stat && (!stat.isFile() || stat.isSymbolicLink())) throw new Error("Invalid messenger session file");
+			if (stat) await fs.chmod(file, 0o600);
+			if (closed || signal.aborted) throw new Error("Messenger request aborted");
+			if (!initialization) {
+				initialization = initialize(route, file).catch(() => {
+					// SDK startup may already have torn down process-global lifecycle resources.
+					closed = true;
+					throw new MessengerFatalError();
+				});
+			}
+			await initialization;
+			const current = session;
+			if (!current) throw new Error("Messenger session unavailable");
+			if (closed || signal.aborted) throw new Error("Messenger request aborted");
+			if (activeRoute !== route) {
+				const switched = await current.switchSession(file);
+				if (!switched) throw new Error("Messenger session switch cancelled");
+				activeRoute = route;
+			}
+			await fs.chmod(file, 0o600);
+			await constrainTools(current);
+			if (closed || signal.aborted || runtimeFailed) throw new Error("Messenger session unavailable");
+			// Slash-looking text is ordinary user data, never an extension command or developer message.
+			const dispatched = await current.prompt(message.text, { expandPromptTemplates: false });
+			await current.waitForIdle();
+			await current.sessionManager.flush();
+			if (!dispatched || closed || signal.aborted || runtimeFailed) throw new Error("Messenger request failed");
+			const last = current.state.messages.at(-1);
+			if (last?.role !== "assistant" || last.stopReason === "error" || last.stopReason === "aborted") {
+				throw new Error("Messenger response unavailable");
+			}
+			const text = last.content
+				.filter(block => block.type === "text")
+				.map(block => block.text)
+				.join("\n");
+			if (!text.trim()) throw new Error("Messenger response is empty");
+			return text;
+		} finally {
+			signal.removeEventListener("abort", onAbort);
+			await aborting?.catch(() => {});
+			activeTurn = undefined;
+			finished.resolve();
+		}
+	};
+
+	function close(): Promise<void> {
+		if (closing) return closing;
+		closed = true;
+		closing = (async () => {
+			await initialization?.catch(() => {});
+			const current = session;
+			if (!current) return;
+			try {
+				await current.abort({ reason: USER_INTERRUPT_LABEL });
+				await activeTurn;
+				await current.sessionManager.flush();
+			} finally {
+				await current.dispose();
+			}
+		})();
+		return closing;
+	}
+
+	return { reply, close };
+}

package/src/messenger/slack.ts

@@ -0,0 +1,333 @@
+import { logger } from "jeopi-utils";
+import { MessengerHttpError, messengerFetchJson, splitMessengerText, waitForMessengerRetry } from "./http";
+import type { MessengerAdapter, MessengerMessage, MessengerPlatformConfig, MessengerTransportDeps } from "./types";
+
+const BACKOFF_BASE_MS = 1_000;
+const BACKOFF_MAX_MS = 30_000;
+const CONNECT_TIMEOUT_MS = 15_000;
+const MAX_RECENT_MESSAGES = 2_000;
+const PERMANENT_ERRORS: Record<string, true> = {
+	invalid_auth: true,
+	not_authed: true,
+	account_inactive: true,
+	token_expired: true,
+	token_revoked: true,
+	missing_scope: true,
+	missing_args: true,
+	not_allowed_token_type: true,
+	no_permission: true,
+	access_denied: true,
+	accesslimited: true,
+	forbidden_team: true,
+	team_access_not_granted: true,
+	enterprise_is_restricted: true,
+	two_factor_setup_required: true,
+};
+
+class SlackConfigurationError extends Error {}
+
+function object(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function requiredToken(value: string | undefined, prefix: string): string {
+	if (!value?.startsWith(prefix) || value.length === prefix.length || /\s/.test(value)) {
+		throw new SlackConfigurationError("Slack token configuration is invalid");
+	}
+	return value;
+}
+
+async function slackRequest(
+	method: "auth.test" | "apps.connections.open" | "chat.postMessage",
+	token: string,
+	body: Record<string, unknown>,
+	signal?: AbortSignal,
+	fetchImpl?: typeof fetch,
+): Promise<Record<string, unknown>> {
+	let response: unknown;
+	try {
+		response = await messengerFetchJson(
+			`https://slack.com/api/${method}`,
+			{
+				method: "POST",
+				headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json; charset=utf-8" },
+				body: JSON.stringify(body),
+			},
+			signal,
+			fetchImpl,
+		);
+	} catch (error) {
+		if (error instanceof MessengerHttpError && error.status === 429) throw error;
+		if (error instanceof MessengerHttpError && (error.status === 401 || error.status === 403)) {
+			throw new SlackConfigurationError("Slack authentication or permission failed");
+		}
+		throw new Error("Slack API request failed");
+	}
+	const data = object(response);
+	if (data?.ok !== true) {
+		if (typeof data?.error === "string" && Object.hasOwn(PERMANENT_ERRORS, data.error)) {
+			throw new SlackConfigurationError("Slack authentication or permission failed");
+		}
+		throw new Error("Slack API request failed");
+	}
+	return data;
+}
+
+function socketUrl(value: unknown): string {
+	let url: URL;
+	try {
+		if (typeof value !== "string") throw new Error();
+		url = new URL(value);
+	} catch {
+		throw new SlackConfigurationError("Slack returned an invalid Socket Mode endpoint");
+	}
+	if (
+		url.protocol !== "wss:" ||
+		!(url.hostname === "slack.com" || url.hostname.endsWith(".slack.com")) ||
+		(url.port !== "" && url.port !== "443") ||
+		url.username ||
+		url.password ||
+		url.hash
+	) {
+		throw new SlackConfigurationError("Slack returned an invalid Socket Mode endpoint");
+	}
+	return url.href;
+}
+
+function messageFromEnvelope(
+	envelope: Record<string, unknown>,
+	teamId: string,
+	botUserId: string,
+): MessengerMessage | undefined {
+	if (envelope.type !== "events_api") return undefined;
+	const payload = object(envelope.payload);
+	if (payload?.team_id !== teamId) return undefined;
+	const event = object(payload.event);
+	if (
+		!event ||
+		(event.type !== "message" && event.type !== "app_mention") ||
+		event.bot_id !== undefined ||
+		event.bot_profile !== undefined ||
+		event.subtype !== undefined ||
+		event.edited !== undefined ||
+		event.hidden === true ||
+		typeof event.user !== "string" ||
+		!event.user ||
+		event.user === botUserId ||
+		typeof event.channel !== "string" ||
+		!event.channel ||
+		typeof event.ts !== "string" ||
+		!event.ts ||
+		typeof event.text !== "string"
+	) {
+		return undefined;
+	}
+	let mentioned = false;
+	const text = event.text
+		.replace(/<@([A-Z0-9]+)(?:\|[^>]+)?>/g, (mention: string, user: string) => {
+			if (user !== botUserId) return mention;
+			mentioned = true;
+			return "";
+		})
+		.trim();
+	const direct = event.channel_type === "im" || (event.channel_type === undefined && event.channel.startsWith("D"));
+	const threadId =
+		typeof event.thread_ts === "string" && event.thread_ts ? event.thread_ts : direct ? undefined : event.ts;
+	return {
+		platform: "slack",
+		accountId: teamId,
+		channelId: event.channel,
+		senderId: event.user,
+		// message and app_mention have different event IDs for the same message.
+		messageId: event.ts,
+		text,
+		threadId,
+		direct,
+		mentioned,
+	};
+}
+
+async function receiveSocket(
+	url: string,
+	teamId: string,
+	botUserId: string,
+	recent: Set<string>,
+	onMessage: (message: MessengerMessage) => Promise<void>,
+	signal: AbortSignal,
+	Socket: typeof WebSocket,
+): Promise<void> {
+	if (signal.aborted) return;
+	let socket: WebSocket;
+	try {
+		socket = new Socket(url);
+	} catch {
+		throw new Error("Slack Socket Mode connection failed");
+	}
+	const completion = Promise.withResolvers<void>();
+	let settled = false;
+	const timer = setTimeout(() => finish(), CONNECT_TIMEOUT_MS);
+	function finish(error?: SlackConfigurationError): void {
+		if (settled) return;
+		settled = true;
+		clearTimeout(timer);
+		signal.removeEventListener("abort", stop);
+		socket.removeEventListener("message", message);
+		socket.removeEventListener("close", stop);
+		socket.removeEventListener("error", stop);
+		try {
+			socket.close();
+		} catch {
+			// Closing an already failed connection must not prevent cancellation.
+		}
+		if (error) completion.reject(error);
+		else completion.resolve();
+	}
+	function stop(): void {
+		finish();
+	}
+	function message(incoming: MessageEvent): void {
+		if (settled || signal.aborted || typeof incoming.data !== "string") return;
+		let envelope: Record<string, unknown> | undefined;
+		try {
+			envelope = object(JSON.parse(incoming.data));
+		} catch {
+			return;
+		}
+		if (!envelope) return;
+		if (typeof envelope.envelope_id === "string") {
+			try {
+				// ACK precedes filtering and callback work, including unsupported envelopes.
+				socket.send(JSON.stringify({ envelope_id: envelope.envelope_id }));
+			} catch {
+				finish();
+				return;
+			}
+		}
+		if (envelope.type === "hello") {
+			clearTimeout(timer);
+			return;
+		}
+		if (envelope.type === "disconnect") {
+			finish(
+				envelope.reason === "link_disabled"
+					? new SlackConfigurationError("Slack Socket Mode is disabled")
+					: undefined,
+			);
+			return;
+		}
+		const parsed = messageFromEnvelope(envelope, teamId, botUserId);
+		if (!parsed) return;
+		const key = JSON.stringify([parsed.accountId, parsed.channelId, parsed.messageId]);
+		if (recent.has(key)) return;
+		recent.add(key);
+		if (recent.size > MAX_RECENT_MESSAGES) {
+			const oldest = recent.values().next().value;
+			if (oldest !== undefined) recent.delete(oldest);
+		}
+		void Promise.resolve()
+			.then(() => {
+				if (!signal.aborted) return onMessage(parsed);
+			})
+			.catch(() => logger.warn("Slack incoming message handler failed"));
+	}
+	socket.addEventListener("message", message);
+	socket.addEventListener("close", stop);
+	socket.addEventListener("error", stop);
+	signal.addEventListener("abort", stop, { once: true });
+	if (signal.aborted) finish();
+	await completion.promise;
+}
+
+export function createSlackAdapter(
+	config: MessengerPlatformConfig,
+	env: Record<string, string | undefined> = process.env,
+	deps: MessengerTransportDeps = {},
+): MessengerAdapter {
+	let teamId: string | undefined;
+	let running = false;
+	return {
+		platform: "slack",
+		async start(onMessage, signal) {
+			if (signal.aborted) return;
+			if (running) throw new SlackConfigurationError("Slack adapter is already running");
+			const botToken = requiredToken(env[config.tokenEnv], "xoxb-");
+			const appToken = requiredToken(env[config.appTokenEnv ?? "JEOPI_SLACK_APP_TOKEN"], "xapp-");
+			const recent = new Set<string>();
+			let botUserId: string | undefined;
+			let backoff = BACKOFF_BASE_MS;
+			running = true;
+			try {
+				while (!signal.aborted) {
+					const startedAt = Date.now();
+					let retryAfterMs = 0;
+					try {
+						if (!botUserId || !teamId) {
+							const identity = await slackRequest("auth.test", botToken, {}, signal, deps.fetch);
+							if (
+								typeof identity.team_id !== "string" ||
+								!identity.team_id ||
+								typeof identity.user_id !== "string" ||
+								!identity.user_id
+							) {
+								throw new SlackConfigurationError("Slack returned an invalid bot identity");
+							}
+							teamId = identity.team_id;
+							botUserId = identity.user_id;
+						}
+						const connection = await slackRequest("apps.connections.open", appToken, {}, signal, deps.fetch);
+						await receiveSocket(
+							socketUrl(connection.url),
+							teamId,
+							botUserId,
+							recent,
+							onMessage,
+							signal,
+							deps.WebSocket ?? WebSocket,
+						);
+					} catch (error) {
+						if (signal.aborted) break;
+						if (error instanceof SlackConfigurationError) throw error;
+						if (error instanceof MessengerHttpError) retryAfterMs = error.retryAfterMs ?? 0;
+						logger.warn("Slack transport disconnected; retrying");
+					}
+					if (signal.aborted) break;
+					if (Date.now() - startedAt >= BACKOFF_MAX_MS) backoff = BACKOFF_BASE_MS;
+					await waitForMessengerRetry(Math.max(backoff, retryAfterMs), signal);
+					backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
+				}
+			} finally {
+				running = false;
+			}
+		},
+		async send(message, text, signal) {
+			if (message.platform !== "slack" || (teamId !== undefined && message.accountId !== teamId)) {
+				throw new SlackConfigurationError("Slack reply account does not match");
+			}
+			const token = requiredToken(env[config.tokenEnv], "xoxb-");
+			const chunks = splitMessengerText(text, 4_000);
+			const sendSignal = signal ?? new AbortController().signal;
+			for (const [index, chunk] of chunks.entries()) {
+				if (index > 0) await waitForMessengerRetry(1_000, sendSignal);
+				if (sendSignal.aborted) throw new Error("Slack send cancelled");
+				await slackRequest(
+					"chat.postMessage",
+					token,
+					{
+						channel: message.channelId,
+						text: chunk,
+						thread_ts: message.threadId ?? (message.direct ? undefined : message.messageId),
+						mrkdwn: false,
+						parse: "none",
+						link_names: false,
+						unfurl_links: false,
+						unfurl_media: false,
+					},
+					sendSignal,
+					deps.fetch,
+				);
+			}
+		},
+	};
+}