@gguf/claw 2026.2.1 → 2026.2.2

package/dist/infra/update-global.js

@@ -3,6 +3,7 @@ import os from "node:os";
 import path from "node:path";
 const PRIMARY_PACKAGE_NAME = "openclaw";
 const ALL_PACKAGE_NAMES = [PRIMARY_PACKAGE_NAME];
+const GLOBAL_RENAME_PREFIX = ".";
 async function pathExists(targetPath) {
     try {
         await fs.access(targetPath);
@@ -105,3 +106,37 @@ export function globalInstallArgs(manager, spec) {
     }
     return ["npm", "i", "-g", spec];
 }
+export async function cleanupGlobalRenameDirs(params) {
+    const removed = [];
+    const root = params.globalRoot.trim();
+    const name = params.packageName.trim();
+    if (!root || !name) {
+        return { removed };
+    }
+    const prefix = `${GLOBAL_RENAME_PREFIX}${name}-`;
+    let entries = [];
+    try {
+        entries = await fs.readdir(root);
+    }
+    catch {
+        return { removed };
+    }
+    for (const entry of entries) {
+        if (!entry.startsWith(prefix)) {
+            continue;
+        }
+        const target = path.join(root, entry);
+        try {
+            const stat = await fs.lstat(target);
+            if (!stat.isDirectory()) {
+                continue;
+            }
+            await fs.rm(target, { recursive: true, force: true });
+            removed.push(entry);
+        }
+        catch {
+            // ignore cleanup failures
+        }
+    }
+    return { removed };
+}

package/dist/infra/update-runner.js

@@ -2,10 +2,10 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { runCommandWithTimeout } from "../process/exec.js";
-import { compareSemverStrings } from "./update-check.js";
-import { DEV_BRANCH, isBetaTag, isStableTag } from "./update-channels.js";
-import { detectGlobalInstallManagerForRoot, globalInstallArgs } from "./update-global.js";
 import { trimLogTail } from "./restart-sentinel.js";
+import { DEV_BRANCH, isBetaTag, isStableTag } from "./update-channels.js";
+import { compareSemverStrings } from "./update-check.js";
+import { cleanupGlobalRenameDirs, detectGlobalInstallManagerForRoot, globalInstallArgs, } from "./update-global.js";
 const DEFAULT_TIMEOUT_MS = 20 * 60_000;
 const MAX_LOG_CHARS = 8000;
 const PREFLIGHT_MAX_COMMITS = 10;
@@ -571,6 +571,10 @@ export async function runGatewayUpdate(opts = {}) {
     const globalManager = await detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs);
     if (globalManager) {
         const packageName = (await readPackageName(pkgRoot)) ?? DEFAULT_PACKAGE_NAME;
+        await cleanupGlobalRenameDirs({
+            globalRoot: path.dirname(pkgRoot),
+            packageName,
+        });
         const spec = `${packageName}@${normalizeTag(opts.tag)}`;
         const updateStep = await runStep({
             runCommand,

package/dist/infra/update-startup.js

@@ -1,11 +1,11 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { formatCliCommand } from "../cli/command-format.js";
 import { resolveStateDir } from "../config/paths.js";
+import { VERSION } from "../version.js";
 import { resolveOpenClawPackageRoot } from "./openclaw-root.js";
-import { compareSemverStrings, resolveNpmChannelTag, checkUpdateStatus } from "./update-check.js";
 import { normalizeUpdateChannel, DEFAULT_PACKAGE_CHANNEL } from "./update-channels.js";
-import { VERSION } from "../version.js";
-import { formatCliCommand } from "../cli/command-format.js";
+import { compareSemverStrings, resolveNpmChannelTag, checkUpdateStatus } from "./update-check.js";
 const UPDATE_CHECK_FILENAME = "update-check.json";
 const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 function shouldSkipCheck(allowInTests) {

package/dist/line/auto-reply-delivery.d.ts

@@ -2,8 +2,8 @@ import type { messagingApi } from "@line/bot-sdk";
 import type { ReplyPayload } from "../auto-reply/types.js";
 import type { FlexContainer } from "./flex-templates.js";
 import type { ProcessedLineMessage } from "./markdown-to-line.js";
-import type { LineChannelData, LineTemplateMessagePayload } from "./types.js";
 import type { LineReplyMessage, SendLineReplyChunksParams } from "./reply-chunks.js";
+import type { LineChannelData, LineTemplateMessagePayload } from "./types.js";
 export type LineAutoReplyDeps = {
     buildTemplateMessageFromPayload: (payload: LineTemplateMessagePayload) => messagingApi.TemplateMessage | null;
     processLineMessage: (text: string) => ProcessedLineMessage;

package/dist/line/bot-handlers.d.ts

@@ -1,8 +1,8 @@
 import type { WebhookEvent } from "@line/bot-sdk";
 import type { OpenClawConfig } from "../config/config.js";
 import type { RuntimeEnv } from "../runtime.js";
-import { type LineInboundContext } from "./bot-message-context.js";
 import type { ResolvedLineAccount } from "./types.js";
+import { type LineInboundContext } from "./bot-message-context.js";
 export interface LineHandlerContext {
     cfg: OpenClawConfig;
     account: ResolvedLineAccount;

package/dist/line/bot-handlers.js

@@ -2,8 +2,8 @@ import { danger, logVerbose } from "../globals.js";
 import { resolvePairingIdLabel } from "../pairing/pairing-labels.js";
 import { buildPairingReply } from "../pairing/pairing-messages.js";
 import { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../pairing/pairing-store.js";
-import { buildLineMessageContext, buildLinePostbackContext, } from "./bot-message-context.js";
 import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore } from "./bot-access.js";
+import { buildLineMessageContext, buildLinePostbackContext, } from "./bot-message-context.js";
 import { downloadLineMedia } from "./download.js";
 import { pushMessageLine, replyMessageLine } from "./send.js";
 function getSourceInfo(source) {

package/dist/line/download.js

@@ -1,7 +1,7 @@
+import { messagingApi } from "@line/bot-sdk";
 import fs from "node:fs";
-import path from "node:path";
 import os from "node:os";
-import { messagingApi } from "@line/bot-sdk";
+import path from "node:path";
 import { logVerbose } from "../globals.js";
 export async function downloadLineMedia(messageId, channelAccessToken, maxBytes = 10 * 1024 * 1024) {
     const client = new messagingApi.MessagingApiBlobClient({

package/dist/line/monitor.js

@@ -1,16 +1,16 @@
+import { resolveEffectiveMessagesConfig } from "../agents/identity.js";
+import { chunkMarkdownText } from "../auto-reply/chunk.js";
+import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
 import { danger, logVerbose } from "../globals.js";
-import { createLineBot } from "./bot.js";
-import { validateLineSignature } from "./signature.js";
 import { normalizePluginHttpPath } from "../plugins/http-path.js";
 import { registerPluginHttpRoute } from "../plugins/http-registry.js";
-import { replyMessageLine, showLoadingAnimation, getUserDisplayName, createQuickReplyItems, createTextMessageWithQuickReplies, pushTextMessageWithQuickReplies, pushMessageLine, pushMessagesLine, createFlexMessage, createImageMessage, createLocationMessage, } from "./send.js";
-import { buildTemplateMessageFromPayload } from "./template-messages.js";
-import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
-import { resolveEffectiveMessagesConfig } from "../agents/identity.js";
-import { chunkMarkdownText } from "../auto-reply/chunk.js";
+import { deliverLineAutoReply } from "./auto-reply-delivery.js";
+import { createLineBot } from "./bot.js";
 import { processLineMessage } from "./markdown-to-line.js";
 import { sendLineReplyChunks } from "./reply-chunks.js";
-import { deliverLineAutoReply } from "./auto-reply-delivery.js";
+import { replyMessageLine, showLoadingAnimation, getUserDisplayName, createQuickReplyItems, createTextMessageWithQuickReplies, pushTextMessageWithQuickReplies, pushMessageLine, pushMessagesLine, createFlexMessage, createImageMessage, createLocationMessage, } from "./send.js";
+import { validateLineSignature } from "./signature.js";
+import { buildTemplateMessageFromPayload } from "./template-messages.js";
 // Track runtime state in memory (simplified version)
 const runtimeState = new Map();
 function recordChannelRuntimeState(params) {

package/dist/line/webhook.d.ts

@@ -1,5 +1,5 @@
-import type { Request, Response, NextFunction } from "express";
 import type { WebhookRequestBody } from "@line/bot-sdk";
+import type { Request, Response, NextFunction } from "express";
 import type { RuntimeEnv } from "../runtime.js";
 export interface LineWebhookOptions {
     channelSecret: string;

package/dist/link-understanding/apply.d.ts

@@ -1,5 +1,5 @@
-import type { OpenClawConfig } from "../config/config.js";
 import type { MsgContext } from "../auto-reply/templating.js";
+import type { OpenClawConfig } from "../config/config.js";
 export type ApplyLinkUnderstandingResult = {
     outputs: string[];
     urls: string[];

package/dist/link-understanding/runner.d.ts

@@ -1,5 +1,5 @@
-import type { OpenClawConfig } from "../config/config.js";
 import type { MsgContext } from "../auto-reply/templating.js";
+import type { OpenClawConfig } from "../config/config.js";
 export type LinkUnderstandingResult = {
     urls: string[];
     outputs: string[];

package/dist/link-understanding/runner.js

@@ -1,9 +1,9 @@
 import { applyTemplate } from "../auto-reply/templating.js";
 import { logVerbose, shouldLogVerbose } from "../globals.js";
-import { runExec } from "../process/exec.js";
 import { CLI_OUTPUT_MAX_BUFFER } from "../media-understanding/defaults.js";
 import { resolveTimeoutMs } from "../media-understanding/resolve.js";
 import { normalizeMediaUnderstandingChatType, resolveMediaUnderstandingScope, } from "../media-understanding/scope.js";
+import { runExec } from "../process/exec.js";
 import { DEFAULT_LINK_TIMEOUT_SECONDS } from "./defaults.js";
 import { extractLinksFromMessage } from "./detect.js";
 function resolveScopeDecision(params) {

package/dist/logging/config.js

@@ -1,5 +1,5 @@
-import fs from "node:fs";
 import json5 from "json5";
+import fs from "node:fs";
 import { resolveConfigPath } from "../config/paths.js";
 export function readLoggingConfig() {
     const configPath = resolveConfigPath();

package/dist/logging/console.js

@@ -2,9 +2,9 @@ import { createRequire } from "node:module";
 import util from "node:util";
 import { isVerbose } from "../globals.js";
 import { stripAnsi } from "../terminal/ansi.js";
+import { readLoggingConfig } from "./config.js";
 import { normalizeLogLevel } from "./levels.js";
 import { getLogger } from "./logger.js";
-import { readLoggingConfig } from "./config.js";
 import { loggingState } from "./state.js";
 const requireConfig = createRequire(import.meta.url);
 function normalizeConsoleLevel(level) {

package/dist/logging/logger.js

@@ -1,9 +1,9 @@
-import { createRequire } from "node:module";
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { Logger as TsLogger } from "tslog";
-import { levelToMinLevel, normalizeLogLevel } from "./levels.js";
 import { readLoggingConfig } from "./config.js";
+import { levelToMinLevel, normalizeLogLevel } from "./levels.js";
 import { loggingState } from "./state.js";
 // Pin to /tmp so mac Debug UI and docs match; os.tmpdir() can be a per-user
 // randomized path on macOS which made the “Open log” button a no-op.

package/dist/logging/subsystem.js

@@ -1,12 +1,12 @@
 import { Chalk } from "chalk";
 import { CHAT_CHANNEL_ORDER } from "../channels/registry.js";
+import { isVerbose } from "../globals.js";
 import { defaultRuntime } from "../runtime.js";
+import { clearActiveProgressLine } from "../terminal/progress-line.js";
 import { getConsoleSettings, shouldLogSubsystemToConsole } from "./console.js";
-import { isVerbose } from "../globals.js";
 import { levelToMinLevel } from "./levels.js";
 import { getChildLogger } from "./logger.js";
 import { loggingState } from "./state.js";
-import { clearActiveProgressLine } from "../terminal/progress-line.js";
 function shouldLogToConsole(level, settings) {
     if (settings.level === "silent") {
         return false;

package/dist/media/fetch.d.ts

@@ -1,3 +1,4 @@
+import type { LookupFn, SsrFPolicy } from "../infra/net/ssrf.js";
 type FetchMediaResult = {
     buffer: Buffer;
     contentType?: string;
@@ -14,6 +15,9 @@ type FetchMediaOptions = {
     fetchImpl?: FetchLike;
     filePathHint?: string;
     maxBytes?: number;
+    maxRedirects?: number;
+    ssrfPolicy?: SsrFPolicy;
+    lookupFn?: LookupFn;
 };
 export declare function fetchRemoteMedia(options: FetchMediaOptions): Promise<FetchMediaResult>;
 export {};

package/dist/media/fetch.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";
 import { detectMime, extensionForMime } from "./mime.js";
 export class MediaFetchError extends Error {
     code;
@@ -52,71 +53,85 @@ async function readErrorBodySnippet(res, maxChars = 200) {
     }
 }
 export async function fetchRemoteMedia(options) {
-    const { url, fetchImpl, filePathHint, maxBytes } = options;
-    const fetcher = fetchImpl ?? globalThis.fetch;
-    if (!fetcher) {
-        throw new Error("fetch is not available");
-    }
+    const { url, fetchImpl, filePathHint, maxBytes, maxRedirects, ssrfPolicy, lookupFn } = options;
     let res;
+    let finalUrl = url;
+    let release = null;
     try {
-        res = await fetcher(url);
+        const result = await fetchWithSsrFGuard({
+            url,
+            fetchImpl,
+            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)}`);
     }
-    if (!res.ok) {
-        const statusText = res.statusText ? ` ${res.statusText}` : "";
-        const redirected = res.url && res.url !== url ? ` (redirected to ${res.url})` : "";
-        let detail = `HTTP ${res.status}${statusText}`;
-        if (!res.body) {
-            detail = `HTTP ${res.status}${statusText}; empty response body`;
+    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}`);
         }
-        else {
-            const snippet = await readErrorBodySnippet(res);
-            if (snippet) {
-                detail += `; body: ${snippet}`;
+        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}`);
             }
         }
-        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)
+            : Buffer.from(await res.arrayBuffer());
+        let fileNameFromUrl;
+        try {
+            const parsed = new URL(finalUrl);
+            const base = path.basename(parsed.pathname);
+            fileNameFromUrl = base || undefined;
         }
+        catch {
+            // ignore parse errors; leave undefined
+        }
+        const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
+        let fileName = headerFileName || fileNameFromUrl || (filePathHint ? path.basename(filePathHint) : undefined);
+        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 ?? undefined,
+            fileName,
+        };
     }
-    const buffer = maxBytes
-        ? await readResponseWithLimit(res, maxBytes)
-        : Buffer.from(await res.arrayBuffer());
-    let fileNameFromUrl;
-    try {
-        const parsed = new URL(url);
-        const base = path.basename(parsed.pathname);
-        fileNameFromUrl = base || undefined;
-    }
-    catch {
-        // ignore parse errors; leave undefined
-    }
-    const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
-    let fileName = headerFileName || fileNameFromUrl || (filePathHint ? path.basename(filePathHint) : undefined);
-    const filePathForMime = headerFileName && path.extname(headerFileName) ? headerFileName : (filePathHint ?? url);
-    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}`;
+    finally {
+        if (release) {
+            await release();
         }
     }
-    return {
-        buffer,
-        contentType: contentType ?? undefined,
-        fileName,
-    };
 }
 async function readResponseWithLimit(res, maxBytes) {
     const body = res.body;

package/dist/media/host.js

@@ -1,9 +1,9 @@
 import fs from "node:fs/promises";
+import { formatCliCommand } from "../cli/command-format.js";
 import { ensurePortAvailable, PortInUseError } from "../infra/ports.js";
 import { getTailnetHostname } from "../infra/tailscale.js";
 import { logInfo } from "../logger.js";
 import { defaultRuntime } from "../runtime.js";
-import { formatCliCommand } from "../cli/command-format.js";
 import { startMediaServer } from "./server.js";
 import { saveMediaSource } from "./store.js";
 const DEFAULT_PORT = 42873;

package/dist/media/input-files.js

@@ -1,5 +1,5 @@
+import { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";
 import { logWarn } from "../logger.js";
-import { closeDispatcher, createPinnedDispatcher, resolvePinnedHostname, } from "../infra/net/ssrf.js";
 let canvasModulePromise = null;
 let pdfJsModulePromise = null;
 // Lazy-load optional PDF/image deps so non-PDF paths don't require native installs.
@@ -38,9 +38,6 @@ export const DEFAULT_INPUT_TIMEOUT_MS = 10_000;
 export const DEFAULT_INPUT_PDF_MAX_PAGES = 4;
 export const DEFAULT_INPUT_PDF_MAX_PIXELS = 4_000_000;
 export const DEFAULT_INPUT_PDF_MIN_TEXT_CHARS = 200;
-function isRedirectStatus(status) {
-    return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
 export function normalizeMimeType(value) {
     if (!value) {
         return undefined;
@@ -65,64 +62,34 @@ export function normalizeMimeList(values, fallback) {
     return new Set(input.map((value) => normalizeMimeType(value)).filter(Boolean));
 }
 export async function fetchWithGuard(params) {
-    let currentUrl = params.url;
-    let redirectCount = 0;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), params.timeoutMs);
+    const { response, release } = await fetchWithSsrFGuard({
+        url: params.url,
+        maxRedirects: params.maxRedirects,
+        timeoutMs: params.timeoutMs,
+        init: { headers: { "User-Agent": "OpenClaw-Gateway/1.0" } },
+    });
     try {
-        while (true) {
-            const parsedUrl = new URL(currentUrl);
-            if (!["http:", "https:"].includes(parsedUrl.protocol)) {
-                throw new Error(`Invalid URL protocol: ${parsedUrl.protocol}. Only HTTP/HTTPS allowed.`);
-            }
-            const pinned = await resolvePinnedHostname(parsedUrl.hostname);
-            const dispatcher = createPinnedDispatcher(pinned);
-            try {
-                const response = await fetch(parsedUrl, {
-                    signal: controller.signal,
-                    headers: { "User-Agent": "OpenClaw-Gateway/1.0" },
-                    redirect: "manual",
-                    dispatcher,
-                });
-                if (isRedirectStatus(response.status)) {
-                    const location = response.headers.get("location");
-                    if (!location) {
-                        throw new Error(`Redirect missing location header (${response.status})`);
-                    }
-                    redirectCount += 1;
-                    if (redirectCount > params.maxRedirects) {
-                        throw new Error(`Too many redirects (limit: ${params.maxRedirects})`);
-                    }
-                    void response.body?.cancel();
-                    currentUrl = new URL(location, parsedUrl).toString();
-                    continue;
-                }
-                if (!response.ok) {
-                    throw new Error(`Failed to fetch: ${response.status} ${response.statusText}`);
-                }
-                const contentLength = response.headers.get("content-length");
-                if (contentLength) {
-                    const size = parseInt(contentLength, 10);
-                    if (size > params.maxBytes) {
-                        throw new Error(`Content too large: ${size} bytes (limit: ${params.maxBytes} bytes)`);
-                    }
-                }
-                const buffer = Buffer.from(await response.arrayBuffer());
-                if (buffer.byteLength > params.maxBytes) {
-                    throw new Error(`Content too large: ${buffer.byteLength} bytes (limit: ${params.maxBytes} bytes)`);
-                }
-                const contentType = response.headers.get("content-type") || undefined;
-                const parsed = parseContentType(contentType);
-                const mimeType = parsed.mimeType ?? "application/octet-stream";
-                return { buffer, mimeType, contentType };
-            }
-            finally {
-                await closeDispatcher(dispatcher);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch: ${response.status} ${response.statusText}`);
+        }
+        const contentLength = response.headers.get("content-length");
+        if (contentLength) {
+            const size = parseInt(contentLength, 10);
+            if (size > params.maxBytes) {
+                throw new Error(`Content too large: ${size} bytes (limit: ${params.maxBytes} bytes)`);
             }
         }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (buffer.byteLength > params.maxBytes) {
+            throw new Error(`Content too large: ${buffer.byteLength} bytes (limit: ${params.maxBytes} bytes)`);
+        }
+        const contentType = response.headers.get("content-type") || undefined;
+        const parsed = parseContentType(contentType);
+        const mimeType = parsed.mimeType ?? "application/octet-stream";
+        return { buffer, mimeType, contentType };
     }
     finally {
-        clearTimeout(timeoutId);
+        await release();
     }
 }
 function decodeTextContent(buffer, charset) {

package/dist/media/mime.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import { fileTypeFromBuffer } from "file-type";
+import path from "node:path";
 import { mediaKindFromMime } from "./constants.js";
 // Map common mimes to preferred file extensions.
 const EXT_BY_MIME = {

package/dist/media/server.js

@@ -1,8 +1,8 @@
-import fs from "node:fs/promises";
 import express from "express";
+import fs from "node:fs/promises";
 import { danger } from "../globals.js";
-import { defaultRuntime } from "../runtime.js";
 import { SafeOpenError, openFileWithinRoot } from "../infra/fs-safe.js";
+import { defaultRuntime } from "../runtime.js";
 import { detectMime } from "./mime.js";
 import { cleanOldMedia, getMediaDir, MEDIA_MAX_BYTES } from "./store.js";
 const DEFAULT_TTL_MS = 2 * 60 * 1000;

package/dist/media/store.js

@@ -5,8 +5,8 @@ import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import path from "node:path";
 import { pipeline } from "node:stream/promises";
-import { resolveConfigDir } from "../utils.js";
 import { resolvePinnedHostname } from "../infra/net/ssrf.js";
+import { resolveConfigDir } from "../utils.js";
 import { detectMime, extensionForMime } from "./mime.js";
 const resolveMediaDir = () => path.join(resolveConfigDir(), "media");
 export const MEDIA_MAX_BYTES = 5 * 1024 * 1024; // 5MB default

package/dist/media-understanding/apply.d.ts

@@ -1,5 +1,5 @@
-import type { OpenClawConfig } from "../config/config.js";
 import type { MsgContext } from "../auto-reply/templating.js";
+import type { OpenClawConfig } from "../config/config.js";
 import type { MediaUnderstandingDecision, MediaUnderstandingOutput, MediaUnderstandingProvider } from "./types.js";
 import { type ActiveMediaModel } from "./runner.js";
 export type ApplyMediaUnderstandingResult = {