@dai_ming/plugin-deliverables 1.0.19 → 1.0.21

package/index.js

@@ -1,18 +1,87 @@
 "use strict";
 
+const fs = require("fs");
+const http = require("http");
+const https = require("https");
+const path = require("path");
+
 const FETCH_PATCH_KEY = "__plugin_deliverables_palz_fetch_patch__";
 const SUMMARY_CACHE_KEY = "__plugin_deliverables_summary_cache__";
+const PENDING_FILES_KEY = "__plugin_deliverables_pending_files__";
+const UPLOAD_CACHE_KEY = "__plugin_deliverables_upload_cache__";
 const SUMMARY_CACHE_LIMIT = 200;
 const SHORT_SUMMARY_THRESHOLD = 120;
+const DEFAULT_GATEWAY_PUBLIC_URL = "https://claw-gateway.csagentai.com";
+const DEFAULT_GATEWAY_INTERNAL_URL = "http://claw-gateway:8080";
+const AUTO_UPLOAD_TTL_MS = 15 * 60 * 1000;
+const AUTO_UPLOAD_MAX_FILES = 8;
+const AUTO_UPLOAD_MAX_BYTES = 200 * 1024 * 1024;
+const AUTO_UPLOAD_SCAN_MAX_ENTRIES = 4000;
+const AUTO_UPLOAD_SCAN_DEPTH = 5;
+const DELIVERABLE_GATEWAY_PATH_RE = /^\/openclaw-gateway\/(?:output|preview)(?:\/|$)/u;
+const DELIVERABLE_LINK_PREFIX_RE =
+  /^\s*(?:[-*+]\s+)?(?:预览链接|下载链接|文件列表|项目入口|在线预览|在线体验|目录链接)\s*[:：]/u;
+const DELIVERABLE_LINK_LABEL_RE =
+  /^\s*(?:[-*+]\s+)?(?:预览链接|下载链接|文件列表|项目入口|在线预览|在线体验|目录链接)\s*[:：]\s*\[[^\]]+\]\([^)]+\)\s*$/u;
+const INTERNAL_ABSOLUTE_PATH_RE =
+  /(?:\/data\/workspace-[^\s`"'<>，。；：、)）\]}]+|\/home\/node\/\.openclaw\/workspace(?:-[A-Za-z0-9_.-]+)?\/[^\s`"'<>，。；：、)）\]}]+)/gu;
+const INLINE_FILE_REF_RE = /`([^`\n]{1,512}\.[A-Za-z0-9]{1,16})`/gu;
+const OUTPUT_RELATIVE_REF_RE = /(?:^|[\s(:：])((?:\.\/)?output\/[^\s`"'<>，。；：、)）\]}]+\.[A-Za-z0-9]{1,16})/gu;
+const FILE_EXTENSION_RE = /\.[A-Za-z0-9]{1,16}$/u;
+const TEXT_EXTENSIONS = new Set([
+  ".css",
+  ".csv",
+  ".html",
+  ".htm",
+  ".js",
+  ".json",
+  ".jsx",
+  ".log",
+  ".md",
+  ".markdown",
+  ".mjs",
+  ".py",
+  ".sql",
+  ".svg",
+  ".ts",
+  ".tsx",
+  ".txt",
+  ".xml",
+  ".yaml",
+  ".yml",
+]);
+const IMAGE_EXTENSIONS = new Set([".apng", ".avif", ".bmp", ".gif", ".ico", ".jpeg", ".jpg", ".png", ".svg", ".webp"]);
+const VIDEO_EXTENSIONS = new Set([".avi", ".m4v", ".mkv", ".mov", ".mp4", ".mpeg", ".mpg", ".webm"]);
+const PPT_EXTENSIONS = new Set([".ppt", ".pptx"]);
+const ARCHIVE_EXTENSIONS = new Set([".7z", ".gz", ".rar", ".tar", ".tgz", ".zip"]);
+const IGNORED_PATH_PARTS = new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  "sessions",
+  "skills",
+  ".cache",
+  "__pycache__",
+]);
+const IGNORED_FILE_NAMES = new Set([
+  "AGENTS.md",
+  "SOUL.md",
+  "openclaw.json",
+  "openclaw-runtime.json",
+  "package-lock.json",
+]);
 
 const RUNTIME_DELIVERABLES_GUIDANCE = [
   "## Deliverables Runtime Guard (HARD CONSTRAINT)",
   "",
   "- These rules apply to the main agent and all subagents.",
   "- When the user asks for a document, article, report, HTML page, Markdown file, PPT, image, archive, game, or any other file deliverable, you MUST create it under the current workspace `output/` directory and upload it with `deliverables__upload_deliverable`.",
+  "- For binary deliverables such as PDF, PPT, images, video, or zip files, pass `file_path` to `deliverables__upload_deliverable` after writing the file under `output/`; do not paste command output or partial base64 into `content_base64`.",
   "- Every single-file deliverable must use a file name with an explicit extension. If the user did not specify a document/text format, default to Markdown and use a `.md` file name.",
   "- Do not use direct message attachments to deliver generated files. This includes the message tool attachment fields such as `media`, `path`, `filePath`, `buffer`, `attachment`, or similar file-carrying fields.",
   "- Do not emit `MEDIA:` file references for user-facing deliverables. Deliverable links must come from the deliverables upload tool instead.",
+  "- If the deliverables upload tool returns an error, retry with a valid `file_path` or explain the upload failure; never invent or rewrite OSS/download URLs.",
   "- After a successful upload, reply with a substantive content summary before the links. For documents/articles/reports, prefer 1 short intro plus 3-6 concise bullets covering key sections, highlights, or findings, then preserve the Markdown links returned by the deliverables tool.",
 ].join("\n");
 
@@ -20,6 +89,648 @@ function isString(value) {
   return typeof value === "string";
 }
 
+function trimString(value) {
+  return isString(value) ? value.trim() : "";
+}
+
+function getPendingFileStore() {
+  if (!globalThis[PENDING_FILES_KEY] || !(globalThis[PENDING_FILES_KEY] instanceof Map)) {
+    globalThis[PENDING_FILES_KEY] = new Map();
+  }
+  return globalThis[PENDING_FILES_KEY];
+}
+
+function getUploadCache() {
+  if (!globalThis[UPLOAD_CACHE_KEY] || !(globalThis[UPLOAD_CACHE_KEY] instanceof Map)) {
+    globalThis[UPLOAD_CACHE_KEY] = new Map();
+  }
+  return globalThis[UPLOAD_CACHE_KEY];
+}
+
+function pruneTimedMap(map, ttlMs) {
+  const now = Date.now();
+  for (const [key, value] of map.entries()) {
+    if (!value || !value.createdAt || now - Number(value.createdAt) > ttlMs) {
+      map.delete(key);
+    }
+  }
+}
+
+function normalizeSlash(value) {
+  return String(value || "").replace(/\\/g, "/");
+}
+
+function stripTrailingPathPunctuation(value) {
+  return String(value || "").replace(/[.,;:!?，。；：！？、)）\]}》】]+$/u, "");
+}
+
+function hasFileExtension(value) {
+  return FILE_EXTENSION_RE.test(path.basename(stripTrailingPathPunctuation(value)));
+}
+
+function isURLLike(value) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(String(value || ""));
+}
+
+function fileExtension(filePath) {
+  return path.extname(stripTrailingPathPunctuation(filePath)).toLowerCase();
+}
+
+function isTextLikeFile(filePath) {
+  return TEXT_EXTENSIONS.has(fileExtension(filePath));
+}
+
+function deliverableTypeForPath(filePath, isDirectory) {
+  if (isDirectory) {
+    return "game";
+  }
+  const ext = fileExtension(filePath);
+  if (IMAGE_EXTENSIONS.has(ext) && ext !== ".svg") {
+    return "image";
+  }
+  if (VIDEO_EXTENSIONS.has(ext)) {
+    return "video";
+  }
+  if (PPT_EXTENSIONS.has(ext)) {
+    return "ppt";
+  }
+  if (ARCHIVE_EXTENSIONS.has(ext)) {
+    return "zip";
+  }
+  return "article";
+}
+
+function isAllowedWorkspacePath(candidatePath) {
+  const normalized = normalizeSlash(path.resolve(candidatePath));
+  return (
+    normalized.indexOf("/data/workspace-") === 0 ||
+    normalized.indexOf("/home/node/.openclaw/workspace") === 0
+  );
+}
+
+function shouldIgnorePath(candidatePath) {
+  const normalized = normalizeSlash(candidatePath);
+  const parts = normalized.split("/").filter(Boolean);
+  for (const part of parts) {
+    if (IGNORED_PATH_PARTS.has(part)) {
+      return true;
+    }
+  }
+  return IGNORED_FILE_NAMES.has(path.basename(normalized));
+}
+
+function safeStat(candidatePath) {
+  try {
+    return fs.statSync(candidatePath);
+  } catch (_err) {
+    return null;
+  }
+}
+
+function workspaceRoots() {
+  const roots = [];
+  ["/home/node/.openclaw/workspace-main", "/home/node/.openclaw/workspace"].forEach((root) => {
+    if (safeStat(root)) {
+      roots.push(root);
+    }
+  });
+  try {
+    for (const entry of fs.readdirSync("/data")) {
+      if (!entry || entry.indexOf("workspace-") !== 0) {
+        continue;
+      }
+      const root = path.join("/data", entry);
+      if (safeStat(root)) {
+        roots.push(root);
+      }
+    }
+  } catch (_err) {
+    // /data is not guaranteed in non-pod test environments.
+  }
+  return roots;
+}
+
+function resolveCandidatePath(rawPath) {
+  const cleaned = stripTrailingPathPunctuation(trimString(rawPath));
+  if (!cleaned || isURLLike(cleaned)) {
+    return "";
+  }
+  if (path.isAbsolute(cleaned)) {
+    return path.resolve(cleaned);
+  }
+  return cleaned;
+}
+
+function findFileByRelativeOrBaseName(rawRef) {
+  const cleaned = stripTrailingPathPunctuation(trimString(rawRef)).replace(/^\.\//, "");
+  if (!cleaned || isURLLike(cleaned) || !hasFileExtension(cleaned)) {
+    return "";
+  }
+  const roots = workspaceRoots();
+  const directCandidates = [];
+  for (const root of roots) {
+    directCandidates.push(path.join(root, cleaned));
+    directCandidates.push(path.join(root, "output", cleaned));
+    directCandidates.push(path.join(root, path.basename(cleaned)));
+    directCandidates.push(path.join(root, "output", path.basename(cleaned)));
+  }
+  for (const candidate of directCandidates) {
+    const stat = safeStat(candidate);
+    if (stat && (stat.isFile() || stat.isDirectory()) && isAllowedWorkspacePath(candidate) && !shouldIgnorePath(candidate)) {
+      return path.resolve(candidate);
+    }
+  }
+
+  const basename = path.basename(cleaned);
+  const found = [];
+  let visited = 0;
+  function scan(dir, depth) {
+    if (depth < 0 || visited > AUTO_UPLOAD_SCAN_MAX_ENTRIES || shouldIgnorePath(dir)) {
+      return;
+    }
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (_err) {
+      return;
+    }
+    for (const entry of entries) {
+      if (visited > AUTO_UPLOAD_SCAN_MAX_ENTRIES) {
+        return;
+      }
+      visited += 1;
+      const full = path.join(dir, entry.name);
+      if (shouldIgnorePath(full)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        scan(full, depth - 1);
+        continue;
+      }
+      if (entry.isFile() && entry.name === basename) {
+        const stat = safeStat(full);
+        if (stat) {
+          found.push({ path: full, mtimeMs: stat.mtimeMs });
+        }
+      }
+    }
+  }
+  for (const root of roots) {
+    scan(root, AUTO_UPLOAD_SCAN_DEPTH);
+  }
+  found.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return found.length > 0 ? path.resolve(found[0].path) : "";
+}
+
+function extractFileReferencesFromText(text) {
+  const normalized = String(text || "");
+  const refs = [];
+  const seen = new Set();
+  function add(raw, value, kind) {
+    const cleaned = stripTrailingPathPunctuation(value);
+    if (!cleaned || isURLLike(cleaned)) {
+      return;
+    }
+    const key = `${kind}:${cleaned}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    refs.push({ raw, value: cleaned, kind });
+  }
+
+  for (const match of normalized.matchAll(INTERNAL_ABSOLUTE_PATH_RE)) {
+    add(match[0], match[0], "absolute");
+  }
+  for (const match of normalized.matchAll(INLINE_FILE_REF_RE)) {
+    add(match[0], match[1], "inline");
+  }
+  for (const match of normalized.matchAll(OUTPUT_RELATIVE_REF_RE)) {
+    add(match[1], match[1], "relative");
+  }
+  return refs;
+}
+
+function resolveFileReference(ref) {
+  if (!ref || !ref.value) {
+    return null;
+  }
+  const candidate = resolveCandidatePath(ref.value);
+  const resolved = path.isAbsolute(candidate) ? candidate : findFileByRelativeOrBaseName(candidate);
+  if (!resolved) {
+    return null;
+  }
+  const stat = safeStat(resolved);
+  if (!stat || (!stat.isFile() && !stat.isDirectory())) {
+    return null;
+  }
+  if (!isAllowedWorkspacePath(resolved) || shouldIgnorePath(resolved)) {
+    return null;
+  }
+  return {
+    raw: ref.raw,
+    path: resolved,
+    fileName: path.basename(resolved),
+    isDirectory: stat.isDirectory(),
+    size: stat.isDirectory() ? 0 : stat.size,
+    mtimeMs: stat.mtimeMs,
+  };
+}
+
+function collectDirectoryFiles(dirPath) {
+  const files = [];
+  let total = 0;
+  let visited = 0;
+  function scan(current, depth) {
+    if (depth < 0 || visited > AUTO_UPLOAD_SCAN_MAX_ENTRIES || shouldIgnorePath(current)) {
+      return;
+    }
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch (_err) {
+      return;
+    }
+    for (const entry of entries) {
+      if (visited > AUTO_UPLOAD_SCAN_MAX_ENTRIES || files.length >= AUTO_UPLOAD_MAX_FILES * 50) {
+        return;
+      }
+      visited += 1;
+      const full = path.join(current, entry.name);
+      if (shouldIgnorePath(full)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        scan(full, depth - 1);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const stat = safeStat(full);
+      if (!stat || total + stat.size > AUTO_UPLOAD_MAX_BYTES) {
+        continue;
+      }
+      total += stat.size;
+      const rel = normalizeSlash(path.relative(dirPath, full));
+      if (isTextLikeFile(full)) {
+        files.push({ name: rel, contentText: fs.readFileSync(full, "utf8") });
+      } else {
+        files.push({ name: rel, contentBase64: fs.readFileSync(full).toString("base64") });
+      }
+    }
+  }
+  scan(dirPath, AUTO_UPLOAD_SCAN_DEPTH);
+  return files;
+}
+
+function extractStringField(obj, keys) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return "";
+  }
+  for (const key of keys) {
+    const value = obj[key];
+    if (isString(value) && value.trim()) {
+      return value.trim();
+    }
+  }
+  return "";
+}
+
+function extractContextString(event, keys) {
+  const direct = extractStringField(event, keys);
+  if (direct) {
+    return direct;
+  }
+  const containers = [
+    event && event.params,
+    event && event.metadata,
+    event && event.context,
+    event && event.ctx,
+    event && event.message,
+  ];
+  for (const container of containers) {
+    const value = extractStringField(container, keys);
+    if (value) {
+      return value;
+    }
+  }
+  return "";
+}
+
+function payloadResourceId(body) {
+  return extractStringField(body, ["resource_id", "resourceId", "conversation_id", "conversationId"]);
+}
+
+function payloadGroupId(body) {
+  return extractStringField(body, ["group_id", "groupId", "conversation_id", "conversationId"]);
+}
+
+function payloadUserId(body) {
+  return extractStringField(body, ["user_id", "userId", "sender_id", "senderId", "owner_id", "ownerId"]);
+}
+
+function isWriteTool(toolName) {
+  const normalized = normalizeToolName(toolName);
+  return normalized === "write" || normalized.endsWith("__write") || normalized === "write_file" || normalized.endsWith("__write_file");
+}
+
+function extractWritePath(params) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return "";
+  }
+  return extractStringField(params, [
+    "path",
+    "file_path",
+    "filePath",
+    "filename",
+    "fileName",
+    "target",
+    "target_path",
+    "targetPath",
+    "destination",
+  ]);
+}
+
+function rememberPendingFile(event) {
+  const params = event && event.params;
+  const writePath = extractWritePath(params);
+  if (!writePath || isURLLike(writePath)) {
+    return;
+  }
+  const store = getPendingFileStore();
+  pruneTimedMap(store, AUTO_UPLOAD_TTL_MS);
+  const resourceId = extractContextString(event, ["resource_id", "resourceId", "conversation_id", "conversationId"]);
+  const key = `${resourceId || "unknown"}:${writePath}`;
+  store.set(key, {
+    path: writePath,
+    resourceId,
+    createdAt: Date.now(),
+  });
+}
+
+function pendingCandidatesForPayload(body) {
+  const resourceId = payloadResourceId(body);
+  if (!resourceId) {
+    return [];
+  }
+  const store = getPendingFileStore();
+  pruneTimedMap(store, AUTO_UPLOAD_TTL_MS);
+  const out = [];
+  for (const entry of store.values()) {
+    if (!entry || entry.resourceId !== resourceId) {
+      continue;
+    }
+    const ref = { raw: entry.path, value: entry.path, kind: "pending" };
+    const resolved = resolveFileReference(ref);
+    if (resolved) {
+      out.push(resolved);
+    }
+  }
+  return out;
+}
+
+function gatewayURL() {
+  return (process.env.CLAW_GATEWAY_URL || DEFAULT_GATEWAY_INTERNAL_URL).replace(/\/$/, "");
+}
+
+function gatewayPublicURL() {
+  return (process.env.CLAW_GATEWAY_PUBLIC_URL || process.env.CLAW_GATEWAY_URL || DEFAULT_GATEWAY_PUBLIC_URL).replace(/\/$/, "");
+}
+
+function apiKey() {
+  return process.env.CLAW_GATEWAY_API_KEY || process.env.OPENCLAW_GATEWAY_API_KEY || "api-key-1";
+}
+
+function deriveReleaseName() {
+  let release = process.env.botID || process.env.OPENCLAW_RELEASE || process.env.BOT_ID || "";
+  if (!release) {
+    const tok = process.env.OPENCLAW_GATEWAY_TOKEN || "";
+    if (tok.indexOf("oc-") === 0) {
+      release = tok.slice(3);
+    }
+  }
+  return release;
+}
+
+function httpJSONRequest(method, requestPath, body) {
+  return new Promise((resolve, reject) => {
+    let parsed;
+    try {
+      parsed = new URL(gatewayURL() + requestPath);
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    const isHTTPS = parsed.protocol === "https:";
+    const transport = isHTTPS ? https : http;
+    const bodyStr = body ? JSON.stringify(body) : "";
+    const req = transport.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port || (isHTTPS ? 443 : 80),
+        path: parsed.pathname + (parsed.search || ""),
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": apiKey(),
+          "Content-Length": Buffer.byteLength(bodyStr),
+        },
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString("utf8");
+          let obj;
+          try {
+            obj = JSON.parse(text);
+          } catch (_err) {
+            reject(new Error(`gateway ${res.statusCode}: non-JSON response: ${text.slice(0, 200)}`));
+            return;
+          }
+          if (res.statusCode >= 400) {
+            reject(new Error(`gateway ${res.statusCode}: ${obj.message || text.slice(0, 200)}`));
+            return;
+          }
+          resolve(obj);
+        });
+      },
+    );
+    req.on("error", reject);
+    if (bodyStr) {
+      req.write(bodyStr);
+    }
+    req.end();
+  });
+}
+
+function uploadCacheKey(candidate, resourceId) {
+  return `${resourceId || ""}:${candidate.path}:${candidate.mtimeMs || 0}:${candidate.size || 0}`;
+}
+
+async function uploadCandidate(candidate, body) {
+  const resourceId = payloadResourceId(body);
+  const cache = getUploadCache();
+  pruneTimedMap(cache, AUTO_UPLOAD_TTL_MS);
+  const cacheKey = uploadCacheKey(candidate, resourceId);
+  const cached = cache.get(cacheKey);
+  if (cached && cached.result) {
+    return cached.result;
+  }
+
+  const stat = safeStat(candidate.path);
+  if (!stat) {
+    throw new Error(`file no longer exists: ${candidate.fileName}`);
+  }
+  const requestBody = {
+    resourceId,
+    groupId: payloadGroupId(body),
+    userId: payloadUserId(body),
+    release: deriveReleaseName(),
+    type: deliverableTypeForPath(candidate.path, stat.isDirectory()),
+    fileName: candidate.fileName || path.basename(candidate.path),
+  };
+  if (stat.isDirectory()) {
+    const files = collectDirectoryFiles(candidate.path);
+    if (files.length === 0) {
+      throw new Error(`directory has no uploadable files: ${candidate.fileName}`);
+    }
+    requestBody.files = files;
+  } else {
+    if (stat.size > AUTO_UPLOAD_MAX_BYTES) {
+      throw new Error(`file exceeds auto-upload limit: ${candidate.fileName}`);
+    }
+    requestBody.contentBase64 = fs.readFileSync(candidate.path).toString("base64");
+  }
+
+  const response = await httpJSONRequest("POST", "/openclaw-gateway/be/deliverables", requestBody);
+  const data = response.data || response;
+  const previewURL = data.previewUrl || `${gatewayPublicURL()}/openclaw-gateway/preview/${data.uuid}`;
+  const result = {
+    fileName: requestBody.fileName,
+    uuid: data.uuid,
+    previewURL,
+    downloadURL: data.downloadUrl || previewURL,
+  };
+  cache.set(cacheKey, { result, createdAt: Date.now() });
+  return result;
+}
+
+function dedupeCandidates(candidates) {
+  const out = [];
+  const seen = new Set();
+  for (const candidate of candidates) {
+    if (!candidate || !candidate.path) {
+      continue;
+    }
+    const key = path.resolve(candidate.path);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    out.push(candidate);
+    if (out.length >= AUTO_UPLOAD_MAX_FILES) {
+      break;
+    }
+  }
+  return out;
+}
+
+function escapeMarkdownLabel(label) {
+  return String(label || "文件").replace(/[[\]()`]/g, "");
+}
+
+function removeInternalPathLeaks(text, candidates) {
+  let out = String(text || "");
+  for (const candidate of candidates) {
+    if (!candidate || !candidate.raw) {
+      continue;
+    }
+    out = out.split(candidate.raw).join(candidate.fileName || path.basename(candidate.path));
+  }
+  return out;
+}
+
+function appendDeliverableLinks(text, uploads) {
+  const lines = [];
+  uploads.forEach((upload) => {
+    const label = escapeMarkdownLabel(upload.fileName);
+    if (upload.previewURL) {
+      lines.push(`预览链接：[${label}](${upload.previewURL})`);
+    }
+    if (upload.downloadURL && upload.downloadURL !== upload.previewURL) {
+      lines.push(`下载链接：[${label}](${upload.downloadURL})`);
+    }
+  });
+  if (lines.length === 0) {
+    return text;
+  }
+  return `${String(text || "").trim()}\n\n交付物链接：\n${lines.join("\n")}`;
+}
+
+function hasTrustedDeliverableLink(text) {
+  return splitDeliverableMessage(text) !== null;
+}
+
+function shouldSkipAutoUploadPayload(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return true;
+  }
+  if (!isString(body.content) || !body.content.trim()) {
+    return true;
+  }
+  if (body.stream_id || body.seq !== undefined || body.delta !== undefined || body.is_final !== undefined) {
+    return true;
+  }
+  if (body.palz_msg_type || body.tool_content) {
+    return true;
+  }
+  return false;
+}
+
+async function autoUploadAndRewritePayload(body, api) {
+  if (shouldSkipAutoUploadPayload(body) || hasTrustedDeliverableLink(body.content)) {
+    return body;
+  }
+  const refs = extractFileReferencesFromText(body.content);
+  const explicitCandidates = refs.map(resolveFileReference).filter(Boolean);
+  const candidates = dedupeCandidates(explicitCandidates.concat(pendingCandidatesForPayload(body)));
+  if (candidates.length === 0) {
+    return body;
+  }
+
+  const uploads = [];
+  const failures = [];
+  for (const candidate of candidates) {
+    try {
+      uploads.push(await uploadCandidate(candidate, body));
+    } catch (err) {
+      failures.push({ candidate, error: err });
+      api.logger.warn?.(
+        `[plugin-deliverables] auto-upload failed file=${candidate.fileName || candidate.path} error=${err.message}`,
+      );
+    }
+  }
+  if (uploads.length === 0) {
+    if (explicitCandidates.length === 0) {
+      return body;
+    }
+    const next = Object.assign({}, body);
+    next.content = "交付物上传失败，已阻止发送工作区内部文件路径。请稍后重试或联系管理员排查上传链路。";
+    return next;
+  }
+  const next = Object.assign({}, body);
+  next.content = appendDeliverableLinks(removeInternalPathLeaks(body.content, candidates), uploads);
+  if (failures.length > 0) {
+    next.content += `\n\n另有 ${failures.length} 个文件上传失败，已避免发送内部路径。`;
+  }
+  api.logger.info?.(
+    `[plugin-deliverables] auto-uploaded ${uploads.length} workspace file(s) for target=${String(body.conversation_id || "")}`,
+  );
+  return next;
+}
+
 function getSummaryCache() {
   if (!globalThis[SUMMARY_CACHE_KEY] || !(globalThis[SUMMARY_CACHE_KEY] instanceof Map)) {
     globalThis[SUMMARY_CACHE_KEY] = new Map();
@@ -392,16 +1103,97 @@ function extractDeliverableURL(line) {
   return "";
 }
 
+function configuredGatewayHosts() {
+  const values = [
+    process.env.CLAW_GATEWAY_PUBLIC_URL,
+    process.env.CLAW_GATEWAY_URL,
+    DEFAULT_GATEWAY_PUBLIC_URL,
+    DEFAULT_GATEWAY_INTERNAL_URL,
+  ];
+  const hosts = new Set();
+  for (const value of values) {
+    if (!isString(value) || !value.trim()) {
+      continue;
+    }
+    try {
+      const parsed = new URL(value.trim());
+      hosts.add(parsed.host.toLowerCase());
+      hosts.add(parsed.hostname.toLowerCase());
+    } catch (_err) {
+      // Ignore malformed configuration placeholders.
+    }
+  }
+  return hosts;
+}
+
+function isTrustedDeliverableURL(rawURL) {
+  if (!isString(rawURL) || !rawURL.trim()) {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = new URL(rawURL.trim());
+  } catch (_err) {
+    return false;
+  }
+  if (!DELIVERABLE_GATEWAY_PATH_RE.test(parsed.pathname)) {
+    return false;
+  }
+  const hosts = configuredGatewayHosts();
+  const host = parsed.host.toLowerCase();
+  const hostname = parsed.hostname.toLowerCase();
+  return hosts.has(host) || hosts.has(hostname);
+}
+
+function isOSSLikeURL(rawURL) {
+  if (!isString(rawURL) || !rawURL.trim()) {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = new URL(rawURL.trim());
+  } catch (_err) {
+    return false;
+  }
+  const host = parsed.hostname.toLowerCase();
+  return (
+    host.includes("aliyuncs.com") ||
+    host.includes("oss-cn-") ||
+    parsed.searchParams.has("OSSAccessKeyId")
+  );
+}
+
+function findUntrustedOSSDeliverableURL(text) {
+  const normalized = String(text || "").replace(/\r\n/g, "\n");
+  if (!normalized.trim()) {
+    return "";
+  }
+  const lines = normalized.split("\n");
+  let hasTrustedDeliverableURL = false;
+  let firstSuspiciousURL = "";
+  for (const line of lines) {
+    const url = extractDeliverableURL(line);
+    if (!url) {
+      continue;
+    }
+    if (isTrustedDeliverableURL(url)) {
+      hasTrustedDeliverableURL = true;
+      continue;
+    }
+    if (!firstSuspiciousURL && DELIVERABLE_LINK_PREFIX_RE.test(line) && isOSSLikeURL(url)) {
+      firstSuspiciousURL = url;
+    }
+  }
+  return !hasTrustedDeliverableURL ? firstSuspiciousURL : "";
+}
+
 function isDeliverableLinkLine(line) {
   const text = String(line || "");
-  if (
-    /^\s*(?:[-*+]\s+)?(?:预览链接|下载链接|文件列表|项目入口|在线预览|在线体验|目录链接)\s*[:：]\s*\[[^\]]+\]\([^)]+\)\s*$/u.test(
-      text,
-    )
-  ) {
-    return true;
+  const url = extractDeliverableURL(text);
+  if (!url || !isTrustedDeliverableURL(url)) {
+    return false;
   }
-  return !!extractDeliverableURL(text);
+  return DELIVERABLE_LINK_LABEL_RE.test(text) || !!url;
 }
 
 function splitDeliverableMessage(text) {
@@ -456,6 +1248,7 @@ function splitDeliverableMessage(text) {
   return {
     summary,
     links,
+    linkUrls,
     primaryLinkUrl: linkUrls.length > 0 ? linkUrls[0] : "",
   };
 }
@@ -478,6 +1271,14 @@ function cloneBodyAsFileLink(body, fileUrl, suffix) {
   return next;
 }
 
+function cloneBodyAsBlockedDeliverableLink(body) {
+  return cloneBody(
+    body,
+    "交付物上传未成功，已阻止发送未通过 gateway 交付物系统生成的 OSS 文件链接。请重新通过交付物上传工具上传后再发送。",
+    "",
+  );
+}
+
 function shouldSplitPalzPayload(body) {
   if (!body || typeof body !== "object" || Array.isArray(body)) {
     return null;
@@ -580,13 +1381,29 @@ function installPalzFetchPatch(api) {
       return originalFetch(input, init);
     }
 
+    const rewritten = await autoUploadAndRewritePayload(parsed, api);
+    if (rewritten !== parsed) {
+      parsed = rewritten;
+    }
+
     const split = shouldSplitPalzPayload(parsed);
     if (!split) {
+      const suspiciousURL = isString(parsed.content)
+        ? findUntrustedOSSDeliverableURL(parsed.content)
+        : "";
+      if (suspiciousURL) {
+        const blockedBody = cloneBodyAsBlockedDeliverableLink(parsed);
+        const blockedBodyStr = JSON.stringify(blockedBody);
+        api.logger.warn?.(
+          `[plugin-deliverables] blocked untrusted OSS deliverable link target=${String(parsed.conversation_id || "")} url=${suspiciousURL}`,
+        );
+        return originalFetch(input, Object.assign({}, init, { body: blockedBodyStr }));
+      }
       return originalFetch(input, init);
     }
 
     const summaryBody = cloneBody(parsed, split.summary, "__summary");
-    const linksBody = split.primaryLinkUrl
+    const linksBody = split.primaryLinkUrl && (!Array.isArray(split.linkUrls) || split.linkUrls.length === 1)
       ? cloneBodyAsFileLink(parsed, split.primaryLinkUrl, "__links")
       : cloneBody(parsed, split.links, "__links");
     const summaryBodyStr = JSON.stringify(summaryBody);
@@ -650,6 +1467,10 @@ const plugin = {
         cacheUploadSummary(event.params);
         return;
       }
+      if (isWriteTool(event.toolName)) {
+        rememberPendingFile(event);
+        return;
+      }
       if (!isOutboundMessageTool(event.toolName)) {
         return;
       }
@@ -679,5 +1500,16 @@ const plugin = {
   },
 };
 
+plugin.__test = {
+  deliverableTypeForPath,
+  extractFileReferencesFromText,
+  extractDeliverableURL,
+  findUntrustedOSSDeliverableURL,
+  isDeliverableLinkLine,
+  isOSSLikeURL,
+  isTrustedDeliverableURL,
+  splitDeliverableMessage,
+};
+
 module.exports = plugin;
 module.exports.default = plugin;