@gajae-code/coding-agent 0.11.2 → 0.11.4

package/src/utils/pasted-image-path.ts

@@ -1,14 +1,3 @@
-/**
- * Resolve pasted editor text to an image file path.
- *
- * Some terminal/clipboard integrations paste a temporary filesystem path after a
- * copied image is pasted into the editor (for example `/tmp/clipboard-...png`).
- * Only those recognized clipboard temp files are auto-attached and replaced with
- * an `[image N] source="/path"` reference so the model receives both the image
- * payload and the raw temp file path. Ordinary image paths remain literal prompt
- * text; users attach saved files explicitly with `@path/to/image.png`.
- */
-import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -16,12 +5,12 @@ import { fileURLToPath } from "node:url";
 const IMAGE_FILE_EXTENSION_PATTERN = /\.(?:png|jpe?g|gif|webp)$/i;
 const CLIPBOARD_TEMP_BASENAME_PATTERN = /^clipboard-\d{4}-\d{2}-\d{2}-\d{6}-[A-Za-z0-9-]+\.(?:png|jpe?g|gif|webp)$/i;
 
+export const MAX_PASTED_IMAGE_COUNT = 16;
+export const MAX_PASTED_IMAGE_PASTE_CHARACTERS = 1024 * 1024;
+export const MAX_PASTED_IMAGE_PATH_CHARACTERS = 32 * 1024;
+
 export interface DecodePastedPathOptions {
-	/**
-	 * Platform whose path semantics apply when decoding (shell unescaping,
-	 * `file://` drive letters / UNC hosts). Defaults to `process.platform`;
-	 * injectable so tests can pin the win32 contract from any host.
-	 */
+	/** Platform whose path and shell semantics apply. Defaults to `process.platform`. */
 	platform?: NodeJS.Platform;
 	/** Home directory for `~/` expansion. Defaults to `os.homedir()`. */
 	homedir?: string;
@@ -32,17 +21,30 @@ export interface ResolvePastedImagePathOptions extends DecodePastedPathOptions {
 	cwd?: string;
 }
 
-/**
- * Convert a `file://` URI to a filesystem path for the given platform, or
- * `undefined` when the URI is invalid.
- *
- * The production path (injected platform === host platform, always true
- * outside tests) delegates to Node's `fileURLToPath`. When tests inject a
- * foreign platform, a mirror of `fileURLToPath`'s rules is applied instead —
- * Bun (1.3) accepts but ignores `fileURLToPath`'s `windows` option, so the
- * native call cannot emulate a foreign platform.
- */
-function decodeFileUrl(candidate: string, platform: NodeJS.Platform): string | undefined {
+export type PastedImagePathParseResult =
+	| {
+			kind: "paths";
+			paths: string[];
+			requiresConfirmation: boolean;
+	  }
+	| {
+			kind: "too-many";
+			maxCandidates: number;
+	  };
+
+type PastedPathListState = "normal" | "escape" | "single-quote" | "double-quote";
+type EscapeReturnState = "normal" | "double-quote";
+
+type TokenizePastedPathsResult =
+	| { kind: "candidates"; candidates: string[] }
+	| { kind: "too-many"; maxCandidates: number; candidates: string[] }
+	| { kind: "invalid" };
+
+function pathApi(platform: NodeJS.Platform): typeof path.posix | typeof path.win32 {
+	return platform === "win32" ? path.win32 : path.posix;
+}
+
+function decodeFileUrl(candidate: string, platform: NodeJS.Platform, allowRemoteHost: boolean): string | undefined {
 	let url: URL;
 	try {
 		url = new URL(candidate);
@@ -50,6 +52,7 @@ function decodeFileUrl(candidate: string, platform: NodeJS.Platform): string | u
 		return undefined;
 	}
 	if (url.protocol !== "file:") return undefined;
+	if (!allowRemoteHost && url.hostname && url.hostname !== "localhost") return undefined;
 
 	if (platform === process.platform) {
 		try {
@@ -59,7 +62,6 @@ function decodeFileUrl(candidate: string, platform: NodeJS.Platform): string | u
 		}
 	}
 
-	// Foreign-platform mirror of fileURLToPath (tests only).
 	if (/%2f/i.test(url.pathname) || (platform === "win32" && /%5c/i.test(url.pathname))) return undefined;
 	let pathname: string;
 	try {
@@ -69,10 +71,8 @@ function decodeFileUrl(candidate: string, platform: NodeJS.Platform): string | u
 	}
 	if (platform === "win32") {
 		if (url.hostname && url.hostname !== "localhost") {
-			// UNC: file://server/share/img.png -> \\server\share\img.png
-			return `\\\\${url.hostname}${pathname.replaceAll("/", "\\")}`;
+			return allowRemoteHost ? `\\\\${url.hostname}${pathname.replaceAll("/", "\\")}` : undefined;
 		}
-		// Drive letter required: file:///C:/x -> C:\x
 		if (!/^\/[A-Za-z]:/.test(pathname)) return undefined;
 		return pathname.slice(1).replaceAll("/", "\\");
 	}
@@ -80,103 +80,228 @@ function decodeFileUrl(candidate: string, platform: NodeJS.Platform): string | u
 	return pathname;
 }
 
-/**
- * Decode pasted text into a filesystem path candidate. No filesystem access.
- *
- * Handles terminal drag-drop shell escaping (`\ `, `\(`, ...; skipped on
- * win32 where `\` is the path separator), quoted paths, `file://` URIs
- * (drive-letter, `file://localhost`, and UNC forms on win32), and `~/`
- * expansion. Returns `undefined` when the text is empty, spans multiple
- * lines, or is an invalid `file://` URI.
- */
-export function decodePastedPathCandidate(text: string, options?: DecodePastedPathOptions): string | undefined {
-	const platform = options?.platform ?? process.platform;
+function isRemoteWindowsPath(candidate: string): boolean {
+	return candidate.startsWith("\\\\") || candidate.startsWith("//");
+}
+
+function expandHome(candidate: string, options: DecodePastedPathOptions, platform: NodeJS.Platform): string {
+	if (!candidate.startsWith("~/")) return candidate;
+	return pathApi(platform).join(options.homedir ?? os.homedir(), candidate.slice(2));
+}
+
+/** Decode one pasted path candidate without filesystem access. */
+export function decodePastedPathCandidate(text: string, options: DecodePastedPathOptions = {}): string | undefined {
+	const platform = options.platform ?? process.platform;
 	let candidate = text.trim();
 	if (!candidate || /[\r\n]/.test(candidate)) return undefined;
 
-	// Quoted paths (some terminals quote instead of escaping).
 	if (
 		candidate.length >= 2 &&
 		(candidate.startsWith('"') || candidate.startsWith("'")) &&
-		candidate.endsWith(candidate[0])
+		candidate.endsWith(candidate[0] ?? "")
 	) {
 		candidate = candidate.slice(1, -1);
 	}
 
 	if (candidate.startsWith("file://")) {
-		const decoded = decodeFileUrl(candidate, platform);
+		const decoded = decodeFileUrl(candidate, platform, true);
 		if (decoded === undefined) return undefined;
 		candidate = decoded;
 	} else if (platform !== "win32") {
-		// Terminal drag-drop escapes shell-special characters (`\ `, `\(`, ...).
-		// Skipped on Windows where `\` is the path separator.
 		candidate = candidate.replace(/\\(.)/g, "$1");
 	}
+	return expandHome(candidate, options, platform);
+}
 
-	if (candidate.startsWith("~/")) {
-		candidate = path.join(options?.homedir ?? os.homedir(), candidate.slice(2));
-	}
+function isAsciiWhitespace(character: string): boolean {
+	return (
+		character === " " ||
+		character === "\t" ||
+		character === "\n" ||
+		character === "\r" ||
+		character === "\v" ||
+		character === "\f"
+	);
+}
 
+function decodeListToken(
+	candidate: string,
+	options: DecodePastedPathOptions,
+	platform: NodeJS.Platform,
+): string | undefined {
+	if (candidate.startsWith("file://")) {
+		const decoded = decodeFileUrl(candidate, platform, false);
+		if (decoded === undefined) return undefined;
+		candidate = decoded;
+	}
+	candidate = expandHome(candidate, options, platform);
+	if (platform === "win32" && isRemoteWindowsPath(candidate)) return undefined;
 	return candidate;
 }
 
-/**
- * Sniff the file header for a supported image signature (PNG, JPEG, GIF,
- * WEBP). Prevents existing non-image files with image-looking extensions
- * (e.g. a text file named `not-image.png`) from being treated as image
- * candidates — consuming such a paste would lose the raw path when the
- * image loader later rejects the content.
- */
-function hasSupportedImageMagic(filePath: string): boolean {
-	let fd: number;
-	try {
-		fd = fs.openSync(filePath, "r");
-	} catch {
-		return false;
-	}
-	try {
-		// Zero-filled; short reads leave trailing zeros so comparisons fail safely.
-		const header = Buffer.alloc(12);
-		fs.readSync(fd, header, 0, 12, 0);
-		if (header[0] === 0x89 && header[1] === 0x50 && header[2] === 0x4e && header[3] === 0x47) return true; // PNG
-		if (header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff) return true; // JPEG
-		const ascii6 = header.toString("latin1", 0, 6);
-		if (ascii6 === "GIF87a" || ascii6 === "GIF89a") return true; // GIF
-		if (header.toString("latin1", 0, 4) === "RIFF" && header.toString("latin1", 8, 12) === "WEBP") return true; // WEBP
-		return false;
-	} catch {
-		return false;
-	} finally {
-		fs.closeSync(fd);
+function tokenizePastedPathCandidates(
+	text: string,
+	options: DecodePastedPathOptions,
+	maxCandidates: number,
+): TokenizePastedPathsResult {
+	if (text.length > MAX_PASTED_IMAGE_PASTE_CHARACTERS) return { kind: "invalid" };
+	const platform = options.platform ?? process.platform;
+	const candidates: string[] = [];
+	let state: PastedPathListState = "normal";
+	let escapeReturnState: EscapeReturnState = "normal";
+	let candidate = "";
+	let candidateStarted = false;
+
+	const startCandidate = (): TokenizePastedPathsResult | undefined => {
+		if (candidateStarted) return undefined;
+		if (candidates.length >= maxCandidates) return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		candidateStarted = true;
+		return undefined;
+	};
+
+	const appendCandidate = (character: string): boolean => {
+		candidate += character;
+		return candidate.length <= MAX_PASTED_IMAGE_PATH_CHARACTERS;
+	};
+
+	const finishCandidate = (): TokenizePastedPathsResult | undefined => {
+		if (!candidateStarted) return undefined;
+		if (!candidate) return { kind: "invalid" };
+		if (candidates.length >= maxCandidates) return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		const decoded = decodeListToken(candidate, options, platform);
+		if (decoded === undefined) return { kind: "invalid" };
+		candidates.push(decoded);
+		candidate = "";
+		candidateStarted = false;
+		return undefined;
+	};
+
+	for (const character of text) {
+		if (state === "escape") {
+			if (!appendCandidate(character)) return { kind: "invalid" };
+			state = escapeReturnState;
+			continue;
+		}
+		if (state === "single-quote") {
+			if (character === "'") state = "normal";
+			else if (!appendCandidate(character)) return { kind: "invalid" };
+			continue;
+		}
+		if (state === "double-quote") {
+			if (character === '"') {
+				state = "normal";
+			} else if (character === "\\" && platform !== "win32") {
+				escapeReturnState = "double-quote";
+				state = "escape";
+			} else if (!appendCandidate(character)) {
+				return { kind: "invalid" };
+			}
+			continue;
+		}
+
+		if (isAsciiWhitespace(character)) {
+			const result = finishCandidate();
+			if (result) return result;
+		} else if (character === "'") {
+			const result = startCandidate();
+			if (result) return result;
+			state = "single-quote";
+		} else if (character === '"') {
+			const result = startCandidate();
+			if (result) return result;
+			state = "double-quote";
+		} else if (character === "\\" && platform !== "win32") {
+			const result = startCandidate();
+			if (result) return result;
+			escapeReturnState = "normal";
+			state = "escape";
+		} else {
+			const result = startCandidate();
+			if (result) return result;
+			if (!appendCandidate(character)) return { kind: "invalid" };
+		}
 	}
+
+	if (state !== "normal") return { kind: "invalid" };
+	const finalResult = finishCandidate();
+	if (finalResult) return finalResult;
+	return candidates.length === 0 ? { kind: "invalid" } : { kind: "candidates", candidates };
 }
 
-function isRecognizedClipboardTempPath(filePath: string): boolean {
-	const resolved = path.resolve(filePath);
-	const tempRoot = path.resolve(os.tmpdir());
-	if (resolved !== tempRoot && !resolved.startsWith(`${tempRoot}${path.sep}`)) return false;
-	return CLIPBOARD_TEMP_BASENAME_PATTERN.test(path.basename(resolved));
+/** Tokenize a bounded complete path list without filesystem access. */
+export function decodePastedPathCandidates(
+	text: string,
+	options: DecodePastedPathOptions = {},
+	maxCandidates = MAX_PASTED_IMAGE_COUNT,
+): string[] | undefined {
+	const result = tokenizePastedPathCandidates(text, options, maxCandidates);
+	return result.kind === "candidates" ? result.candidates : undefined;
 }
 
-/**
- * Returns the resolved path when the whole pasted text is a recognized clipboard
- * temp path to an existing image file, otherwise `undefined` (the paste is
- * inserted as text). Arbitrary saved image paths are not auto-attached here;
- * users attach them explicitly with `@path/to/image.png`.
- */
-export function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined {
+function resolveCandidate(
+	candidate: string,
+	options: ResolvePastedImagePathOptions,
+	platform: NodeJS.Platform,
+): string {
+	return pathApi(platform).resolve(options.cwd ?? process.cwd(), candidate);
+}
+
+function isRecognizedClipboardTempPath(filePath: string, platform: NodeJS.Platform): boolean {
+	const api = pathApi(platform);
+	const resolved = api.resolve(filePath);
+	const tempRoot = api.resolve(os.tmpdir());
+	if (resolved !== tempRoot && !resolved.startsWith(`${tempRoot}${api.sep}`)) return false;
+	return CLIPBOARD_TEMP_BASENAME_PATTERN.test(api.basename(resolved));
+}
+
+/** Resolve one recognized clipboard-temp image path lexically, before any filesystem access. */
+export function resolvePastedImagePath(text: string, options: ResolvePastedImagePathOptions = {}): string | undefined {
+	const platform = options.platform ?? process.platform;
 	const candidate = decodePastedPathCandidate(text, options);
 	if (!candidate || !IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
+	if (platform === "win32" && isRemoteWindowsPath(candidate)) return undefined;
+	const resolved = resolveCandidate(candidate, options, platform);
+	return isRecognizedClipboardTempPath(resolved, platform) ? resolved : undefined;
+}
 
-	const resolved = path.resolve(options?.cwd ?? process.cwd(), candidate);
-	if (!isRecognizedClipboardTempPath(resolved)) return undefined;
-	try {
-		if (!fs.statSync(resolved).isFile()) return undefined;
-	} catch {
-		return undefined;
+/**
+ * Parse a complete image path paste without filesystem access. A single path
+ * keeps the clipboard-temp-only policy; multi-path saved-image pastes require
+ * explicit confirmation before any path is opened.
+ */
+export function parsePastedImagePaths(
+	text: string,
+	options: ResolvePastedImagePathOptions = {},
+): PastedImagePathParseResult | undefined {
+	const platform = options.platform ?? process.platform;
+	const tokenized = tokenizePastedPathCandidates(text, options, MAX_PASTED_IMAGE_COUNT);
+	if (tokenized.kind === "too-many") {
+		if (
+			tokenized.candidates.length !== MAX_PASTED_IMAGE_COUNT ||
+			tokenized.candidates.some(
+				candidate =>
+					!IMAGE_FILE_EXTENSION_PATTERN.test(candidate) ||
+					(platform === "win32" && isRemoteWindowsPath(candidate)),
+			)
+		) {
+			return undefined;
+		}
+		return { kind: "too-many", maxCandidates: tokenized.maxCandidates };
+	}
+	if (tokenized.kind !== "candidates") return undefined;
+
+	if (tokenized.candidates.length === 1) {
+		const resolved = resolvePastedImagePath(text, options);
+		return resolved ? { kind: "paths", paths: [resolved], requiresConfirmation: false } : undefined;
+	}
+
+	const paths: string[] = [];
+	for (const candidate of tokenized.candidates) {
+		if (!IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
+		if (platform === "win32" && isRemoteWindowsPath(candidate)) return undefined;
+		paths.push(resolveCandidate(candidate, options, platform));
 	}
-	if (!hasSupportedImageMagic(resolved)) return undefined;
-	return resolved;
+	return { kind: "paths", paths, requiresConfirmation: true };
 }
 
 export function formatPastedImageReference(placeholder: string, imagePath: string): string {

package/src/web/scrapers/html-to-markdown.ts

@@ -0,0 +1,68 @@
+import type TurndownService from "turndown";
+
+/** Module-level Turndown instance — built lazily on first use. */
+let turndownPromise: Promise<TurndownService> | undefined;
+
+type TurndownListParent = {
+	nodeName: string;
+	getAttribute(name: string): string | null;
+	children: ArrayLike<unknown>;
+};
+
+function getTurndown(): Promise<TurndownService> {
+	turndownPromise ||= initTurndown();
+	return turndownPromise;
+}
+
+async function initTurndown(): Promise<TurndownService> {
+	const [{ default: TurndownService }, { gfm }] = await Promise.all([
+		import("turndown"),
+		import("turndown-plugin-gfm"),
+	]);
+	const turndown = new TurndownService({
+		headingStyle: "atx",
+		codeBlockStyle: "fenced",
+		bulletListMarker: "-",
+	});
+	turndown.use(gfm);
+	turndown.addRule("strikethrough", {
+		filter: ["del", "s", "strike"],
+		replacement(content) {
+			return `~~${content}~~`;
+		},
+	});
+	turndown.addRule("heading", {
+		filter: ["h1", "h2", "h3", "h4", "h5", "h6"],
+		replacement(content, node) {
+			const level = Number(node.nodeName.charAt(1));
+			const prefix = "#".repeat(level);
+			const cleaned = content.replace(/\\([.])/g, "$1").trim();
+			return `\n\n${prefix} ${cleaned}\n\n`;
+		},
+	});
+	turndown.addRule("listItem", {
+		filter: "li",
+		replacement(content, node, options) {
+			content = content.replace(/^\n+/, "").replace(/\n+$/, "\n").replace(/\n/gm, "\n  ");
+			const parent = node.parentNode as unknown as TurndownListParent | null;
+			let prefix = `${options.bulletListMarker} `;
+			if (parent?.nodeName === "OL") {
+				const start = parent.getAttribute("start");
+				const index = Array.prototype.indexOf.call(parent.children, node);
+				prefix = `${(start ? Number(start) : 1) + index}. `;
+			}
+			return prefix + content + (node.nextSibling ? "\n" : "");
+		},
+	});
+	return turndown;
+}
+
+/**
+ * Convert HTML to markdown using Turndown with GFM support.
+ * Strips script/style tags before conversion.
+ */
+export async function htmlToBasicMarkdown(html: string): Promise<string> {
+	const cleaned = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "");
+	const turndown = await getTurndown();
+	return turndown.turndown(cleaned).trim();
+}

package/src/web/scrapers/readthedocs.ts

@@ -60,7 +60,7 @@ export const handleReadTheDocs: SpecialHandler = async (
 		?.querySelectorAll(
 			".headerlink, .viewcode-link, nav, .sidebar, footer, .related, .sphinxsidebar, .toctree-wrapper",
 		)
-		.forEach((el: Element) => {
+		.forEach((el: { remove(): void }) => {
 			el.remove();
 		});
 

package/src/web/scrapers/types.ts

@@ -2,8 +2,6 @@
  * Shared types and utilities for web-fetch handlers
  */
 import { ptree } from "@gajae-code/utils";
-import type TurndownService from "turndown";
-
 import type { AgentStorage } from "../../session/agent-storage";
 import { ToolAbortError } from "../../tools/tool-errors";
 import type { AddressResolver } from "../insane/url-guard";
@@ -259,72 +257,7 @@ export async function loadPage(url: string, options: LoadPageOptions = {}): Prom
 	return { content: "", contentType: "", finalUrl: initialUrl, ok: false };
 }
 
-/** Module-level Turndown instance — built lazily on first use. */
-let turndownPromise: Promise<TurndownService> | undefined;
-
-type TurndownListParent = {
-	nodeName: string;
-	getAttribute(name: string): string | null;
-	children: ArrayLike<unknown>;
-};
-
-function getTurndown(): Promise<TurndownService> {
-	turndownPromise ||= initTurndown();
-	return turndownPromise;
-}
-
-async function initTurndown(): Promise<TurndownService> {
-	const [{ default: TurndownService }, { gfm }] = await Promise.all([
-		import("turndown"),
-		import("turndown-plugin-gfm"),
-	]);
-	const turndown = new TurndownService({
-		headingStyle: "atx",
-		codeBlockStyle: "fenced",
-		bulletListMarker: "-",
-	});
-	turndown.use(gfm);
-	turndown.addRule("strikethrough", {
-		filter: ["del", "s", "strike"],
-		replacement(content) {
-			return `~~${content}~~`;
-		},
-	});
-	turndown.addRule("heading", {
-		filter: ["h1", "h2", "h3", "h4", "h5", "h6"],
-		replacement(content, node) {
-			const level = Number(node.nodeName.charAt(1));
-			const prefix = "#".repeat(level);
-			const cleaned = content.replace(/\\([.])/g, "$1").trim();
-			return `\n\n${prefix} ${cleaned}\n\n`;
-		},
-	});
-	turndown.addRule("listItem", {
-		filter: "li",
-		replacement(content, node, options) {
-			content = content.replace(/^\n+/, "").replace(/\n+$/, "\n").replace(/\n/gm, "\n  ");
-			const parent = node.parentNode as unknown as TurndownListParent | null;
-			let prefix = `${options.bulletListMarker} `;
-			if (parent?.nodeName === "OL") {
-				const start = parent.getAttribute("start");
-				const index = Array.prototype.indexOf.call(parent.children, node);
-				prefix = `${(start ? Number(start) : 1) + index}. `;
-			}
-			return prefix + content + (node.nextSibling ? "\n" : "");
-		},
-	});
-	return turndown;
-}
-
-/**
- * Convert HTML to markdown using Turndown with GFM support.
- * Strips script/style tags before conversion.
- */
-export async function htmlToBasicMarkdown(html: string): Promise<string> {
-	const cleaned = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "");
-	const turndown = await getTurndown();
-	return turndown.turndown(cleaned).trim();
-}
+export { htmlToBasicMarkdown } from "./html-to-markdown";
 
 /**
  * Build a RenderResult from markdown content. Calls finalizeOutput internally.