@sayknow-cli/coding-agent 0.5.2 → 0.5.8

package/src/tools/ask.ts

@@ -595,6 +595,11 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	readonly description: string;
 	readonly parameters = askSchema;
 	readonly strict = true;
+	/**
+	 * These fields are rendered to the user and carry no executable or durable
+	 * meaning. IDs and workflow/deep-interview metadata remain fail-closed.
+	 */
+	readonly displaySafeEscapedArgFields = ["questions.question", "questions.options.label"] as const;
 	readonly loadMode = "discoverable";
 
 	constructor(private readonly session: ToolSession) {

package/src/tools/fetch.ts

@@ -751,7 +751,9 @@ async function renderUrl(
 				let convertedText: string | null = null;
 				const converted = await convertWithMarkit(binary.buffer, conversionExtension, timeout, signal);
 				if (converted.ok) {
-					if (converted.content.trim().length > 50) {
+					// See the non-empty conversion note near the document path
+					// below (upstream #5433): short conversions still beat raw fallback.
+					if (converted.content.trim().length > 0) {
 						notes.push("Converted with markit");
 						convertedText = converted.content;
 					} else {
@@ -859,7 +861,10 @@ async function renderUrl(
 			const ext = getExtensionHint(finalUrl, binary.contentDisposition) || extHint;
 			const converted = await convertWithMarkit(binary.buffer, ext, timeout, signal);
 			if (converted.ok) {
-				if (converted.content.trim().length > 50) {
+				// Any non-empty markit conversion is preferable to a raw-bytes
+				// fallback (upstream #5433): short documents like the W3C dummy.pdf
+				// ("Dummy PDF file", 14 chars) are legitimately converted text.
+				if (converted.content.trim().length > 0) {
 					notes.push("Converted with markit");
 					const output = finalizeOutput(converted.content);
 					return {

package/src/utils/markit.ts

@@ -1,6 +1,7 @@
 import { untilAborted } from "@sayknow-cli/utils";
 import type { Markit, StreamInfo } from "markit-ai";
 import { ToolAbortError } from "../tools/tool-errors";
+import { ensureMupdfWasmResolution } from "./mupdf-wasm";
 
 export interface MarkitConversionResult {
 	content: string;
@@ -18,6 +19,11 @@ let markit: () => Markit | Promise<Markit> = async () => {
 	return promise;
 };
 
+// Upstream #5433: mupdf's wasm asset is not reachable at the Emscripten
+// loader's default bunfs path in compiled binaries. Seed the embedded-asset
+// hook before any markit conversion (and therefore before any mupdf import).
+ensureMupdfWasmResolution();
+
 function normalizeExtension(extension: string): string {
 	const trimmed = extension.trim().toLowerCase();
 	if (!trimmed) return ".bin";
@@ -31,6 +37,22 @@ function normalizeError(error: unknown): string {
 	return "Conversion failed";
 }
 
+/**
+ * markit-ai's PDF converter swallows the real mupdf import failure behind a
+ * generic "Install it" message (upstream #5433). Re-run the import here so
+ * release diagnostics carry the actual module/asset/initialization error.
+ */
+async function describeConversionError(error: unknown): Promise<string> {
+	const base = normalizeError(error);
+	if (!base.includes("PDF support requires 'mupdf'")) return base;
+	try {
+		await import("mupdf");
+	} catch (cause) {
+		return `${base} (mupdf import failed: ${normalizeError(cause)})`;
+	}
+	return base;
+}
+
 async function runMarkitConversion<T>(task: (markit: Markit) => Promise<T>, signal?: AbortSignal): Promise<T> {
 	try {
 		const instance = await markit();
@@ -62,7 +84,7 @@ export async function convertFileWithMarkit(filePath: string, signal?: AbortSign
 		if (error instanceof ToolAbortError) {
 			throw error;
 		}
-		return { content: "", ok: false, error: normalizeError(error) };
+		return { content: "", ok: false, error: await describeConversionError(error) };
 	}
 }
 
@@ -84,6 +106,6 @@ export async function convertBufferWithMarkit(
 		if (error instanceof ToolAbortError) {
 			throw error;
 		}
-		return { content: "", ok: false, error: normalizeError(error) };
+		return { content: "", ok: false, error: await describeConversionError(error) };
 	}
 }

package/src/utils/mupdf-wasm.ts

@@ -0,0 +1,26 @@
+/**
+ * MuPDF wasm asset resolution inside compiled binaries (upstream #5433).
+ *
+ * `mupdf`'s Emscripten loader resolves `mupdf-wasm.wasm` relative to
+ * `import.meta.url` (or `scriptDirectory`). Inside a `bun build --compile`
+ * bunfs that path points at the bunfs root where the asset does not exist,
+ * so every mupdf import aborted with
+ * `ENOENT: ... /$bunfs/root/mupdf-wasm.wasm`.
+ *
+ * The wasm is embedded via `with { type: "file" }`, which lands it at a
+ * hashed bunfs path. MuPDF's top-level factory call reads
+ * `globalThis["$libmupdf_wasm_Module"]`, so seeding that config with a
+ * `locateFile` hook that returns the embedded asset path makes the loader
+ * read the wasm from the bunfs directly — no disk sidecar needed.
+ *
+ * This must run before the first `import("mupdf")` anywhere in the process.
+ */
+import mupdfWasmPath from "../../../../node_modules/mupdf/dist/mupdf-wasm.wasm" with { type: "file" };
+
+const MODULE_CONFIG_KEY = "$libmupdf_wasm_Module";
+
+export function ensureMupdfWasmResolution(): void {
+	const globalScope = globalThis as typeof globalThis & Record<string, unknown>;
+	if (globalScope[MODULE_CONFIG_KEY] !== undefined) return;
+	globalScope[MODULE_CONFIG_KEY] = { locateFile: () => String(mupdfWasmPath) };
+}