@gajae-code/coding-agent 0.17.2 → 0.17.5

package/src/utils/mupdf.ts

@@ -0,0 +1,136 @@
+import * as path from "node:path";
+import * as url from "node:url";
+import * as util from "node:util";
+import { logger } from "@gajae-code/utils";
+import { embeddedMuPdfModule, embeddedMuPdfWasm } from "./mupdf-embedded";
+
+export let mupdfAssetMapping = "module mupdf; WASM mupdf-wasm.wasm -> unresolved";
+let wasmAsset: string | undefined;
+let initializationFailure: unknown;
+let preparation: Promise<void> | undefined;
+
+interface MuPdfModuleConfiguration {
+	wasmBinary?: Uint8Array;
+	locateFile?: (filename?: string) => string;
+	onAbort?: (error: unknown) => void;
+}
+
+type MuPdfGlobal = typeof globalThis & {
+	$libmupdf_wasm_Module?: MuPdfModuleConfiguration;
+};
+
+function resolveWasmAsset(): string {
+	if (wasmAsset) return wasmAsset;
+	let moduleMapping: string;
+	if (embeddedMuPdfWasm) {
+		wasmAsset = embeddedMuPdfWasm;
+		moduleMapping = `build-time provenance ${embeddedMuPdfModule}`;
+	} else {
+		if (process.env.PI_COMPILED || /\$bunfs|~BUN|%7EBUN/.test(import.meta.url)) {
+			throw new Error("Compiled MuPDF WASM mapping is missing; run scripts/embed-mupdf.ts before compiling.");
+		}
+		const markitModule = url.fileURLToPath(new URL("../../vendor/markit-ai/dist/index.js", import.meta.url));
+		moduleMapping = Bun.resolveSync("mupdf", path.dirname(markitModule));
+		wasmAsset = path.join(path.dirname(moduleMapping), "mupdf-wasm.wasm");
+	}
+	mupdfAssetMapping = `module mupdf -> ${moduleMapping}; WASM mupdf-wasm.wasm -> ${wasmAsset}`;
+	return wasmAsset;
+}
+
+// The official Emscripten hook is consumed by markit-ai's lazy MuPDF import.
+// Capture initialization aborts while preserving the import error's cause chain.
+const globalScope = globalThis as MuPdfGlobal;
+const hostConfiguration = globalScope.$libmupdf_wasm_Module;
+const configuration: MuPdfModuleConfiguration = hostConfiguration ?? {
+	locateFile: resolveWasmAsset,
+	onAbort(error: unknown) {
+		initializationFailure = error;
+	},
+};
+
+if (hostConfiguration === undefined) {
+	globalScope.$libmupdf_wasm_Module = configuration;
+} else {
+	// Reuse an SDK host's configuration and hooks. Only fill absent fields; do
+	// not replace locateFile/onAbort or discard caller-owned settings.
+	if (configuration.locateFile === undefined) configuration.locateFile = resolveWasmAsset;
+	if (configuration.onAbort === undefined) {
+		configuration.onAbort = error => {
+			initializationFailure = error;
+		};
+	}
+}
+
+function preparationAsset(): string {
+	const configuredPath = configuration.locateFile?.("mupdf-wasm.wasm");
+	return configuredPath ?? resolveWasmAsset();
+}
+
+export function prepareMuPdf(): Promise<void> {
+	// A new conversion attempt must not inherit an abort from a prior attempt.
+	initializationFailure = undefined;
+	const previousWasmBinary = configuration.wasmBinary;
+	preparation ??= Promise.resolve()
+		.then(async () => {
+			const bytes = await Bun.file(preparationAsset()).bytes();
+			// Reject corrupt assets before Emscripten starts: its abort path can also
+			// reject a secondary promise even when the module import is caught.
+			await WebAssembly.compile(bytes);
+			if (configuration.wasmBinary === undefined) configuration.wasmBinary = bytes;
+		})
+		.catch(error => {
+			preparation = undefined;
+			configuration.wasmBinary = previousWasmBinary;
+			throw error;
+		});
+	return preparation;
+}
+
+export function withMuPdfDiagnostic(error: unknown): Error {
+	const capturedInitializationFailure = initializationFailure;
+	initializationFailure = undefined;
+	const cause = capturedInitializationFailure ?? error;
+	const debugDetails: Record<string, unknown> = {
+		asset: embeddedMuPdfWasm ? "embedded" : "package",
+		error: formatMuPdfCauseChain(error),
+	};
+	if (capturedInitializationFailure !== undefined) {
+		debugDetails.initializationFailure = formatMuPdfCauseChain(capturedInitializationFailure);
+	}
+	logger.debug("MuPDF conversion failed", debugDetails);
+	const asset = embeddedMuPdfWasm ? "embedded asset" : "package asset";
+	return new Error(`PDF conversion failed [MuPDF; ${asset}; mupdf-wasm.wasm]`, { cause });
+}
+
+function formatMuPdfCauseChain(error: unknown): string {
+	const messages: string[] = [];
+	const seen = new Set<unknown>();
+	while (error !== undefined && !seen.has(error)) {
+		seen.add(error);
+		if (error instanceof Error) {
+			messages.push(sanitizeMuPdfDiagnostic(`${error.name}: ${error.message}`));
+			error = error.cause;
+		} else {
+			messages.push(sanitizeMuPdfDiagnostic(String(error)));
+			break;
+		}
+	}
+	return messages.join("; caused by: ") || "Conversion failed";
+}
+
+// Only the model-facing rendering is redacted; Error.cause remains intact for
+// internal inspection and operational debug logging. Conservatively redact the
+// rest of a path-bearing field so spaces in install paths cannot leak suffixes.
+export function sanitizeMuPdfDiagnostic(message: string): string {
+	return (
+		util
+			.stripVTControlCharacters(message)
+			.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g, "")
+			// The prefix run is boundary anchored. Unbounded, `[^\s"'`]*` is re-tried at
+			// every offset of a long slash-free run before failing to find a separator,
+			// which is quadratic in the message length: 100 KB cost about 13s. A MuPDF
+			// diagnostic is derived from the document being converted, and
+			// `normalizeError` runs this once per link in the cause chain.
+			.replace(/(?<![^\s"'`])[^\s"'`]*(?:[/\\]|%2f|%5c)[^"'`]*(?=["'`]|$)/gi, "[path redacted]")
+	);
+}

package/src/utils/session-title-generation.ts

@@ -0,0 +1,29 @@
+/**
+ * In-memory generation lease for asynchronous session-title regeneration.
+ *
+ * The lease is keyed by the session manager instance so TUI and ACP command
+ * dispatchers share the same ordering state without adding protocol fields to
+ * the persisted session format.
+ */
+const generations = new WeakMap<object, number>();
+
+function currentGeneration(owner: object): number {
+	return generations.get(owner) ?? 0;
+}
+
+/** Start a new regeneration and invalidate every older completion. */
+export function beginSessionTitleGeneration(owner: object): number {
+	const generation = currentGeneration(owner) + 1;
+	generations.set(owner, generation);
+	return generation;
+}
+
+/** Invalidate pending regeneration after a newer session mutation is accepted. */
+export function invalidateSessionTitleGeneration(owner: object): void {
+	generations.set(owner, currentGeneration(owner) + 1);
+}
+
+/** Return whether a regeneration still owns the latest generation lease. */
+export function isSessionTitleGenerationCurrent(owner: object, generation: number): boolean {
+	return currentGeneration(owner) === generation;
+}

package/src/utils/title-generator.ts

@@ -3,6 +3,7 @@
  */
 import * as path from "node:path";
 
+import type { AgentMessage } from "@gajae-code/agent-core";
 import { type Api, type AssistantMessage, completeSimple, type Model, type Tool } from "@gajae-code/ai/core";
 import { logger, prompt } from "@gajae-code/utils";
 import type { ModelRegistry } from "../config/model-registry";
@@ -17,6 +18,9 @@ const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 const DEFAULT_TERMINAL_TITLE = "GJC";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
+const MAX_TITLE_CONVERSATION_MESSAGES = 6;
+const MAX_TITLE_MESSAGE_CHARS = 400;
+
 const MAX_INPUT_CHARS = 2000;
 const TITLE_MAX_TOKENS = 30;
 const REASONING_SAFE_MAX_TOKENS = 1024;
@@ -29,6 +33,44 @@ const SET_TITLE_TOOL_NAME = "set_title";
 const MAX_TITLE_CHARS = 80;
 const MAX_TITLE_WORDS = 12;
 
+/**
+ * Build a bounded conversation digest for title regeneration. Regeneration
+ * reads several messages so a throwaway first prompt can be corrected, while
+ * the automatic first-message path intentionally uses only its initial input.
+ */
+export function buildConversationTitleInput(messages: readonly AgentMessage[]): string | undefined {
+	const userMessages: string[] = [];
+	for (const message of messages) {
+		if (message.role !== "user") continue;
+		const content = message.content;
+		const text =
+			typeof content === "string"
+				? content
+				: content
+						.filter(block => block.type === "text")
+						.map(block => block.text)
+						.join("\n");
+		const trimmed = text.trim();
+		if (trimmed) userMessages.push(trimmed);
+	}
+
+	if (userMessages.length === 0) return undefined;
+
+	const keptMessages =
+		userMessages.length > MAX_TITLE_CONVERSATION_MESSAGES
+			? [userMessages[0]!, ...userMessages.slice(-(MAX_TITLE_CONVERSATION_MESSAGES - 1))]
+			: userMessages;
+	// Reserve separator and ellipsis room so the digest is already within the
+	// generator's MAX_INPUT_CHARS bound; its existing truncation is a no-op here.
+	const maxMessageChars = Math.min(
+		MAX_TITLE_MESSAGE_CHARS,
+		Math.floor((MAX_INPUT_CHARS - (keptMessages.length - 1) - keptMessages.length) / keptMessages.length),
+	);
+	return keptMessages
+		.map(message => (message.length > maxMessageChars ? `${message.slice(0, maxMessageChars)}…` : message))
+		.join("\n");
+}
+
 const setTitleTool: Tool = {
 	name: SET_TITLE_TOOL_NAME,
 	description: "Set the generated session title.",
@@ -58,9 +100,11 @@ function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel
 }
 
 /**
- * Generate a title for a session based on the first user message.
+ * Generate a title for a session based on the provided user-message input.
+ * Automatic titles pass the first user message; regeneration passes a bounded
+ * conversation digest.
  *
- * @param firstMessage The first user message
+ * @param firstMessage The first user message or bounded conversation digest
  * @param registry Model registry
  * @param settings Settings used to resolve the smol role
  * @param sessionId Optional session id for sticky API key selection

package/src/web/scrapers/types.ts

@@ -78,7 +78,10 @@ export interface LoadPageOptions {
 
 export interface LoadPageResult {
 	content: string;
+	/** The bounded response bytes retained for binary classification/conversion. */
+	buffer?: Uint8Array;
 	contentType: string;
+	contentDisposition?: string;
 	finalUrl: string;
 	ok: boolean;
 	status?: number;
@@ -173,6 +176,7 @@ export async function loadPage(url: string, options: LoadPageOptions = {}): Prom
 				}
 
 				const contentType = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() ?? "";
+				const contentDisposition = response.headers.get("content-disposition") || undefined;
 				const finalUrl = logicalUrl;
 
 				const reader = response.body?.getReader();
@@ -196,16 +200,33 @@ export async function loadPage(url: string, options: LoadPageOptions = {}): Prom
 					}
 				}
 
-				const content = Buffer.concat(chunks).toString("utf-8");
+				const bytes = Buffer.concat(chunks);
+				const content = bytes.toString("utf-8");
+				const buffer =
+					contentType.length === 0 ||
+					contentType === "application/octet-stream" ||
+					contentType === "binary/octet-stream" ||
+					contentType === "unknown" ||
+					contentDisposition !== undefined
+						? bytes
+						: undefined;
 				if (isBotBlocked(response.status, content) && attempt < USER_AGENTS.length - 1) {
 					continue attempts;
 				}
 
 				if (!response.ok) {
-					return { content, contentType, finalUrl, ok: false, status: response.status };
+					return {
+						content,
+						buffer,
+						contentType,
+						contentDisposition,
+						finalUrl,
+						ok: false,
+						status: response.status,
+					};
 				}
 
-				return { content, contentType, finalUrl, ok: true, status: response.status };
+				return { content, buffer, contentType, contentDisposition, finalUrl, ok: true, status: response.status };
 			}
 			return {
 				content: "",

package/vendor/markit-ai/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Liv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.