jeopi-cli 16.6.11 → 16.6.12

package/src/main.ts

@@ -296,7 +296,11 @@ export function buildModelScopeNotification(
 export async function submitInteractiveInput(
 	mode: Pick<
 		InteractiveMode,
-		"markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested"
+		| "markPendingSubmissionStarted"
+		| "finishPendingSubmission"
+		| "showError"
+		| "checkShutdownRequested"
+		| "liveDiscordBridge"
 	>,
 	session: Pick<AgentSession, "prompt" | "promptCustomMessage" | "isStreaming">,
 	input: SubmittedUserInput,
@@ -346,7 +350,13 @@ export async function submitInteractiveInput(
 				userInitiated: input.userInitiated,
 			});
 		} else {
-			await session.prompt(input.text, { images: input.images, streamingBehavior });
+			const submit = () => session.prompt(input.text, { images: input.images, streamingBehavior });
+			const bridge = mode.liveDiscordBridge;
+			await (input.streamingBehavior === "steer" && bridge?.active
+				? bridge.withLocalTurn(input.text, onPreparedUserMessage =>
+						session.prompt(input.text, { images: input.images, streamingBehavior, onPreparedUserMessage }),
+					)
+				: submit());
 		}
 	} catch (error: unknown) {
 		const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";

package/src/messenger/artifacts.ts

@@ -0,0 +1,167 @@
+import * as fsConstants from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { prompt } from "jeopi-utils";
+import artifactPrompt from "../prompts/system/messenger-artifacts.md" with { type: "text" };
+import { messengerConversationKey } from "./gateway";
+import type { MessengerMessage } from "./types";
+
+const MAX_ARTIFACT_SIZE = 8 * 1024 * 1024;
+const MAX_ARTIFACTS = 10;
+
+export function messengerArtifactDirectory(root: string, message: MessengerMessage): string {
+	const route = new Bun.CryptoHasher("sha256").update(messengerConversationKey(message)).digest("hex");
+	return path.join(root, route);
+}
+
+export async function prepareMessengerArtifactDirectory(root: string, message: MessengerMessage): Promise<string> {
+	const rootStat = await fs.lstat(root);
+	if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) throw new Error("Invalid artifact directory");
+	const directory = messengerArtifactDirectory(root, message);
+	await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+	const stat = await fs.lstat(directory);
+	if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("Invalid artifact directory");
+	return directory;
+}
+
+async function withAbort<T>(operation: () => Promise<T>, signal: AbortSignal): Promise<T> {
+	if (signal.aborted) throw new Error("Attachment download aborted");
+	const stopped = Promise.withResolvers<never>();
+	const abort = (): void => stopped.reject(new Error("Attachment download aborted"));
+	signal.addEventListener("abort", abort, { once: true });
+	try {
+		return await Promise.race([operation(), stopped.promise]);
+	} finally {
+		signal.removeEventListener("abort", abort);
+	}
+}
+
+export async function downloadMessengerAttachments(
+	directory: string,
+	message: MessengerMessage,
+	signal: AbortSignal,
+	fetchImpl: typeof fetch = fetch,
+	timeoutMs = 30_000,
+): Promise<string[]> {
+	const attachments = message.attachments ?? [];
+	if (attachments.length > 5) throw new Error("Too many attachments");
+	const paths: string[] = [];
+	for (const [index, attachment] of attachments.entries()) {
+		const url = new URL(attachment.url);
+		if (
+			url.protocol !== "https:" ||
+			url.hostname !== "cdn.discordapp.com" ||
+			url.port ||
+			url.username ||
+			url.password ||
+			!url.pathname.startsWith("/attachments/")
+		)
+			throw new Error("Invalid attachment URL");
+		if (!Number.isSafeInteger(attachment.size) || attachment.size < 0 || attachment.size > MAX_ARTIFACT_SIZE)
+			throw new Error("Invalid attachment size");
+		const downloadSignal = AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]);
+		const response = await withAbort(
+			() => fetchImpl(url, { signal: downloadSignal, redirect: "error" }),
+			downloadSignal,
+		);
+		if (!response.ok || !response.body) throw new Error("Attachment download failed");
+		const reader = response.body.getReader();
+		const chunks: Uint8Array[] = [];
+		let size = 0;
+		try {
+			while (true) {
+				const { done, value } = await withAbort(() => reader.read(), downloadSignal);
+				if (done) break;
+				size += value.byteLength;
+				if (size > MAX_ARTIFACT_SIZE || size > attachment.size) throw new Error("Attachment exceeds declared size");
+				chunks.push(value);
+			}
+		} finally {
+			void reader.cancel().catch(() => {});
+		}
+		if (size !== attachment.size) throw new Error("Attachment size mismatch");
+		const safeName =
+			path
+				.basename(attachment.filename)
+				.replace(/[^a-zA-Z0-9._-]/gu, "_")
+				.slice(0, 100) || "attachment";
+		const id = new Bun.CryptoHasher("sha256").update(message.messageId).digest("hex");
+		const file = path.join(directory, `input-${id}-${index}-${safeName}`);
+		await fs.writeFile(file, Buffer.concat(chunks), { flag: "wx", mode: 0o600 });
+		paths.push(file);
+	}
+	return paths;
+}
+
+export async function messengerArtifactPrompt(
+	root: string | undefined,
+	message: MessengerMessage,
+	signal: AbortSignal,
+): Promise<string> {
+	if (!root) {
+		if (message.attachments?.length) throw new Error("Discord attachments are not enabled");
+		return "";
+	}
+	const directory = await prepareMessengerArtifactDirectory(root, message);
+	const inputs = await downloadMessengerAttachments(directory, message, signal);
+	return prompt.render(artifactPrompt, { directory, inputs: inputs.join(", ") });
+}
+
+export async function readMessengerArtifacts(
+	root: string,
+	message: MessengerMessage,
+	text: string,
+): Promise<{
+	text: string;
+	files: { name: string; data: Uint8Array }[];
+}> {
+	const names: string[] = [];
+	const cleaned = text
+		.replace(/^\s*\[artifact:([^\]\r\n]+)\]\s*$/gmu, (_match, name: string) => {
+			names.push(name);
+			return "";
+		})
+		.trim();
+	if (names.length > MAX_ARTIFACTS) throw new Error("Too many output files");
+	if (!names.length) return { text, files: [] };
+	const directory = await prepareMessengerArtifactDirectory(root, message);
+	const files: { name: string; data: Uint8Array }[] = [];
+	for (const name of names) {
+		if (
+			!name ||
+			path.isAbsolute(name) ||
+			name.includes("\\") ||
+			name.split("/").some(part => !part || part === "." || part === "..")
+		) {
+			throw new Error("Invalid output file path");
+		}
+		let current = path.resolve(directory);
+		for (const part of name.split("/")) {
+			current = path.join(current, part);
+			const entry = await fs.lstat(current);
+			if (entry.isSymbolicLink()) throw new Error("Output file symlinks are not allowed");
+		}
+		if (!(await fs.lstat(current)).isFile()) throw new Error("Output file is not a regular file");
+		const handle = await fs.open(
+			current,
+			fsConstants.constants.O_RDONLY | fsConstants.constants.O_NOFOLLOW | fsConstants.constants.O_NONBLOCK,
+		);
+		try {
+			const stat = await handle.stat();
+			if (!stat.isFile() || stat.size > MAX_ARTIFACT_SIZE)
+				throw new Error("Output file is invalid or exceeds 8 MiB");
+			const data = Buffer.alloc(stat.size + 1);
+			let offset = 0;
+			while (offset < data.length) {
+				const { bytesRead } = await handle.read(data, offset, data.length - offset, offset);
+				if (!bytesRead) break;
+				offset += bytesRead;
+			}
+			if (offset !== stat.size) throw new Error("Output file changed while being read");
+			files.push({ name: path.basename(name), data: data.subarray(0, offset) });
+		} finally {
+			await handle.close();
+		}
+	}
+	return { text: cleaned, files };
+}

package/src/messenger/config.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { MessengerConfig, MessengerPlatform, MessengerPlatformConfig } from "./types";
 
@@ -51,7 +52,9 @@ export function parseMessengerConfig(value: unknown, baseDir: string): Messenger
 			item,
 			platform === "slack"
 				? ["tokenEnv", "appTokenEnv", "allowedUserIds", "allowedChannelIds"]
-				: ["tokenEnv", "allowedUserIds", "allowedChannelIds"],
+				: platform === "discord"
+					? ["tokenEnv", "allowedUserIds", "allowedChannelIds", "artifactDir"]
+					: ["tokenEnv", "allowedUserIds", "allowedChannelIds"],
 			`${platform} config`,
 		);
 		const config: MessengerPlatformConfig = {
@@ -62,6 +65,8 @@ export function parseMessengerConfig(value: unknown, baseDir: string): Messenger
 			config.appTokenEnv = envName(item.appTokenEnv, "JEOPI_SLACK_APP_TOKEN", "slack.appTokenEnv");
 		if (item.allowedChannelIds !== undefined)
 			config.allowedChannelIds = ids(item.allowedChannelIds, `${platform}.allowedChannelIds`);
+		if (platform === "discord" && item.artifactDir !== undefined)
+			config.artifactDir = path.resolve(baseDir, string(item.artifactDir, "discord.artifactDir"));
 		platforms[platform] = config;
 	}
 	const toolNames = input.toolNames === undefined ? [] : input.toolNames;
@@ -90,7 +95,14 @@ export async function loadMessengerConfig(file: string): Promise<MessengerConfig
 	} catch {
 		throw new Error("Cannot read messenger configuration as JSON");
 	}
-	return parseMessengerConfig(value, path.dirname(path.resolve(file)));
+	const config = parseMessengerConfig(value, path.dirname(path.resolve(file)));
+	const artifactDir = config.platforms.discord?.artifactDir;
+	if (artifactDir) {
+		const stat = await fs.lstat(artifactDir).catch(() => undefined);
+		if (!stat?.isDirectory() || stat.isSymbolicLink())
+			throw new Error("discord.artifactDir must be an existing directory, not a symlink");
+	}
+	return config;
 }
 
 export function validateMessengerEnvironment(

package/src/messenger/discord.ts

@@ -1,5 +1,6 @@
 import { isRecord, logger } from "jeopi-utils";
-import { MessengerHttpError, messengerFetchJson, splitMessengerText } from "./http";
+import { readMessengerArtifacts } from "./artifacts";
+import { MessengerHttpError, messengerFetchJson } from "./http";
 import type { MessengerAdapter, MessengerMessage, MessengerPlatformConfig, MessengerTransportDeps } from "./types";
 
 // Protocol: https://docs.discord.com/developers/events/gateway
@@ -9,6 +10,36 @@ const API = "https://discord.com/api/v10";
 const INTENTS = (1 << 9) | (1 << 12) | (1 << 15);
 const PERMANENT_CLOSE_CODES = new Set([4004, 4010, 4011, 4012, 4013, 4014]);
 
+// Discord strips boundary whitespace. Invisible guards preserve it in message content;
+// they are part of the delivered text, and consume one UTF-16 unit each.
+const DISCORD_WHITESPACE = /^[\s\u0085\u001c-\u001f]$/u;
+const DISCORD_BOUNDARY_GUARD = "\u200b";
+
+function splitDiscordText(text: string): { chunks: string[]; needsAttachment: boolean } {
+	const chunks: string[] = [];
+	let needsAttachment = false;
+	for (let start = 0; start < text.length; ) {
+		const leadingGuard = DISCORD_WHITESPACE.test(text[start]) ? DISCORD_BOUNDARY_GUARD : "";
+		let fallback = 0;
+		let end = Math.min(start + 2_000 - leadingGuard.length, text.length);
+		for (; end > start; end--) {
+			const last = text.charCodeAt(end - 1);
+			if (end < text.length && last >= 0xd800 && last <= 0xdbff) continue;
+			const trailingWhitespace = DISCORD_WHITESPACE.test(text[end - 1]);
+			if (end - start + leadingGuard.length + Number(trailingWhitespace) > 2_000) continue;
+			if (!fallback) fallback = end;
+			if (end === text.length || (!trailingWhitespace && !DISCORD_WHITESPACE.test(text[end]))) break;
+		}
+		if (end === start) end = fallback;
+		const chunk = text.slice(start, end);
+		const trailingGuard = DISCORD_WHITESPACE.test(chunk[chunk.length - 1]) ? DISCORD_BOUNDARY_GUARD : "";
+		if (leadingGuard || trailingGuard) needsAttachment = true;
+		chunks.push(`${leadingGuard}${chunk}${trailingGuard}`);
+		start = end;
+	}
+	return { chunks, needsAttachment };
+}
+
 class DiscordConfigurationError extends Error {}
 
 export interface DiscordClock {
@@ -89,14 +120,24 @@ function normalizeMessage(value: unknown, accountId: string): MessengerMessage |
 		typeof value.author.id !== "string" ||
 		!value.author.id ||
 		typeof value.content !== "string" ||
-		!value.content.trim() ||
+		(!value.content.trim() && !(Array.isArray(value.attachments) && value.attachments.length > 0)) ||
 		(value.type !== undefined && value.type !== 0 && value.type !== 19)
 	)
 		return;
 	const mentioned =
 		Array.isArray(value.mentions) && value.mentions.some(user => isRecord(user) && user.id === accountId);
 	const text = value.content.replaceAll(`<@${accountId}>`, "").replaceAll(`<@!${accountId}>`, "").trim();
-	if (!text) return;
+	const attachments = Array.isArray(value.attachments)
+		? value.attachments.map(item =>
+				isRecord(item) &&
+				typeof item.url === "string" &&
+				typeof item.filename === "string" &&
+				typeof item.size === "number"
+					? { url: item.url, filename: item.filename, size: item.size }
+					: { url: "", filename: "", size: -1 },
+			)
+		: [];
+	if (!text && attachments.length === 0) return;
 	return {
 		platform: "discord",
 		accountId,
@@ -105,6 +146,7 @@ function normalizeMessage(value: unknown, accountId: string): MessengerMessage |
 		messageId: value.id,
 		text,
 		direct: value.guild_id === undefined,
+		attachments,
 		mentioned,
 	};
 }
@@ -283,6 +325,14 @@ export function createDiscordAdapter(
 ): MessengerAdapter {
 	const token = env[config.tokenEnv]?.trim();
 	const clock = deps.clock ?? defaultClock;
+	const createdThreads = new Map<string, { parentChannelId: string; senderId: string }>();
+	const rememberThread = (threadId: string, parentChannelId: string, senderId: string): void => {
+		createdThreads.set(threadId, { parentChannelId, senderId });
+		if (createdThreads.size > 10_000) {
+			const oldest = createdThreads.keys().next().value;
+			if (oldest !== undefined) createdThreads.delete(oldest);
+		}
+	};
 	const headers = (): Record<string, string> => {
 		if (!token) throw new DiscordConfigurationError("Discord bot token is missing");
 		return { Authorization: `Bot ${token}`, "Content-Type": "application/json" };
@@ -319,12 +369,54 @@ export function createDiscordAdapter(
 						}
 						initialUrl = gatewayUrl(gateway.url);
 					}
+					const deliver = async (message: MessengerMessage): Promise<void> => {
+						const thread = createdThreads.get(message.channelId);
+						if (thread && thread.senderId === message.senderId) {
+							await onMessage({
+								...message,
+								threadId: message.channelId,
+								parentChannelId: thread.parentChannelId,
+							});
+						} else if (
+							!message.direct &&
+							message.mentioned &&
+							config.allowedUserIds.includes(message.senderId) &&
+							config.allowedChannelIds &&
+							!config.allowedChannelIds.includes(message.channelId)
+						) {
+							try {
+								const channel = await messengerFetchJson(
+									`${API}/channels/${encodeURIComponent(message.channelId)}`,
+									{ headers: headers() },
+									signal,
+									deps.fetch,
+								);
+								if (
+									isRecord(channel) &&
+									typeof channel.type === "number" &&
+									[10, 11, 12].includes(channel.type) &&
+									typeof channel.parent_id === "string" &&
+									channel.parent_id
+								) {
+									await onMessage({
+										...message,
+										threadId: message.channelId,
+										parentChannelId: channel.parent_id,
+									});
+								}
+							} catch {
+								if (!signal.aborted) logger.warn("Discord thread parent lookup failed");
+							}
+						} else {
+							await onMessage(message);
+						}
+					};
 					await connectGateway(
 						session.url ?? initialUrl,
 						token!,
 						accountId,
 						session,
-						onMessage,
+						deliver,
 						signal,
 						deps.WebSocket ?? WebSocket,
 						clock,
@@ -357,25 +449,183 @@ export function createDiscordAdapter(
 				delay = Math.min(delay * 2, 30_000);
 			}
 		},
+		async prepare(message, signal) {
+			if (message.direct) return message;
+			if (message.threadId) {
+				if (message.parentChannelId) rememberThread(message.threadId, message.parentChannelId, message.senderId);
+				return message;
+			}
+			const channel = await messengerFetchJson(
+				`${API}/channels/${encodeURIComponent(message.channelId)}`,
+				{ headers: headers() },
+				signal,
+				deps.fetch,
+			);
+			if (!isRecord(channel) || typeof channel.type !== "number")
+				throw new Error("Discord channel type unavailable");
+			if ([10, 11, 12].includes(channel.type)) {
+				if (typeof channel.parent_id !== "string" || !channel.parent_id)
+					throw new Error("Discord thread parent unavailable");
+				rememberThread(message.channelId, channel.parent_id, message.senderId);
+				return { ...message, threadId: message.channelId, parentChannelId: channel.parent_id };
+			}
+			if (channel.type !== 0 && channel.type !== 5) throw new Error("Discord channel cannot host a reply thread");
+			const thread = await messengerFetchJson(
+				`${API}/channels/${encodeURIComponent(message.channelId)}/messages/${encodeURIComponent(message.messageId)}/threads`,
+				{ method: "POST", headers: headers(), body: JSON.stringify({ name: `Request ${message.messageId}` }) },
+				signal,
+				deps.fetch,
+			);
+			if (!isRecord(thread) || typeof thread.id !== "string" || !thread.id)
+				throw new Error("Discord thread creation returned no ID");
+			rememberThread(thread.id, message.channelId, message.senderId);
+			return { ...message, threadId: thread.id };
+		},
+		async status(message, state, signal) {
+			const base = `${API}/channels/${encodeURIComponent(message.channelId)}/messages/${encodeURIComponent(message.messageId)}/reactions`;
+			const processing = encodeURIComponent("⏳");
+			if (state !== "processing") {
+				try {
+					await messengerFetchJson(
+						`${base}/${processing}/@me`,
+						{ method: "DELETE", headers: headers() },
+						signal,
+						deps.fetch,
+					);
+				} catch {
+					logger.warn("Discord processing reaction removal failed");
+				}
+			}
+			const emoji = state === "processing" ? "⏳" : state === "success" ? "✅" : "❌";
+			await messengerFetchJson(
+				`${base}/${encodeURIComponent(emoji)}/@me`,
+				{ method: "PUT", headers: headers() },
+				signal,
+				deps.fetch,
+			);
+		},
 		async send(message, text, signal) {
-			const chunks = splitMessengerText(text, 2_000);
-			for (let index = 0; index < chunks.length; index++) {
-				await messengerFetchJson(
-					`${API}/channels/${encodeURIComponent(message.channelId)}/messages`,
-					{
-						method: "POST",
-						headers: headers(),
-						body: JSON.stringify({
-							content: chunks[index],
-							allowed_mentions: { parse: [], replied_user: false },
-							...(index === 0
-								? { message_reference: { message_id: message.messageId, fail_if_not_exists: false } }
-								: {}),
-						}),
-					},
-					signal,
-					deps.fetch,
-				);
+			let files: { name: string; data: Uint8Array }[] = [];
+			if (config.artifactDir) {
+				try {
+					const result = await readMessengerArtifacts(config.artifactDir, message, text);
+					text = result.text;
+					files = result.files;
+				} catch {
+					await messengerFetchJson(
+						`${API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
+						{
+							method: "POST",
+							headers: headers(),
+							body: JSON.stringify({
+								content: "File delivery failed: check the output path and size (maximum 8 MiB).",
+								allowed_mentions: { parse: [], replied_user: false },
+							}),
+						},
+						signal,
+						deps.fetch,
+					);
+					throw new Error("Discord artifact delivery failed");
+				}
+			}
+			const { chunks, needsAttachment } = splitDiscordText(text);
+			for (let index = 0; index < chunks.length + Number(needsAttachment); index++) {
+				for (let attempt = 0; ; attempt++) {
+					try {
+						const attachment = index === chunks.length;
+						const requestHeaders = headers();
+						let body: string | FormData;
+						if (attachment) {
+							delete requestHeaders["Content-Type"];
+							const form = new FormData();
+							form.append(
+								"payload_json",
+								JSON.stringify({ allowed_mentions: { parse: [], replied_user: false } }),
+							);
+							form.append("files[0]", new Blob([text], { type: "text/plain; charset=utf-8" }), "response.txt");
+							body = form;
+						} else {
+							body = JSON.stringify({
+								content: chunks[index],
+								allowed_mentions: { parse: [], replied_user: false },
+								...(index === 0 &&
+								message.messageId &&
+								(!message.threadId || message.threadId === message.channelId)
+									? { message_reference: { message_id: message.messageId, fail_if_not_exists: false } }
+									: {}),
+							});
+						}
+						await messengerFetchJson(
+							`${API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
+							{
+								method: "POST",
+								headers: requestHeaders,
+								body,
+							},
+							signal,
+							deps.fetch,
+						);
+						break;
+					} catch (error) {
+						if (error instanceof MessengerHttpError && error.status === 429 && attempt < 3 && !signal?.aborted) {
+							try {
+								await waitForReconnect(
+									error.retryAfterMs ?? 1_000,
+									signal ?? new AbortController().signal,
+									clock,
+								);
+								if (!signal?.aborted) continue;
+							} catch {
+								// Cancellation or timer failure stops delivery without replaying prior chunks.
+							}
+						}
+						logger.warn("Discord reply partially delivered", {
+							deliveredChunks: Math.min(index, chunks.length),
+							totalChunks: chunks.length,
+							...(index === chunks.length ? { attachmentFailed: true } : {}),
+						});
+						throw error;
+					}
+				}
+			}
+			for (const file of files) {
+				const requestHeaders = headers();
+				delete requestHeaders["Content-Type"];
+				const form = new FormData();
+				form.append("payload_json", JSON.stringify({ allowed_mentions: { parse: [], replied_user: false } }));
+				form.append("files[0]", new Blob([file.data]), file.name);
+				for (let attempt = 0; ; attempt++) {
+					try {
+						await messengerFetchJson(
+							`${API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
+							{ method: "POST", headers: requestHeaders, body: form },
+							signal,
+							deps.fetch,
+						);
+						break;
+					} catch (error) {
+						if (error instanceof MessengerHttpError && error.status === 429 && attempt < 3 && !signal?.aborted) {
+							await waitForReconnect(error.retryAfterMs ?? 1_000, signal ?? new AbortController().signal, clock);
+							continue;
+						}
+						if (!signal?.aborted) {
+							await messengerFetchJson(
+								`${API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
+								{
+									method: "POST",
+									headers: headers(),
+									body: JSON.stringify({
+										content: "File upload failed; some files may not have been delivered.",
+										allowed_mentions: { parse: [], replied_user: false },
+									}),
+								},
+								signal,
+								deps.fetch,
+							).catch(() => {});
+						}
+						throw error;
+					}
+				}
 			}
 		},
 	};