squidclaw 3.0.3 → 3.0.4

package/dist/plugin-sdk/{ir-BVZ5kUMb.js → ir-DihI2SIz.js}

@@ -1,10 +1,10 @@
-import { ot as normalizeAccountId } from "./run-with-concurrency-DmTrN5JG.js";
-import { L as logVerbose, y as resolveUserPath, z as shouldLogVerbose } from "./logger-DIb2cGHp.js";
-import { v as resolveAccountEntry } from "./accounts-YTdQYQFr.js";
-import { r as normalizeChannelId } from "./plugins-B8pWVYug.js";
-import { _ as maxBytesForKind, a as hasAlphaChannel, c as detectMime, l as extensionForMime, m as kindFromMime, o as optimizeImageToPng, r as convertHeicToJpeg, s as resizeToJpeg, y as INTERNAL_MESSAGE_CHANNEL } from "./image-ops-sw0uZ0GN.js";
-import { o as readLocalFileSafely, t as SafeOpenError } from "./fs-safe-DqCO1D4C.js";
-import { i as fetchRemoteMedia, n as getDefaultMediaLocalRoots } from "./local-roots-fO3ZgW3G.js";
+import { ot as normalizeAccountId } from "./run-with-concurrency-kVooFCVo.js";
+import { L as logVerbose, y as resolveUserPath, z as shouldLogVerbose } from "./logger-Bg4vIUJn.js";
+import { v as resolveAccountEntry } from "./accounts-CxUSDHsT.js";
+import { r as normalizeChannelId } from "./plugins-DSs2-fnK.js";
+import { _ as maxBytesForKind, a as hasAlphaChannel, c as detectMime, l as extensionForMime, m as kindFromMime, o as optimizeImageToPng, r as convertHeicToJpeg, s as resizeToJpeg, y as INTERNAL_MESSAGE_CHANNEL } from "./image-ops-CMsocOob.js";
+import { o as readLocalFileSafely, t as SafeOpenError } from "./fs-safe-DFbwq9CS.js";
+import { i as fetchRemoteMedia, n as getDefaultMediaLocalRoots } from "./local-roots-1xVosTZ4.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";

package/dist/plugin-sdk/{local-roots-fO3ZgW3G.js → local-roots-1xVosTZ4.js}

@@ -1,8 +1,8 @@
-import { c as resolveAgentWorkspaceDir } from "./run-with-concurrency-DmTrN5JG.js";
-import { Y as resolvePreferredSquidClawTmpDir } from "./logger-DIb2cGHp.js";
+import { c as resolveAgentWorkspaceDir } from "./run-with-concurrency-kVooFCVo.js";
+import { Y as resolvePreferredSquidClawTmpDir } from "./logger-Bg4vIUJn.js";
 import { c as resolveStateDir } from "./paths-Duwviem_.js";
-import { c as detectMime, l as extensionForMime } from "./image-ops-sw0uZ0GN.js";
-import { n as withStrictGuardedFetchMode, t as fetchWithSsrFGuard } from "./fetch-guard-DyPZh8r2.js";
+import { c as detectMime, l as extensionForMime } from "./image-ops-CMsocOob.js";
+import { n as withStrictGuardedFetchMode, t as fetchWithSsrFGuard } from "./fetch-guard-Or5BCq0E.js";
 import path from "node:path";
 
 //#region src/media/read-response-with-limit.ts

package/dist/plugin-sdk/local-roots-DmOKwiNW.js

@@ -0,0 +1,186 @@
+import { c as resolveAgentWorkspaceDir } from "./run-with-concurrency-5DMu9szx.js";
+import { c as resolveStateDir } from "./paths-8xF5kDne.js";
+import { X as resolvePreferredSquidClawTmpDir } from "./logger-DDdrdbDu.js";
+import { c as detectMime, l as extensionForMime } from "./image-ops-BjK2qZZn.js";
+import { n as withStrictGuardedFetchMode, t as fetchWithSsrFGuard } from "./fetch-guard-C55uvn27.js";
+import path from "node:path";
+
+//#region src/media/read-response-with-limit.ts
+async function readResponseWithLimit(res, maxBytes, opts) {
+	const onOverflow = opts?.onOverflow ?? ((params) => /* @__PURE__ */ new Error(`Content too large: ${params.size} bytes (limit: ${params.maxBytes} bytes)`));
+	const body = res.body;
+	if (!body || typeof body.getReader !== "function") {
+		const fallback = Buffer.from(await res.arrayBuffer());
+		if (fallback.length > maxBytes) throw onOverflow({
+			size: fallback.length,
+			maxBytes,
+			res
+		});
+		return fallback;
+	}
+	const reader = body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value?.length) {
+				total += value.length;
+				if (total > maxBytes) {
+					try {
+						await reader.cancel();
+					} catch {}
+					throw onOverflow({
+						size: total,
+						maxBytes,
+						res
+					});
+				}
+				chunks.push(value);
+			}
+		}
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+	return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)), total);
+}
+
+//#endregion
+//#region src/media/fetch.ts
+var MediaFetchError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "MediaFetchError";
+	}
+};
+function stripQuotes(value) {
+	return value.replace(/^["']|["']$/g, "");
+}
+function parseContentDispositionFileName(header) {
+	if (!header) return;
+	const starMatch = /filename\*\s*=\s*([^;]+)/i.exec(header);
+	if (starMatch?.[1]) {
+		const cleaned = stripQuotes(starMatch[1].trim());
+		const encoded = cleaned.split("''").slice(1).join("''") || cleaned;
+		try {
+			return path.basename(decodeURIComponent(encoded));
+		} catch {
+			return path.basename(encoded);
+		}
+	}
+	const match = /filename\s*=\s*([^;]+)/i.exec(header);
+	if (match?.[1]) return path.basename(stripQuotes(match[1].trim()));
+}
+async function readErrorBodySnippet(res, maxChars = 200) {
+	try {
+		const text = await res.text();
+		if (!text) return;
+		const collapsed = text.replace(/\s+/g, " ").trim();
+		if (!collapsed) return;
+		if (collapsed.length <= maxChars) return collapsed;
+		return `${collapsed.slice(0, maxChars)}…`;
+	} catch {
+		return;
+	}
+}
+async function fetchRemoteMedia(options) {
+	const { url, fetchImpl, requestInit, filePathHint, maxBytes, maxRedirects, ssrfPolicy, lookupFn } = options;
+	let res;
+	let finalUrl = url;
+	let release = null;
+	try {
+		const result = await fetchWithSsrFGuard(withStrictGuardedFetchMode({
+			url,
+			fetchImpl,
+			init: requestInit,
+			maxRedirects,
+			policy: ssrfPolicy,
+			lookupFn
+		}));
+		res = result.response;
+		finalUrl = result.finalUrl;
+		release = result.release;
+	} catch (err) {
+		throw new MediaFetchError("fetch_failed", `Failed to fetch media from ${url}: ${String(err)}`);
+	}
+	try {
+		if (!res.ok) {
+			const statusText = res.statusText ? ` ${res.statusText}` : "";
+			const redirected = finalUrl !== url ? ` (redirected to ${finalUrl})` : "";
+			let detail = `HTTP ${res.status}${statusText}`;
+			if (!res.body) detail = `HTTP ${res.status}${statusText}; empty response body`;
+			else {
+				const snippet = await readErrorBodySnippet(res);
+				if (snippet) detail += `; body: ${snippet}`;
+			}
+			throw new MediaFetchError("http_error", `Failed to fetch media from ${url}${redirected}: ${detail}`);
+		}
+		const contentLength = res.headers.get("content-length");
+		if (maxBytes && contentLength) {
+			const length = Number(contentLength);
+			if (Number.isFinite(length) && length > maxBytes) throw new MediaFetchError("max_bytes", `Failed to fetch media from ${url}: content length ${length} exceeds maxBytes ${maxBytes}`);
+		}
+		const buffer = maxBytes ? await readResponseWithLimit(res, maxBytes, { onOverflow: ({ maxBytes, res }) => new MediaFetchError("max_bytes", `Failed to fetch media from ${res.url || url}: payload exceeds maxBytes ${maxBytes}`) }) : Buffer.from(await res.arrayBuffer());
+		let fileNameFromUrl;
+		try {
+			const parsed = new URL(finalUrl);
+			fileNameFromUrl = path.basename(parsed.pathname) || void 0;
+		} catch {}
+		const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
+		let fileName = headerFileName || fileNameFromUrl || (filePathHint ? path.basename(filePathHint) : void 0);
+		const filePathForMime = headerFileName && path.extname(headerFileName) ? headerFileName : filePathHint ?? finalUrl;
+		const contentType = await detectMime({
+			buffer,
+			headerMime: res.headers.get("content-type"),
+			filePath: filePathForMime
+		});
+		if (fileName && !path.extname(fileName) && contentType) {
+			const ext = extensionForMime(contentType);
+			if (ext) fileName = `${fileName}${ext}`;
+		}
+		return {
+			buffer,
+			contentType: contentType ?? void 0,
+			fileName
+		};
+	} finally {
+		if (release) await release();
+	}
+}
+
+//#endregion
+//#region src/media/local-roots.ts
+let cachedPreferredTmpDir;
+function resolveCachedPreferredTmpDir() {
+	if (!cachedPreferredTmpDir) cachedPreferredTmpDir = resolvePreferredSquidClawTmpDir();
+	return cachedPreferredTmpDir;
+}
+function buildMediaLocalRoots(stateDir, options = {}) {
+	const resolvedStateDir = path.resolve(stateDir);
+	return [
+		options.preferredTmpDir ?? resolveCachedPreferredTmpDir(),
+		path.join(resolvedStateDir, "media"),
+		path.join(resolvedStateDir, "agents"),
+		path.join(resolvedStateDir, "workspace"),
+		path.join(resolvedStateDir, "sandboxes")
+	];
+}
+function getDefaultMediaLocalRoots() {
+	return buildMediaLocalRoots(resolveStateDir());
+}
+function getAgentScopedMediaLocalRoots(cfg, agentId) {
+	const roots = buildMediaLocalRoots(resolveStateDir());
+	if (!agentId?.trim()) return roots;
+	const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+	if (!workspaceDir) return roots;
+	const normalizedWorkspaceDir = path.resolve(workspaceDir);
+	if (!roots.includes(normalizedWorkspaceDir)) roots.push(normalizedWorkspaceDir);
+	return roots;
+}
+
+//#endregion
+export { readResponseWithLimit as a, fetchRemoteMedia as i, getDefaultMediaLocalRoots as n, MediaFetchError as r, getAgentScopedMediaLocalRoots as t };

package/dist/plugin-sdk/{logger-DIb2cGHp.js → logger-Bg4vIUJn.js}

@@ -4,7 +4,7 @@ import chalk, { Chalk } from "chalk";
 import fs from "node:fs";
 import { Logger } from "tslog";
 import os from "node:os";
-import JSON5 from "json5";
+import json5 from "json5";
 import util from "node:util";
 
 //#region src/infra/cli-root-options.ts
@@ -157,7 +157,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = JSON5.parse(raw)?.logging;
+		const logging = json5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {