jeopi-cli 16.6.14 → 16.6.18

package/src/messenger/session-pool.ts

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { logger } from "jeopi-utils";
 import {
 	createWorkerHandle,
 	createWorkerSubprocess,
@@ -106,6 +107,7 @@ interface Lane {
 	/** Turns queued or running; idle retirement waits for zero. */
 	turns: number;
 	live?: LiveSession;
+	retiring?: Promise<void>;
 	idle?: NodeJS.Timeout;
 	/** Already chosen to free a slot, so concurrent starts pick different victims. */
 	evicting?: boolean;
@@ -152,27 +154,52 @@ export function createMessengerSessionPool(
 	};
 
 	/** Let the process flush and dispose its session, then kill it; the session file stays for resumption. */
-	const retire = async (lane: Lane): Promise<void> => {
+	const retire = (lane: Lane): Promise<void> => {
+		if (lane.retiring) return lane.retiring;
 		const live = lane.live;
-		if (!live) return;
+		if (!live) return Promise.resolve();
 		lane.live = undefined;
-		const id = String(++nextId);
-		const acknowledged = Promise.withResolvers<void>();
-		const unsubscribe = live.process.onMessage(event => {
-			if (event.type === "closed" && event.id === id) acknowledged.resolve();
-		});
-		const timer = setTimeout(acknowledged.resolve, SESSION_CLOSE_TIMEOUT_MS);
-		try {
-			live.process.send({ type: "close", id });
-			await Promise.race([acknowledged.promise, live.process.exited]);
-		} catch {
-			// The process is already gone; killing it below is still safe.
-		} finally {
-			clearTimeout(timer);
-			unsubscribe();
+		const retirement = (async () => {
+			const id = String(++nextId);
+			const acknowledged = Promise.withResolvers<void>();
+			const unsubscribe = live.process.onMessage(event => {
+				if (event.type === "closed" && event.id === id) acknowledged.resolve();
+			});
+			const timer = setTimeout(acknowledged.resolve, SESSION_CLOSE_TIMEOUT_MS);
+			try {
+				live.process.send({ type: "close", id });
+				await Promise.race([acknowledged.promise, live.process.exited]);
+			} catch {
+				// Still try to terminate a process with a broken IPC channel.
+			} finally {
+				clearTimeout(timer);
+				unsubscribe();
+			}
 			live.process.kill();
-			release(live);
-		}
+			const timeout = Promise.withResolvers<void>();
+			const exitTimer = setTimeout(
+				() => timeout.reject(new Error("Messenger session process did not exit")),
+				SESSION_CLOSE_TIMEOUT_MS,
+			);
+			try {
+				await Promise.race([
+					live.process.exited.then(
+						() => {},
+						() => {},
+					),
+					timeout.promise,
+				]);
+			} finally {
+				clearTimeout(exitTimer);
+			}
+		})();
+		lane.retiring = retirement;
+		const clearRetirement = (): void => {
+			if (lane.retiring === retirement) lane.retiring = undefined;
+		};
+		void live.process.exited.then(clearRetirement, clearRetirement);
+		void retirement.catch(() => {});
+		return retirement;
 	};
 
 	const retireIfIdle = async (lane: Lane): Promise<void> => {
@@ -261,6 +288,7 @@ export function createMessengerSessionPool(
 			result.reject(new Error("Messenger request aborted"));
 		};
 		try {
+			if (lane.retiring) await lane.retiring;
 			live ??= await start(lane, signal);
 			const current = live;
 			current.failTurn = result.reject;
@@ -271,7 +299,7 @@ export function createMessengerSessionPool(
 				else if (event.type === "failed") result.reject(new Error("Messenger session turn failed"));
 			});
 			signal.addEventListener("abort", onAbort, { once: true });
-			if (signal.aborted) onAbort();
+			if (signal.aborted) throw new Error("Messenger request aborted");
 			try {
 				current.process.send({ type: "turn", id, message });
 			} catch (error) {
@@ -309,7 +337,11 @@ export function createMessengerSessionPool(
 		} finally {
 			current.turns--;
 			if (current.turns === 0 && !closed) {
-				current.idle = setTimeout(() => void enqueue(current, () => retireIfIdle(current)), idleMs);
+				current.idle = setTimeout(() => {
+					void enqueue(current, () => retireIfIdle(current)).catch(() =>
+						logger.warn("Messenger session retirement failed"),
+					);
+				}, idleMs);
 				current.idle.unref?.();
 				capacityChanged();
 			}
@@ -323,7 +355,9 @@ export function createMessengerSessionPool(
 			const all = [...lanes.values()];
 			lanes.clear();
 			for (const lane of all) clearTimeout(lane.idle);
-			await Promise.allSettled(all.map(retire));
+			const results = await Promise.allSettled(all.map(retire));
+			const failure = results.find(result => result.status === "rejected");
+			if (failure?.status === "rejected") throw failure.reason;
 		})();
 		return closing;
 	};

package/src/messenger/session.ts

@@ -83,6 +83,9 @@ export function createMessengerSessionBridge(
 	}
 
 	async function initialize(route: string, file: string): Promise<void> {
+		const userSettings = await Settings.loadReadOnly({ cwd, agentDir: dependencies?.agentDir });
+		const defaultModel = userSettings.getModelRole("default");
+		if (defaultModel) settings.override("modelRoles", { default: defaultModel });
 		const sessionManager = await SessionManager.open(file, sessionDir, undefined, {
 			initialCwd: cwd,
 			suppressBreadcrumb: true,

package/src/messenger/slack.ts

@@ -40,7 +40,7 @@ function requiredToken(value: string | undefined, prefix: string): string {
 }
 
 async function slackRequest(
-	method: "auth.test" | "apps.connections.open" | "chat.postMessage",
+	method: "auth.test" | "apps.connections.open" | "chat.postMessage" | "chat.update" | "chat.delete",
 	token: string,
 	body: Record<string, unknown>,
 	signal?: AbortSignal,
@@ -247,6 +247,7 @@ export function createSlackAdapter(
 ): MessengerAdapter {
 	let teamId: string | undefined;
 	let running = false;
+	const activityMessages = new Map<string, string>();
 	return {
 		platform: "slack",
 		async start(onMessage, signal) {
@@ -329,5 +330,65 @@ export function createSlackAdapter(
 				);
 			}
 		},
+		releaseActivity(message) {
+			activityMessages.delete(
+				JSON.stringify([message.accountId, message.channelId, message.threadId ?? "", message.messageId]),
+			);
+		},
+		async activity(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 key = JSON.stringify([message.accountId, message.channelId, message.threadId ?? "", message.messageId]);
+			const statusId = activityMessages.get(key);
+			if (text === undefined) {
+				if (!statusId) return;
+				await slackRequest("chat.delete", token, { channel: message.channelId, ts: statusId }, signal, deps.fetch);
+				activityMessages.delete(key);
+				return;
+			}
+			const body = {
+				channel: message.channelId,
+				text: `⏳ ${text}`,
+				mrkdwn: false,
+				parse: "none",
+				link_names: false,
+				unfurl_links: false,
+				unfurl_media: false,
+			};
+			if (statusId) {
+				await slackRequest("chat.update", token, { ...body, ts: statusId }, signal, deps.fetch);
+				return;
+			}
+			if (signal?.aborted) return;
+			// Keep creation alive after cancellation so a late ID can be deleted; HTTP has its own timeout.
+			const created = await slackRequest(
+				"chat.postMessage",
+				token,
+				{
+					...body,
+					thread_ts: message.threadId ?? (message.direct ? undefined : message.messageId),
+				},
+				undefined,
+				deps.fetch,
+			);
+			if (typeof created.ts !== "string" || !created.ts) throw new Error("Slack activity message returned no ID");
+			if (signal?.aborted) {
+				try {
+					await slackRequest(
+						"chat.delete",
+						token,
+						{ channel: message.channelId, ts: created.ts },
+						AbortSignal.timeout(3_000),
+						deps.fetch,
+					);
+				} catch {
+					logger.warn("Slack late activity removal failed");
+				}
+				return;
+			}
+			activityMessages.set(key, created.ts);
+		},
 	};
 }

package/src/messenger/telegram.ts

@@ -144,6 +144,7 @@ export function createTelegramAdapter(
 	const baseUrl = `https://api.telegram.org/bot${encodeURIComponent(token).replaceAll("%3A", ":")}/`;
 	let running = false;
 	let offset = 0;
+	const activityMessages = new Map<string, number>();
 
 	async function request(method: string, parameters: Record<string, unknown>, signal?: AbortSignal): Promise<unknown> {
 		const response = await messengerFetchJson(
@@ -156,7 +157,9 @@ export function createTelegramAdapter(
 		if (!response.ok) {
 			const status = isInteger(response.error_code) ? response.error_code : 400;
 			const retryAfter = isRecord(response.parameters) ? response.parameters.retry_after : undefined;
-			throw new TelegramApiError(status, isPositiveId(retryAfter) ? Math.min(retryAfter, 300) * 1_000 : 0);
+			const retryAfterMs = isPositiveId(retryAfter) ? Math.min(retryAfter, 300) * 1_000 : 0;
+			if (status === 429) throw new MessengerHttpError(status, retryAfterMs || undefined);
+			throw new TelegramApiError(status, retryAfterMs);
 		}
 		if (!("result" in response)) throw new TelegramApiError(400);
 		return response.result;
@@ -240,5 +243,55 @@ export function createTelegramAdapter(
 				if (!isRecord(result) || !isPositiveId(result.message_id)) throw new TelegramApiError(400);
 			}
 		},
+		releaseActivity(message) {
+			activityMessages.delete(
+				JSON.stringify([message.accountId, message.channelId, message.threadId ?? "", message.messageId]),
+			);
+		},
+		async activity(message, text, signal) {
+			const key = JSON.stringify([message.accountId, message.channelId, message.threadId ?? "", message.messageId]);
+			const statusId = activityMessages.get(key);
+			if (text === undefined) {
+				if (!statusId) return;
+				await request("deleteMessage", { chat_id: message.channelId, message_id: statusId }, signal);
+				activityMessages.delete(key);
+				return;
+			}
+			if (statusId) {
+				await request(
+					"editMessageText",
+					{ chat_id: message.channelId, message_id: statusId, text: `⏳ ${text}` },
+					signal,
+				);
+				return;
+			}
+			const threadId = message.threadId === undefined ? undefined : Number(message.threadId);
+			if (threadId !== undefined && !isPositiveId(threadId)) throw new Error("Telegram topic identifier is invalid");
+			if (signal?.aborted) return;
+			// Keep creation alive after cancellation so a late ID can be deleted; HTTP has its own timeout.
+			const created = await request(
+				"sendMessage",
+				{
+					chat_id: message.channelId,
+					text: `⏳ ${text}`,
+					...(threadId === undefined ? {} : { message_thread_id: threadId }),
+				},
+				undefined,
+			);
+			if (!isRecord(created) || !isPositiveId(created.message_id)) throw new TelegramApiError(400);
+			if (signal?.aborted) {
+				try {
+					await request(
+						"deleteMessage",
+						{ chat_id: message.channelId, message_id: created.message_id },
+						AbortSignal.timeout(3_000),
+					);
+				} catch {
+					logger.warn("Telegram late activity removal failed");
+				}
+				return;
+			}
+			activityMessages.set(key, created.message_id);
+		},
 	};
 }

package/src/messenger/types.ts

@@ -27,11 +27,15 @@ export interface MessengerAdapter {
 		status: "processing" | "success" | "failure",
 		signal?: AbortSignal,
 	): Promise<void>;
+	/** Remove an in-progress status after cancellation without adding a terminal status. */
+	clearStatus?(message: MessengerMessage, signal?: AbortSignal): Promise<void>;
 	/**
 	 * Show `text` (one sanitized line) as the request's single in-progress status, editing it in place on
 	 * later calls; `undefined` removes it. The gateway serializes and throttles calls per request.
 	 */
 	activity?(message: MessengerMessage, text: string | undefined, signal?: AbortSignal): Promise<void>;
+	/** Forget request-local cosmetic activity state after the gateway finishes cleanup retries. */
+	releaseActivity?(message: MessengerMessage): void;
 }
 
 export interface MessengerPlatformConfig {