@openclaw/diffs 2026.7.2-beta.7 → 2026.7.34

package/dist/index.js

@@ -6,22 +6,19 @@ import { z } from "zod";
 import fs, { constants } from "node:fs";
 import path from "node:path";
 import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
-import { isLoopbackHost } from "openclaw/plugin-sdk/ssrf-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import fs$1 from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import { gunzip, gzip } from "node:zlib";
 import { MAX_DATE_TIMESTAMP_MS, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
-import { safeEqualSecret, writeExternalFileWithinRoot } from "openclaw/plugin-sdk/security-runtime";
+import { root, safeEqualSecret, writeExternalFileWithinRoot } from "openclaw/plugin-sdk/security-runtime";
 import { optionalFiniteNumberSchema, stringEnum } from "openclaw/plugin-sdk/channel-actions";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { readFiniteNumberParam } from "openclaw/plugin-sdk/param-readers";
 import { Type } from "typebox";
 import { chromium } from "playwright-core";
 import { parsePatchFiles, resolveLanguage } from "@pierre/diffs";
-import { preloadDiffHTML } from "@pierre/diffs/ssr";
-import { escapeHtml } from "openclaw/plugin-sdk/text-utility-runtime";
+import { preloadFileDiff, preloadMultiFileDiff } from "@pierre/diffs/ssr";
 //#region extensions/diffs/src/types.ts
 const DIFF_LAYOUTS = ["unified", "split"];
 const DIFF_MODES = [
@@ -287,15 +284,15 @@ function normalizeTtlSeconds(ttlSeconds) {
 	return Math.min(Math.max(Math.floor(ttlSeconds), 1), 21600);
 }
 function resolveDiffImageRenderOptions(params) {
-	const format = normalizeFileFormat(params.fileFormat ?? params.defaults.fileFormat);
-	const qualityOverrideProvided = params.fileQuality !== void 0;
-	const qualityPreset = normalizeFileQuality$1(params.fileQuality ?? params.defaults.fileQuality);
+	const format = normalizeFileFormat(params.fileFormat ?? params.imageFormat ?? params.format ?? params.defaults.fileFormat);
+	const qualityOverrideProvided = params.fileQuality !== void 0 || params.imageQuality !== void 0;
+	const qualityPreset = normalizeFileQuality$1(params.fileQuality ?? params.imageQuality ?? params.defaults.fileQuality);
 	const profile = DEFAULT_IMAGE_QUALITY_PROFILES[qualityPreset];
 	return {
 		format,
 		qualityPreset,
-		scale: normalizeFileScale(params.fileScale, qualityOverrideProvided ? profile.scale : params.defaults.fileScale),
-		maxWidth: normalizeFileMaxWidth(params.fileMaxWidth, qualityOverrideProvided ? profile.maxWidth : params.defaults.fileMaxWidth),
+		scale: normalizeFileScale(params.fileScale ?? params.imageScale, qualityOverrideProvided ? profile.scale : params.defaults.fileScale),
+		maxWidth: normalizeFileMaxWidth(params.fileMaxWidth ?? params.imageMaxWidth, qualityOverrideProvided ? profile.maxWidth : params.defaults.fileMaxWidth),
 		maxPixels: profile.maxPixels
 	};
 }
@@ -474,20 +471,19 @@ function createDiffsHttpHandler(params) {
 			respondText(res, 404, "Diff not found");
 			return true;
 		}
+		if (!await params.store.getArtifact(id, token)) {
+			recordRemoteFailure(viewerFailureLimiter, access);
+			respondText(res, 404, "Diff not found or expired");
+			return true;
+		}
 		try {
-			const viewer = await params.store.readAuthorizedViewer(id, token);
-			if (!viewer) {
-				recordRemoteFailure(viewerFailureLimiter, access);
-				respondText(res, 404, "Diff not found or expired");
-				return true;
-			}
+			const html = await params.store.readHtml(id);
 			resetRemoteFailures(viewerFailureLimiter, access);
 			res.statusCode = 200;
 			setSharedHeaders(res, "text/html; charset=utf-8");
 			res.setHeader("content-security-policy", VIEWER_CONTENT_SECURITY_POLICY);
-			res.setHeader("content-length", String(viewer.html.byteLength));
 			if (req.method === "HEAD") res.end();
-			else res.end(Buffer.from(viewer.html));
+			else res.end(html);
 			return true;
 		} catch (error) {
 			recordRemoteFailure(viewerFailureLimiter, access);
@@ -544,7 +540,7 @@ function normalizeRemoteClientKey(remoteAddress) {
 	return normalized.startsWith("::ffff:") ? normalized.slice(7) : normalized;
 }
 function isLoopbackClientIp(clientIp) {
-	return isLoopbackHost(clientIp);
+	return clientIp === "127.0.0.1" || clientIp === "::1";
 }
 function hasProxyForwardingHints(req) {
 	const headers = req.headers ?? {};
@@ -627,177 +623,144 @@ const DIFFS_AGENT_GUIDANCE = [
 	"When you need to show edits as a real diff, prefer the `diffs` tool instead of writing a manual summary.",
 	"It accepts either `before` + `after` text or a unified `patch`.",
 	"Check `details.changed`: identical before/after input returns `false` without creating an artifact; rendered results return `true`.",
-	"`mode=view` returns `details.viewerUrl` for interactive viewing; `mode=file` returns `details.filePath`; `mode=both` returns both.",
-	"To send the rendered file, use an available file-sending tool to send `details.filePath` as an attachment.",
+	"`mode=view` returns `details.viewerUrl` for canvas use; `mode=file` returns `details.filePath`; `mode=both` returns both.",
+	"If you need to send the rendered file, use the `message` tool with `path` or `filePath`.",
 	"Include `path` when you know the filename, and omit presentation overrides unless needed."
 ].join("\n");
 //#endregion
 //#region extensions/diffs/src/store.ts
-const DEFAULT_TTL_MS = 1800 * 1e3;
-const MAX_TTL_MS = 360 * 60 * 1e3;
-const SWEEP_FALLBACK_AGE_MS = 1440 * 60 * 1e3;
-const DEFAULT_CLEANUP_INTERVAL_MS = 300 * 1e3;
-const MAX_DECODED_HTML_BYTES = 64 * 1024 * 1024;
-const ARTIFACT_ID_ATTEMPTS = 8;
+const DEFAULT_TTL_MS = 18e5;
+const MAX_TTL_MS = 216e5;
+const SWEEP_FALLBACK_AGE_MS = 864e5;
+const DEFAULT_CLEANUP_INTERVAL_MS = 3e5;
 const VIEWER_PREFIX = "/plugins/diffs/view";
-const EMPTY_BLOB = /* @__PURE__ */ new Uint8Array();
-function isBlobLimitError(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "PLUGIN_BLOB_LIMIT_EXCEEDED";
-}
 var DiffArtifactStore = class {
 	constructor(params) {
-		this.renderingFileIds = /* @__PURE__ */ new Set();
 		this.cleanupInFlight = null;
 		this.nextCleanupAt = 0;
 		this.rootDir = path.resolve(params.rootDir);
-		this.blobStore = params.blobStore;
 		this.logger = params.logger;
 		this.cleanupIntervalMs = params.cleanupIntervalMs === void 0 ? DEFAULT_CLEANUP_INTERVAL_MS : Math.max(0, Math.floor(params.cleanupIntervalMs));
 	}
 	async createArtifact(params) {
-		const html = Buffer.from(params.html, "utf8");
-		if (html.byteLength > MAX_DECODED_HTML_BYTES) throw new Error(`Diff viewer HTML exceeds ${MAX_DECODED_HTML_BYTES} bytes.`);
-		const compressedHtml = await gzipAsync(html);
+		await this.ensureRoot();
+		const id = crypto.randomBytes(10).toString("hex");
 		const token = crypto.randomBytes(24).toString("hex");
+		const artifactDir = this.artifactDir(id);
+		const htmlPath = path.join(artifactDir, "viewer.html");
 		const ttlMs = normalizeTtlMs$1(params.ttlMs);
-		const metadata = {
-			version: 1,
-			kind: "viewer",
-			encoding: "gzip",
-			tokenHash: hashToken(token),
+		const createdAt = /* @__PURE__ */ new Date();
+		const createdAtIso = createdAt.toISOString();
+		const expiresAt = resolveExpiresAtIso(createdAt.getTime(), ttlMs);
+		const meta = {
+			id,
+			token,
 			title: params.title,
 			inputKind: params.inputKind,
 			fileCount: params.fileCount,
-			decodedBytes: html.byteLength,
+			createdAt: createdAtIso,
+			expiresAt,
+			viewerPath: `${VIEWER_PREFIX}/${id}/${token}`,
+			htmlPath,
 			...params.context ? { context: params.context } : {}
 		};
-		const entry = await this.registerUnique(compressedHtml, metadata, ttlMs);
+		const root = await this.artifactRoot();
+		await root.mkdir(id);
+		await root.write(path.posix.join(id, "viewer.html"), params.html);
+		await this.writeMeta(meta);
 		this.scheduleCleanup();
-		return viewerEntryToMeta(entry, token);
+		return meta;
 	}
-	async readAuthorizedViewer(id, token) {
-		if (!DIFF_ARTIFACT_ID_PATTERN.test(id) || !DIFF_ARTIFACT_TOKEN_PATTERN.test(token)) return null;
-		const entry = await this.blobStore.lookup(id);
-		if (!entry) {
-			const expired = await this.blobStore.deleteExpiredKey(id);
-			if (expired) await this.deleteExpiredFile(expired);
+	async getArtifact(id, token) {
+		const meta = await this.readMeta(id);
+		if (!meta) return null;
+		if (!safeEqualSecret(token, meta.token)) return null;
+		if (isExpired(meta)) {
+			await this.deleteArtifact(id);
 			return null;
 		}
-		if (!isViewerMetadata(entry.metadata)) return null;
-		if (!safeEqualSecret(hashToken(token), entry.metadata.tokenHash)) return null;
-		const html = await gunzipAsync(entry.bytes, MAX_DECODED_HTML_BYTES);
-		if (html.byteLength !== entry.metadata.decodedBytes) throw new Error(`Diff artifact ${id} decoded size does not match its metadata.`);
-		return {
-			artifact: viewerEntryToMeta(entry, token),
-			html
+		return meta;
+	}
+	async readHtml(id) {
+		const meta = await this.readMeta(id);
+		if (!meta) throw new Error(`Diff artifact not found: ${id}`);
+		const htmlPath = this.normalizeStoredPath(meta.htmlPath, "htmlPath");
+		return await (await this.artifactRoot()).readText(this.relativeStoredPath(htmlPath));
+	}
+	async updateFilePath(id, filePath) {
+		const meta = await this.readMeta(id);
+		if (!meta) throw new Error(`Diff artifact not found: ${id}`);
+		const normalizedFilePath = this.normalizeStoredPath(filePath, "filePath");
+		const next = {
+			...meta,
+			filePath: normalizedFilePath,
+			imagePath: normalizedFilePath
 		};
+		await this.writeMeta(next);
+		return next;
+	}
+	async updateImagePath(id, imagePath) {
+		return this.updateFilePath(id, imagePath);
+	}
+	allocateFilePath(id, format = "png") {
+		return path.join(this.artifactDir(id), `preview.${format}`);
 	}
 	async createStandaloneFileArtifact(params = {}) {
+		await this.ensureRoot();
+		const id = crypto.randomBytes(10).toString("hex");
+		const artifactDir = this.artifactDir(id);
 		const format = params.format ?? "png";
+		const filePath = path.join(artifactDir, `preview.${format}`);
 		const ttlMs = normalizeTtlMs$1(params.ttlMs);
-		const metadata = {
-			version: 1,
-			kind: "rendered_file",
-			format,
+		const createdAt = /* @__PURE__ */ new Date();
+		const meta = {
+			kind: "standalone_file",
+			id,
+			createdAt: createdAt.toISOString(),
+			expiresAt: resolveExpiresAtIso(createdAt.getTime(), ttlMs),
+			filePath: this.normalizeStoredPath(filePath, "filePath"),
 			...params.context ? { context: params.context } : {}
 		};
-		for (let attempt = 0; attempt < ARTIFACT_ID_ATTEMPTS; attempt += 1) {
-			const id = crypto.randomBytes(10).toString("hex");
-			if (!await this.registerIfAbsentWithCleanup(id, EMPTY_BLOB, metadata, ttlMs)) continue;
-			const artifactDir = this.artifactDir(id);
-			try {
-				await fs$1.mkdir(this.rootDir, { recursive: true });
-				await fs$1.mkdir(artifactDir);
-				const entry = await this.blobStore.lookup(id);
-				if (!entry || !isRenderedFileMetadata(entry.metadata)) throw new Error(`Diff file artifact expired before materialization: ${id}`);
-				this.renderingFileIds.add(id);
-				this.scheduleCleanup();
-				return {
-					id,
-					filePath: path.join(artifactDir, `preview.${format}`),
-					expiresAt: resolveEntryExpiresAt(entry),
-					...params.context ? { context: params.context } : {}
-				};
-			} catch (error) {
-				await this.blobStore.delete(id).catch(() => false);
-				await fs$1.rm(artifactDir, {
-					recursive: true,
-					force: true
-				}).catch(() => {});
-				if (isFileExists(error)) continue;
-				throw error;
-			}
-		}
-		throw new Error("Failed to allocate a unique diff file artifact id.");
-	}
-	async completeFileArtifact(id) {
-		try {
-			const entry = await this.blobStore.lookup(id);
-			if (!entry || !isRenderedFileMetadata(entry.metadata)) {
-				await fs$1.rm(this.artifactDir(id), {
-					recursive: true,
-					force: true
-				}).catch(() => {});
-				throw new Error(`Diff file artifact expired during rendering: ${id}`);
-			}
-		} finally {
-			this.renderingFileIds.delete(id);
-		}
+		await (await this.artifactRoot()).mkdir(id);
+		await this.writeStandaloneMeta(meta);
+		this.scheduleCleanup();
+		return {
+			id,
+			filePath: meta.filePath,
+			expiresAt: meta.expiresAt,
+			...meta.context ? { context: meta.context } : {}
+		};
 	}
-	async deleteFileArtifact(id) {
-		this.renderingFileIds.delete(id);
-		await this.blobStore.delete(id).catch(() => false);
-		await fs$1.rm(this.artifactDir(id), {
-			recursive: true,
-			force: true
-		}).catch(() => {});
+	allocateImagePath(id, format = "png") {
+		return this.allocateFilePath(id, format);
 	}
 	scheduleCleanup() {
 		this.maybeCleanupExpired();
 	}
 	async cleanupExpired() {
-		const expired = await this.blobStore.deleteExpired();
-		await Promise.all(expired.map(async (entry) => await this.deleteExpiredFile(entry)));
-		const entries = await fs$1.readdir(this.rootDir, { withFileTypes: true }).catch((error) => {
-			if (isFileNotFound(error)) return [];
-			throw error;
-		});
+		const entries = await (await this.artifactRoot()).list("", { withFileTypes: true }).catch(() => []);
 		const now = Date.now();
-		await Promise.all(entries.filter((entry) => entry.isDirectory() && DIFF_ARTIFACT_ID_PATTERN.test(entry.name)).map(async (entry) => {
-			if (this.renderingFileIds.has(entry.name) || await this.blobStore.lookup(entry.name)) return;
-			const artifactDir = this.artifactDir(entry.name);
-			const stats = await fs$1.stat(artifactDir).catch(() => null);
-			if (stats && now - stats.mtimeMs > SWEEP_FALLBACK_AGE_MS) await fs$1.rm(artifactDir, {
-				recursive: true,
-				force: true
-			}).catch(() => {});
+		await Promise.all(entries.filter((entry) => entry.isDirectory).map(async (entry) => {
+			const id = entry.name;
+			const meta = await this.readMeta(id);
+			if (meta) {
+				if (isExpired(meta)) await this.deleteArtifact(id);
+				return;
+			}
+			const standaloneMeta = await this.readStandaloneMeta(id);
+			if (standaloneMeta) {
+				if (isExpired(standaloneMeta)) await this.deleteArtifact(id);
+				return;
+			}
+			if (now - entry.mtimeMs > SWEEP_FALLBACK_AGE_MS) await this.deleteArtifact(id);
 		}));
 	}
-	async registerUnique(bytes, metadata, ttlMs) {
-		for (let attempt = 0; attempt < ARTIFACT_ID_ATTEMPTS; attempt += 1) {
-			const id = crypto.randomBytes(10).toString("hex");
-			if (!await this.registerIfAbsentWithCleanup(id, bytes, metadata, ttlMs)) continue;
-			const entry = await this.blobStore.lookup(id);
-			if (entry) return entry;
-		}
-		throw new Error("Failed to allocate a unique diff artifact id.");
-	}
-	async registerIfAbsentWithCleanup(id, bytes, metadata, ttlMs) {
-		try {
-			return await this.blobStore.registerIfAbsent(id, bytes, metadata, { ttlMs });
-		} catch (error) {
-			if (!isBlobLimitError(error)) throw error;
-			await this.cleanupExpired();
-			return await this.blobStore.registerIfAbsent(id, bytes, metadata, { ttlMs });
-		}
+	async ensureRoot() {
+		await fs$1.mkdir(this.rootDir, { recursive: true });
 	}
-	async deleteExpiredFile(entry) {
-		if (!isRenderedFileMetadata(entry.metadata) || this.renderingFileIds.has(entry.key)) return;
-		if (await this.blobStore.lookup(entry.key)) return;
-		await fs$1.rm(this.artifactDir(entry.key), {
-			recursive: true,
-			force: true
-		}).catch(() => {});
+	async artifactRoot() {
+		await this.ensureRoot();
+		return await root(this.rootDir);
 	}
 	maybeCleanupExpired() {
 		const now = Date.now();
@@ -812,85 +775,104 @@ var DiffArtifactStore = class {
 		this.cleanupInFlight = cleanupPromise;
 	}
 	artifactDir(id) {
-		if (!DIFF_ARTIFACT_ID_PATTERN.test(id)) throw new Error(`Invalid diff artifact id: ${id}`);
-		return path.join(this.rootDir, id);
+		return this.resolveWithinRoot(id);
+	}
+	async writeMeta(meta) {
+		await this.writeJsonMeta(meta.id, "meta.json", meta);
+	}
+	async readMeta(id) {
+		const parsed = await this.readJsonMeta(id, "meta.json", "diff artifact");
+		if (!parsed) return null;
+		return parsed;
+	}
+	async writeStandaloneMeta(meta) {
+		await this.writeJsonMeta(meta.id, "file-meta.json", meta);
+	}
+	async readStandaloneMeta(id) {
+		const parsed = await this.readJsonMeta(id, "file-meta.json", "standalone diff");
+		if (!parsed) return null;
+		try {
+			const value = parsed;
+			if (value.kind !== "standalone_file" || typeof value.id !== "string" || typeof value.createdAt !== "string" || typeof value.expiresAt !== "string" || typeof value.filePath !== "string") return null;
+			return {
+				kind: value.kind,
+				id: value.id,
+				createdAt: value.createdAt,
+				expiresAt: value.expiresAt,
+				filePath: this.normalizeStoredPath(value.filePath, "filePath"),
+				...value.context ? { context: normalizeArtifactContext(value.context) } : {}
+			};
+		} catch (error) {
+			this.logger?.warn(`Failed to normalize standalone diff metadata for ${id}: ${String(error)}`);
+			return null;
+		}
+	}
+	async writeJsonMeta(id, fileName, data) {
+		await (await this.artifactRoot()).writeJson(path.posix.join(id, fileName), data, { space: 2 });
+	}
+	async readJsonMeta(id, fileName, context) {
+		try {
+			const raw = await (await this.artifactRoot()).readText(path.posix.join(id, fileName));
+			return JSON.parse(raw);
+		} catch (error) {
+			if (isFileNotFound(error)) return null;
+			this.logger?.warn(`Failed to read ${context} metadata for ${id}: ${String(error)}`);
+			return null;
+		}
+	}
+	async deleteArtifact(id) {
+		await fs$1.rm(this.artifactDir(id), {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	}
+	resolveWithinRoot(...parts) {
+		const candidate = path.resolve(this.rootDir, ...parts);
+		this.assertWithinRoot(candidate);
+		return candidate;
+	}
+	normalizeStoredPath(rawPath, label) {
+		const candidate = path.isAbsolute(rawPath) ? path.resolve(rawPath) : path.resolve(this.rootDir, rawPath);
+		this.assertWithinRoot(candidate, label);
+		return candidate;
+	}
+	relativeStoredPath(storedPath) {
+		return path.relative(this.rootDir, this.normalizeStoredPath(storedPath, "path")).split(path.sep).join(path.posix.sep);
+	}
+	assertWithinRoot(candidate, label = "path") {
+		const relative = path.relative(this.rootDir, candidate);
+		if (relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative)) return;
+		throw new Error(`Diff artifact ${label} escapes store root: ${candidate}`);
 	}
 };
-function viewerEntryToMeta(entry, token) {
-	if (!isViewerMetadata(entry.metadata)) throw new Error(`Diff artifact ${entry.key} is not a viewer.`);
-	return {
-		id: entry.key,
-		token,
-		createdAt: timestampMsToIsoString(entry.createdAt) ?? "1970-01-01T00:00:00.000Z",
-		expiresAt: resolveEntryExpiresAt(entry),
-		title: entry.metadata.title,
-		inputKind: entry.metadata.inputKind,
-		fileCount: entry.metadata.fileCount,
-		viewerPath: `${VIEWER_PREFIX}/${entry.key}/${token}`,
-		...entry.metadata.context ? { context: entry.metadata.context } : {}
-	};
-}
-function resolveEntryExpiresAt(entry) {
-	return timestampMsToIsoString(entry.expiresAt ?? MAX_DATE_TIMESTAMP_MS) ?? timestampMsToIsoString(MAX_DATE_TIMESTAMP_MS) ?? "1970-01-01T00:00:00.000Z";
-}
-function hashToken(token) {
-	return crypto.createHash("sha256").update(token).digest("hex");
-}
 function normalizeTtlMs$1(value) {
-	const rounded = value === void 0 || !Number.isFinite(value) ? 0 : Math.floor(value);
-	const requestedTtlMs = rounded > 0 ? rounded : DEFAULT_TTL_MS;
-	const remainingDateRangeMs = Math.floor(MAX_DATE_TIMESTAMP_MS - Date.now());
-	return Math.min(requestedTtlMs, MAX_TTL_MS, Math.max(1, remainingDateRangeMs));
-}
-function isViewerMetadata(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	const metadata = value;
-	return metadata.version === 1 && metadata.kind === "viewer" && metadata.encoding === "gzip" && typeof metadata.tokenHash === "string" && /^[0-9a-f]{64}$/u.test(metadata.tokenHash) && typeof metadata.title === "string" && (metadata.inputKind === "before_after" || metadata.inputKind === "patch") && Number.isSafeInteger(metadata.fileCount) && typeof metadata.fileCount === "number" && metadata.fileCount >= 0 && Number.isSafeInteger(metadata.decodedBytes) && typeof metadata.decodedBytes === "number" && metadata.decodedBytes >= 0 && metadata.decodedBytes <= MAX_DECODED_HTML_BYTES && isArtifactContext(metadata.context);
-}
-function isRenderedFileMetadata(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	const metadata = value;
-	return metadata.version === 1 && metadata.kind === "rendered_file" && (metadata.format === "png" || metadata.format === "pdf") && isArtifactContext(metadata.context);
-}
-function isArtifactContext(value) {
-	if (value === void 0) return true;
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	const context = value;
-	const allowed = /* @__PURE__ */ new Set([
-		"agentId",
-		"sessionId",
-		"messageChannel",
-		"agentAccountId"
-	]);
-	return Object.entries(context).every(([key, entry]) => allowed.has(key) && (entry === void 0 || typeof entry === "string"));
-}
-async function gzipAsync(input) {
-	return await new Promise((resolve, reject) => {
-		gzip(input, (error, result) => {
-			if (error) {
-				reject(error);
-				return;
-			}
-			resolve(result);
-		});
-	});
+	if (!Number.isFinite(value) || value === void 0) return DEFAULT_TTL_MS;
+	const rounded = Math.floor(value);
+	if (rounded <= 0) return DEFAULT_TTL_MS;
+	return Math.min(rounded, MAX_TTL_MS);
 }
-async function gunzipAsync(input, maxOutputLength) {
-	return await new Promise((resolve, reject) => {
-		gunzip(input, { maxOutputLength }, (error, result) => {
-			if (error) {
-				reject(error);
-				return;
-			}
-			resolve(result);
-		});
-	});
+function resolveExpiresAtIso(createdAtMs, ttlMs) {
+	return timestampMsToIsoString(createdAtMs + ttlMs) ?? timestampMsToIsoString(MAX_DATE_TIMESTAMP_MS) ?? "1970-01-01T00:00:00.000Z";
 }
-function isFileExists(error) {
-	return error instanceof Error && "code" in error && error.code === "EEXIST";
+function isExpired(meta) {
+	const expiresAt = Date.parse(meta.expiresAt);
+	if (!Number.isFinite(expiresAt)) return true;
+	return Date.now() >= expiresAt;
 }
 function isFileNotFound(error) {
-	return error instanceof Error && "code" in error && error.code === "ENOENT";
+	const code = error instanceof Error && "code" in error ? error.code : void 0;
+	return code === "ENOENT" || code === "not-found";
+}
+function normalizeArtifactContext(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const raw = value;
+	const context = {
+		agentId: normalizeOptionalString(raw.agentId),
+		sessionId: normalizeOptionalString(raw.sessionId),
+		messageChannel: normalizeOptionalString(raw.messageChannel),
+		agentAccountId: normalizeOptionalString(raw.agentAccountId)
+	};
+	return Object.values(context).some((entry) => entry !== void 0) ? context : void 0;
 }
 //#endregion
 //#region extensions/diffs/src/browser.ts
@@ -1500,6 +1482,11 @@ const bundledLanguagesBase = Object.fromEntries(bundledLanguagesInfo.map((langua
 function getBundledLanguageAliases(language) {
 	return "aliases" in language ? language.aliases : [];
 }
+const bundledLanguagesAlias = Object.fromEntries(bundledLanguagesInfo.flatMap((language) => getBundledLanguageAliases(language).map((alias) => [alias, language.import])));
+({
+	...bundledLanguagesBase,
+	...bundledLanguagesAlias
+});
 //#endregion
 //#region extensions/diffs/src/language-hints.ts
 const BASE_DIFF_VIEWER_LANGUAGE_HINTS = [
@@ -1603,6 +1590,9 @@ var DiffRenderInputError = class extends Error {
 function escapeCssString(value) {
 	return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
 }
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
 function escapeJsonScript(value) {
 	return JSON.stringify(value).replaceAll("<", "\\u003c");
 }
@@ -2018,18 +2008,19 @@ async function renderBeforeAfterDiff(input, options, target) {
 	});
 	const preloadOptions = viewerOptions ?? imageOptions;
 	if (!preloadOptions) throw new Error(`Unsupported diff render target: ${target}`);
-	const normalizedPayload = await normalizeDiffViewerPayloadLanguages({
-		prerenderedHTML: await preloadDiffHTMLWithFallback({
-			oldFile,
-			newFile,
-			options: preloadOptions
-		}),
+	const preloadResult = await preloadMultiFileDiffWithFallback({
 		oldFile,
 		newFile,
+		options: preloadOptions
+	});
+	const normalizedPayload = await normalizeDiffViewerPayloadLanguages({
+		prerenderedHTML: preloadResult.prerenderedHTML,
+		oldFile: preloadResult.oldFile,
+		newFile: preloadResult.newFile,
 		options: preloadOptions,
 		langs: collectDiffPayloadLanguageHints({
-			oldFile,
-			newFile
+			oldFile: preloadResult.oldFile,
+			newFile: preloadResult.newFile
 		})
 	}, { languagePackAvailable });
 	const viewerPayload = viewerOptions ? {
@@ -2072,14 +2063,15 @@ async function renderPatchDiff(input, options, target) {
 		stats: computeFileDiffStats(fileDiff)
 	}));
 	const sections = await Promise.all(files.map(async (fileDiff, index) => {
-		const normalizedPayload = await normalizeDiffViewerPayloadLanguages({
-			prerenderedHTML: await preloadDiffHTMLWithFallback({
-				fileDiff,
-				options: preloadOptions
-			}),
+		const preloadResult = await preloadFileDiffWithFallback({
 			fileDiff,
+			options: preloadOptions
+		});
+		const normalizedPayload = await normalizeDiffViewerPayloadLanguages({
+			prerenderedHTML: preloadResult.prerenderedHTML,
+			fileDiff: preloadResult.fileDiff,
 			options: preloadOptions,
-			langs: collectDiffPayloadLanguageHints({ fileDiff })
+			langs: collectDiffPayloadLanguageHints({ fileDiff: preloadResult.fileDiff })
 		}, { languagePackAvailable });
 		const viewerPayload = viewerOptions ? {
 			...normalizedPayload,
@@ -2142,18 +2134,33 @@ async function renderDiffDocument(input, options, target = "both") {
 function shouldFallbackToClientHydration(error) {
 	return error instanceof TypeError && error.message.includes("needs an import attribute of \"type: json\"");
 }
-async function preloadDiffHTMLWithFallback(params) {
+async function preloadFileDiffWithFallback(params) {
 	try {
-		return await preloadDiffHTML(params);
+		return await preloadFileDiff(params);
 	} catch (error) {
 		if (!shouldFallbackToClientHydration(error)) throw error;
-		return "";
+		return {
+			fileDiff: params.fileDiff,
+			prerenderedHTML: ""
+		};
+	}
+}
+async function preloadMultiFileDiffWithFallback(params) {
+	try {
+		return await preloadMultiFileDiff(params);
+	} catch (error) {
+		if (!shouldFallbackToClientHydration(error)) throw error;
+		return {
+			oldFile: params.oldFile,
+			newFile: params.newFile,
+			prerenderedHTML: ""
+		};
 	}
 }
 //#endregion
 //#region extensions/diffs/src/tool.ts
-const MAX_BEFORE_AFTER_BYTES = 512 * 1024;
-const MAX_PATCH_BYTES = 2 * 1024 * 1024;
+const MAX_BEFORE_AFTER_BYTES = 524288;
+const MAX_PATCH_BYTES = 2097152;
 const MAX_TITLE_BYTES = 1024;
 const MAX_PATH_BYTES = 2048;
 const MAX_LANG_BYTES = 128;
@@ -2192,6 +2199,30 @@ const DiffsToolSchema = Type.Object({
 		minimum: 640,
 		maximum: 2400
 	}),
+	/** @deprecated Use fileQuality. */
+	imageQuality: Type.Optional(stringEnum(DIFF_IMAGE_QUALITY_PRESETS, {
+		description: "Deprecated alias for fileQuality.",
+		deprecated: true
+	})),
+	/** @deprecated Use fileFormat. */
+	imageFormat: Type.Optional(stringEnum(DIFF_OUTPUT_FORMATS, {
+		description: "Deprecated alias for fileFormat.",
+		deprecated: true
+	})),
+	/** @deprecated Use fileScale. */
+	imageScale: optionalFiniteNumberSchema({
+		description: "Deprecated alias for fileScale.",
+		deprecated: true,
+		minimum: 1,
+		maximum: 4
+	}),
+	/** @deprecated Use fileMaxWidth. */
+	imageMaxWidth: optionalFiniteNumberSchema({
+		description: "Deprecated alias for fileMaxWidth.",
+		deprecated: true,
+		minimum: 640,
+		maximum: 2400
+	}),
 	expandUnchanged: Type.Optional(Type.Boolean({ description: "Expand unchanged sections instead of collapsing them." })),
 	ttlSeconds: optionalFiniteNumberSchema({
 		description: "Artifact lifetime in seconds. Default: 1800. Maximum: 21600.",
@@ -2204,7 +2235,7 @@ function createDiffsTool(params) {
 	return {
 		name: "diffs",
 		label: "Diffs",
-		description: "Create a read-only diff viewer from before/after text or a unified patch. Returns a gateway viewer URL for interactive viewing and can also render the same diff to a PNG or PDF.",
+		description: "Create a read-only diff viewer from before/after text or a unified patch. Returns a gateway viewer URL for canvas use and can also render the same diff to a PNG or PDF.",
 		parameters: DiffsToolSchema,
 		execute: async (_toolCallId, rawParams) => {
 			const toolParams = rawParams;
@@ -2226,13 +2257,13 @@ function createDiffsTool(params) {
 			const layout = normalizeLayout(toolParams.layout, params.defaults.layout);
 			const expandUnchanged = toolParams.expandUnchanged === true;
 			const ttlSeconds = readFiniteNumberParam(rawRecord, "ttlSeconds") ?? params.defaults.ttlSeconds;
-			const fileScale = readFiniteNumberParam(rawRecord, "fileScale");
-			const fileMaxWidth = readFiniteNumberParam(rawRecord, "fileMaxWidth");
+			const fileScale = readFiniteNumberParam(rawRecord, "fileScale") ?? readFiniteNumberParam(rawRecord, "imageScale");
+			const fileMaxWidth = readFiniteNumberParam(rawRecord, "fileMaxWidth") ?? readFiniteNumberParam(rawRecord, "imageMaxWidth");
 			const ttlMs = normalizeTtlMs(ttlSeconds);
 			const image = resolveDiffImageRenderOptions({
 				defaults: params.defaults,
-				fileFormat: normalizeOutputFormat(toolParams.fileFormat),
-				fileQuality: normalizeFileQuality(toolParams.fileQuality),
+				fileFormat: normalizeOutputFormat(toolParams.fileFormat ?? toolParams.imageFormat ?? toolParams.format),
+				fileQuality: normalizeFileQuality(toolParams.fileQuality ?? toolParams.imageQuality),
 				fileScale,
 				fileMaxWidth
 			});
@@ -2321,12 +2352,12 @@ function createDiffsTool(params) {
 				const artifactFile = await renderDiffArtifactFile({
 					screenshotter,
 					store: params.store,
+					artifactId: artifact.id,
 					html: requireRenderedHtml(rendered.imageHtml, "image"),
 					theme,
-					image,
-					ttlMs,
-					context: artifactContext
+					image
 				});
+				await params.store.updateFilePath(artifact.id, artifactFile.path);
 				return {
 					content: [{
 						type: "text",
@@ -2352,7 +2383,8 @@ function createDiffsTool(params) {
 						}],
 						details: {
 							...baseDetails,
-							fileError: errorMessage
+							fileError: errorMessage,
+							imageError: errorMessage
 						}
 					};
 				}
@@ -2383,59 +2415,55 @@ function buildArtifactDetails(params) {
 	return {
 		...params.baseDetails,
 		filePath: params.artifactFile.path,
+		imagePath: params.artifactFile.path,
 		path: params.artifactFile.path,
 		fileBytes: params.artifactFile.bytes,
+		imageBytes: params.artifactFile.bytes,
+		format: params.image.format,
 		fileFormat: params.image.format,
 		fileQuality: params.image.qualityPreset,
+		imageQuality: params.image.qualityPreset,
 		fileScale: params.image.scale,
-		fileMaxWidth: params.image.maxWidth
+		imageScale: params.image.scale,
+		fileMaxWidth: params.image.maxWidth,
+		imageMaxWidth: params.image.maxWidth
 	};
 }
 function buildFileArtifactMessage(params) {
 	const lines = params.viewerUrl ? [`Diff viewer: ${params.viewerUrl}`] : [];
 	lines.push(`Diff ${params.format.toUpperCase()} generated at: ${params.filePath}`);
-	lines.push("To send this file, use an available file-sending tool to send it as an attachment.");
+	lines.push("Use the `message` tool with `path` or `filePath` to send this file.");
 	return lines.join("\n");
 }
 async function renderDiffArtifactFile(params) {
-	const fileArtifact = await params.store.createStandaloneFileArtifact({
+	const standaloneArtifact = params.artifactId ? void 0 : await params.store.createStandaloneFileArtifact({
 		format: params.image.format,
 		ttlMs: params.ttlMs,
 		context: params.context
 	});
-	try {
-		await params.screenshotter.screenshotHtml({
-			html: params.html,
-			outputPath: fileArtifact.filePath,
-			theme: params.theme,
-			image: params.image
-		});
-		const stats = await fs$1.stat(fileArtifact.filePath);
-		await params.store.completeFileArtifact(fileArtifact.id);
-		return {
-			path: fileArtifact.filePath,
-			bytes: stats.size,
-			artifactId: fileArtifact.id,
-			expiresAt: fileArtifact.expiresAt
-		};
-	} catch (error) {
-		await params.store.deleteFileArtifact(fileArtifact.id);
-		throw error;
-	}
+	const outputPath = params.artifactId ? params.store.allocateFilePath(params.artifactId, params.image.format) : standaloneArtifact.filePath;
+	await params.screenshotter.screenshotHtml({
+		html: params.html,
+		outputPath,
+		theme: params.theme,
+		image: params.image
+	});
+	return {
+		path: outputPath,
+		bytes: (await fs$1.stat(outputPath)).size,
+		...standaloneArtifact?.id ? { artifactId: standaloneArtifact.id } : {},
+		...standaloneArtifact?.expiresAt ? { expiresAt: standaloneArtifact.expiresAt } : {}
+	};
 }
 function buildArtifactContext(context) {
 	if (!context) return;
-	const agentId = normalizeOptionalString(context.agentId);
-	const sessionId = normalizeOptionalString(context.sessionId);
-	const messageChannel = normalizeOptionalString(context.messageChannel);
-	const agentAccountId = normalizeOptionalString(context.agentAccountId);
 	const artifactContext = {
-		...agentId ? { agentId } : {},
-		...sessionId ? { sessionId } : {},
-		...messageChannel ? { messageChannel } : {},
-		...agentAccountId ? { agentAccountId } : {}
+		agentId: normalizeOptionalString(context.agentId),
+		sessionId: normalizeOptionalString(context.sessionId),
+		messageChannel: normalizeOptionalString(context.messageChannel),
+		agentAccountId: normalizeOptionalString(context.agentAccountId)
 	};
-	return Object.keys(artifactContext).length > 0 ? artifactContext : void 0;
+	return Object.values(artifactContext).some((value) => value !== void 0) ? artifactContext : void 0;
 }
 function normalizeDiffInput(params) {
 	const patch = params.patch?.trim();
@@ -2505,20 +2533,9 @@ var PluginToolInputError = class extends Error {
 //#endregion
 //#region extensions/diffs/src/plugin.ts
 const DIFFS_LANGUAGE_PACK_PLUGIN_ID = "diffs-language-pack";
-const DIFF_ARTIFACT_NAMESPACE = "diff-artifacts";
-const DIFF_ARTIFACT_MAX_ENTRIES = 2048;
-const DIFF_ARTIFACT_MAX_BYTES_PER_ENTRY = 32 * 1024 * 1024;
-const DIFF_ARTIFACT_MAX_BYTES_PER_NAMESPACE = 256 * 1024 * 1024;
 function registerDiffsPlugin(api) {
 	const store = new DiffArtifactStore({
 		rootDir: path.join(resolvePreferredOpenClawTmpDir(), "openclaw-diffs"),
-		blobStore: api.runtime.state.openBlobStore({
-			namespace: DIFF_ARTIFACT_NAMESPACE,
-			maxEntries: DIFF_ARTIFACT_MAX_ENTRIES,
-			maxBytesPerEntry: DIFF_ARTIFACT_MAX_BYTES_PER_ENTRY,
-			maxBytesPerNamespace: DIFF_ARTIFACT_MAX_BYTES_PER_NAMESPACE,
-			overflowPolicy: "reject-new"
-		}),
 		logger: api.logger
 	});
 	const resolveCurrentPluginConfig = () => resolveLivePluginConfigObject(api.runtime.config?.current ? () => api.runtime.config.current() : void 0, "diffs", api.pluginConfig) ?? {};