jeopi-cli 16.6.13 → 16.6.17

package/src/messenger/gateway.ts

@@ -141,24 +141,27 @@ function createActivityReporter(
 			closing ??= (async () => {
 				closed = true;
 				wake?.();
-				await pump;
-				if (!shown) return;
-				for (let attempt = 0; ; attempt++) {
-					try {
-						await update(undefined);
-						return;
-					} catch (error) {
-						const wait =
-							error instanceof MessengerHttpError && error.status === 429
-								? (error.retryAfterMs ?? 1_000)
-								: 1_000;
-						// One bounded retry: removal holds the request queue.
-						if (attempt > 0 || wait > ACTIVITY_TIMEOUT_MS) {
-							logger.warn("Messenger activity removal failed", { platform: destination.platform });
+				try {
+					await pump;
+					if (!shown) return;
+					for (let attempt = 0; ; attempt++) {
+						try {
+							await update(undefined);
 							return;
+						} catch (error) {
+							const wait =
+								error instanceof MessengerHttpError && error.status === 429
+									? (error.retryAfterMs ?? 1_000)
+									: 1_000;
+							if (attempt > 0 || wait > ACTIVITY_TIMEOUT_MS) {
+								logger.warn("Messenger activity removal failed", { platform: destination.platform });
+								return;
+							}
+							await Bun.sleep(wait);
 						}
-						await Bun.sleep(wait);
 					}
+				} finally {
+					adapter.releaseActivity?.(destination);
 				}
 			})();
 			return closing;
@@ -177,6 +180,28 @@ export function messengerConversationKey(message: MessengerMessage): string {
 	]);
 }
 
+/** Stable per-conversation route shared by the persisted session file and its session process. */
+export function messengerSessionRoute(cwd: string, message: MessengerMessage): string {
+	return new Bun.CryptoHasher("sha256").update(JSON.stringify([cwd, messengerConversationKey(message)])).digest("hex");
+}
+
+/**
+ * Discord creates a thread with the original message's ID. Reserve that conversation key before
+ * preparing it so follow-ups cannot overtake the request while thread creation is in flight.
+ */
+function schedulingKey(message: MessengerMessage, adapter: MessengerAdapter): string {
+	if (
+		message.platform === "discord" &&
+		adapter.prepare &&
+		!message.direct &&
+		!message.threadId &&
+		!message.parentChannelId
+	) {
+		return messengerConversationKey({ ...message, threadId: message.messageId });
+	}
+	return messengerConversationKey(message);
+}
+
 export function isMessengerMessageAllowed(message: MessengerMessage, config: MessengerConfig): boolean {
 	const platform = config.platforms[message.platform];
 	return Boolean(
@@ -201,6 +226,8 @@ interface PendingMessage {
 	adapter: MessengerAdapter;
 	signal: AbortSignal;
 	resolve: () => void;
+	/** Requests sharing a key never run at the same time. */
+	key: string;
 }
 
 export interface MessengerGateway {
@@ -211,6 +238,11 @@ export interface MessengerGateway {
 export interface MessengerGatewayOptions {
 	/** Minimum spacing between in-place activity edits for one request. */
 	activityIntervalMs?: number;
+	/**
+	 * Requests processed at once (default 1). Requests of one prepared conversation still answer and deliver in
+	 * order; above 1 the reply implementation must accept concurrent turns for different conversations.
+	 */
+	concurrency?: number;
 }
 
 export function createMessengerGateway(
@@ -220,6 +252,7 @@ export function createMessengerGateway(
 	options: MessengerGatewayOptions = {},
 ): MessengerGateway {
 	const activityIntervalMs = Math.max(0, options.activityIntervalMs ?? ACTIVITY_INTERVAL_MS);
+	const concurrency = Math.max(1, Math.trunc(options.concurrency ?? 1));
 	const byPlatform = new Map(adapters.map(adapter => [adapter.platform, adapter]));
 	if (byPlatform.size !== adapters.length) throw new Error("Duplicate messenger adapter");
 	for (const platform of Object.keys(config.platforms)) {
@@ -228,90 +261,139 @@ export function createMessengerGateway(
 	}
 	const seen = new Set<string>();
 	const queue: PendingMessage[] = [];
+	const activeKeys = new Set<string>();
+	const turns = new Set<Promise<void>>();
+	/** Settles when the latest request of a prepared conversation has delivered its reply. */
+	const conversationTails = new Map<string, Promise<void>>();
 	const lifetime = new AbortController();
-	let draining: Promise<void> | undefined;
-	let workerActive = false;
 	let running = false;
 	let fatalError: MessengerFatalError | undefined;
 	let statusInFlight = 0;
 
-	async function drain(): Promise<void> {
-		while (queue.length > 0) {
-			const pending = queue.shift();
-			if (!pending) break;
-			const { message, adapter, signal, resolve } = pending;
-			let failed = false;
-			let activity = NO_ACTIVITY;
-			let statusChain = Promise.resolve();
-			const status = (state: "processing" | "success" | "failure"): void => {
-				if (!adapter.status) return;
-				statusChain = statusChain.then(async () => {
-					if (signal.aborted || statusInFlight >= MAX_STATUS_IN_FLIGHT) return;
-					const timeout = new AbortController();
-					const statusSignal = AbortSignal.any([signal, timeout.signal]);
-					const stopped = Promise.withResolvers<void>();
-					const onAbort = (): void => stopped.resolve();
-					statusSignal.addEventListener("abort", onAbort, { once: true });
-					statusInFlight++;
-					const operation = Promise.resolve().then(() => adapter.status!(message, state, statusSignal));
-					void operation.then(
-						() => {
-							statusInFlight--;
-						},
-						() => {
-							statusInFlight--;
-						},
-					);
-					const timer = setTimeout(() => timeout.abort(), STATUS_TIMEOUT_MS);
-					try {
-						await Promise.race([operation, stopped.promise]);
-					} catch {
-						if (!signal.aborted) logger.warn("Messenger status update failed", { platform: message.platform });
-					} finally {
-						clearTimeout(timer);
-						statusSignal.removeEventListener("abort", onAbort);
-					}
+	async function processRequest(pending: PendingMessage): Promise<void> {
+		const { message, adapter, signal, resolve } = pending;
+		let failed = false;
+		let activity = NO_ACTIVITY;
+		let release = (): void => {};
+		let tail: Promise<void> | undefined;
+		let conversation = "";
+		let statusChain = Promise.resolve();
+		let processingStarted = false;
+		const status = (state: "processing" | "success" | "failure"): void => {
+			if (!adapter.status) return;
+			statusChain = statusChain.then(async () => {
+				if (signal.aborted || statusInFlight >= MAX_STATUS_IN_FLIGHT) return;
+				const timeout = new AbortController();
+				const statusSignal = AbortSignal.any([signal, timeout.signal]);
+				const stopped = Promise.withResolvers<void>();
+				const onAbort = (): void => stopped.resolve();
+				statusSignal.addEventListener("abort", onAbort, { once: true });
+				statusInFlight++;
+				const operation = Promise.resolve().then(() => {
+					if (state === "processing") processingStarted = true;
+					return adapter.status!(message, state, statusSignal);
 				});
-			};
-			try {
-				if (signal.aborted) continue;
-				status("processing");
-				const destination = (await adapter.prepare?.(message, signal)) ?? message;
-				activity = createActivityReporter(adapter, destination, signal, activityIntervalMs);
-				let text: string;
+				void operation.then(
+					() => {
+						statusInFlight--;
+					},
+					() => {
+						statusInFlight--;
+					},
+				);
+				const timer = setTimeout(() => timeout.abort(), STATUS_TIMEOUT_MS);
 				try {
-					text = await reply(destination, signal, activity.report);
-				} catch (error) {
-					failed = true;
-					if (error instanceof MessengerFatalError) {
-						fatalError = error;
-						status("failure");
-						lifetime.abort();
-						continue;
-					}
-					if (signal.aborted) continue;
-					logger.warn("Messenger agent turn failed", { platform: message.platform });
-					text = "The request could not be completed. Please try again.";
+					await Promise.race([operation, stopped.promise]);
+				} catch {
+					if (!signal.aborted) logger.warn("Messenger status update failed", { platform: message.platform });
 				} finally {
-					// Retire the status line alongside reply delivery rather than delaying the reply on it.
-					void activity.close();
+					clearTimeout(timer);
+					statusSignal.removeEventListener("abort", onAbort);
 				}
-				if (!signal.aborted && text.trim()) {
-					// A failed send may already have delivered a chunk: never retry the entire reply.
-					await adapter.send(destination, text, signal);
-				}
-				if (!signal.aborted) status(failed ? "failure" : "success");
-			} catch {
-				if (!signal.aborted) {
-					logger.warn("Messenger reply delivery failed", { platform: message.platform });
+			});
+		};
+		try {
+			if (signal.aborted) return;
+			status("processing");
+			const destination = (await adapter.prepare?.(message, signal)) ?? message;
+			// Answer and deliver in arrival order per prepared conversation, so a follow-up in a new thread can
+			// neither overtake nor interleave with the reply of the request that created it.
+			conversation = messengerConversationKey(destination);
+			const previous = conversationTails.get(conversation);
+			const done = Promise.withResolvers<void>();
+			release = done.resolve;
+			tail = done.promise;
+			conversationTails.set(conversation, tail);
+			await previous;
+			activity = createActivityReporter(adapter, destination, signal, activityIntervalMs);
+			let text: string;
+			try {
+				text = await reply(destination, signal, activity.report);
+			} catch (error) {
+				failed = true;
+				if (error instanceof MessengerFatalError) {
+					fatalError = error;
 					status("failure");
+					lifetime.abort();
+					return;
 				}
+				if (signal.aborted) return;
+				logger.warn("Messenger agent turn failed", { platform: message.platform });
+				text = "The request could not be completed. Please try again.";
 			} finally {
-				await activity.close();
-				resolve();
+				// Retire the status line alongside reply delivery rather than delaying the reply on it.
+				void activity.close();
+			}
+			if (!signal.aborted && text.trim()) {
+				// A failed send may already have delivered a chunk: never retry the entire reply.
+				await adapter.send(destination, text, signal);
 			}
+			if (!signal.aborted) status(failed ? "failure" : "success");
+		} catch {
+			if (!signal.aborted) {
+				logger.warn("Messenger reply delivery failed", { platform: message.platform });
+				status("failure");
+			}
+		} finally {
+			await activity.close();
+			if (signal.aborted && processingStarted && adapter.clearStatus && statusInFlight < MAX_STATUS_IN_FLIGHT) {
+				statusInFlight++;
+				const operation = Promise.resolve().then(() =>
+					adapter.clearStatus!(message, AbortSignal.timeout(STATUS_TIMEOUT_MS)),
+				);
+				void operation.then(
+					() => statusInFlight--,
+					() => statusInFlight--,
+				);
+				try {
+					await Promise.race([operation, Bun.sleep(STATUS_TIMEOUT_MS)]);
+				} catch {
+					logger.warn("Messenger cancelled status removal failed", { platform: message.platform });
+				}
+			}
+			release();
+			if (tail && conversationTails.get(conversation) === tail) conversationTails.delete(conversation);
+			resolve();
+		}
+	}
+
+	/** Start queued requests in arrival order while capacity allows, skipping conversations already running. */
+	function schedule(): void {
+		for (let index = 0; index < queue.length && turns.size < concurrency; ) {
+			const pending = queue[index]!;
+			if (activeKeys.has(pending.key)) {
+				index++;
+				continue;
+			}
+			queue.splice(index, 1);
+			activeKeys.add(pending.key);
+			const turn = processRequest(pending).finally(() => {
+				activeKeys.delete(pending.key);
+				turns.delete(turn);
+				schedule();
+			});
+			turns.add(turn);
 		}
-		workerActive = false;
 	}
 
 	function handle(message: MessengerMessage, signal?: AbortSignal): Promise<void> {
@@ -326,11 +408,8 @@ export function createMessengerGateway(
 			if (oldest !== undefined) seen.delete(oldest);
 		}
 		const { promise, resolve } = Promise.withResolvers<void>();
-		queue.push({ message, adapter, signal: effectiveSignal, resolve });
-		if (!workerActive) {
-			workerActive = true;
-			draining = drain();
-		}
+		queue.push({ message, adapter, signal: effectiveSignal, resolve, key: schedulingKey(message, adapter) });
+		schedule();
 		return promise;
 	}
 
@@ -362,7 +441,7 @@ export function createMessengerGateway(
 			} finally {
 				lifetime.abort();
 				await Promise.allSettled(starts);
-				await draining;
+				while (turns.size > 0) await Promise.allSettled(turns);
 				signal.removeEventListener("abort", abort);
 			}
 		},

package/src/messenger/service.ts

@@ -0,0 +1,122 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { $ } from "bun";
+
+/** A per-user background service that keeps one messenger profile's gateway running. */
+export interface MessengerServicePlan {
+	/** Stable service name derived from the profile directory. */
+	label: string;
+	/** Profile directory: working directory and home of the run script and log. */
+	directory: string;
+	runScript: string;
+	logFile: string;
+}
+
+export function messengerServicePlan(directory: string, runScript: string): MessengerServicePlan {
+	const slug =
+		path
+			.basename(directory)
+			.toLowerCase()
+			.replace(/[^a-z0-9]+/g, "-")
+			.replace(/^-+|-+$/g, "") || "default";
+	return {
+		label: `dev.jeopi.messenger.${slug}`,
+		directory,
+		runScript,
+		logFile: path.join(directory, "gateway.log"),
+	};
+}
+
+function xml(value: string): string {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+/** launchd job: starts at login, restarts after a crash (throttled), logs to the profile directory. */
+export function launchdPlist(plan: MessengerServicePlan): string {
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Label</key><string>${xml(plan.label)}</string>
+	<key>ProgramArguments</key>
+	<array><string>/bin/sh</string><string>${xml(plan.runScript)}</string></array>
+	<key>WorkingDirectory</key><string>${xml(plan.directory)}</string>
+	<key>RunAtLoad</key><true/>
+	<key>KeepAlive</key><true/>
+	<key>ThrottleInterval</key><integer>30</integer>
+	<key>StandardOutPath</key><string>${xml(plan.logFile)}</string>
+	<key>StandardErrorPath</key><string>${xml(plan.logFile)}</string>
+</dict>
+</plist>
+`;
+}
+
+/** systemd --user unit with the same lifecycle as the launchd job. */
+export function systemdUnit(plan: MessengerServicePlan): string {
+	const quoted = (value: string): string => `"${value.replace(/(["\\])/g, "\\$1")}"`;
+	return `[Unit]
+Description=jeopi messenger gateway (${plan.label})
+After=network-online.target
+
+[Service]
+WorkingDirectory=${quoted(plan.directory)}
+ExecStart=/bin/sh ${quoted(plan.runScript)}
+Restart=always
+RestartSec=30
+StandardOutput=append:${plan.logFile}
+StandardError=append:${plan.logFile}
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+/**
+ * Install (or replace) and start the service, then confirm the platform reports it running.
+ * Returns a one-line description of where it was installed.
+ */
+export async function installMessengerService(
+	plan: MessengerServicePlan,
+	platform: NodeJS.Platform = process.platform,
+	home: string = os.homedir(),
+): Promise<string> {
+	if (platform === "darwin") {
+		const file = path.join(home, "Library", "LaunchAgents", `${plan.label}.plist`);
+		await Bun.write(file, launchdPlist(plan));
+		const domain = `gui/${process.getuid?.() ?? 0}`;
+		await $`launchctl bootout ${domain} ${file}`.quiet().nothrow();
+		// bootstrap can fail briefly while a replaced job is still exiting.
+		let loaded = false;
+		for (let attempt = 0; attempt < 5 && !loaded; attempt++) {
+			if (attempt) await Bun.sleep(1_000);
+			loaded = (await $`launchctl bootstrap ${domain} ${file}`.quiet().nothrow()).exitCode === 0;
+		}
+		if (!loaded) throw new Error(`launchctl could not load ${file}`);
+		for (let attempt = 0; attempt < 20; attempt++) {
+			const status = await $`launchctl print ${domain}/${plan.label}`.quiet().nothrow();
+			if (status.exitCode === 0 && /\bstate = running\b/.test(status.text()))
+				return `launchd job ${plan.label} (${file})`;
+			await Bun.sleep(500);
+		}
+		throw new Error(`launchd job ${plan.label} did not reach the running state; see ${plan.logFile}`);
+	}
+	if (platform === "linux") {
+		const unit = `${plan.label}.service`;
+		const file = path.join(home, ".config", "systemd", "user", unit);
+		await fs.mkdir(path.dirname(file), { recursive: true });
+		await Bun.write(file, systemdUnit(plan));
+		const reload = await $`systemctl --user daemon-reload`.quiet().nothrow();
+		const enable = await $`systemctl --user enable ${unit}`.quiet().nothrow();
+		const restart = await $`systemctl --user restart ${unit}`.quiet().nothrow();
+		if (reload.exitCode !== 0 || enable.exitCode !== 0 || restart.exitCode !== 0) {
+			throw new Error(`systemctl --user could not start ${unit}`);
+		}
+		const active = await $`systemctl --user is-active ${unit}`.quiet().nothrow();
+		if (active.text().trim() !== "active") throw new Error(`${unit} is not active; see ${plan.logFile}`);
+		return `systemd user unit ${unit} (${file})`;
+	}
+	throw new Error(
+		`Background services are supported on macOS (launchd) and Linux (systemd --user); run ${plan.runScript} under your own process manager`,
+	);
+}