@fieldwangai/agentflow 0.1.41 → 0.1.43

package/bin/lib/ui-server.mjs

@@ -108,8 +108,13 @@ const MIME = {
   ".js": "text/javascript; charset=utf-8",
   ".css": "text/css; charset=utf-8",
   ".json": "application/json; charset=utf-8",
-  ".ico": "image/x-icon",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
   ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
 };
 
 const RUN_CONFIG_FILENAME = "run-config.json";
@@ -136,11 +141,35 @@ const BUILTIN_SKILL_COLLECTIONS = [
       "agentflow-workspace-markdown",
       "agentflow-workspace-mermaid",
       "agentflow-workspace-ascii",
+      "agentflow-workspace-chart",
+      "agentflow-workspace-table",
+      "agentflow-workspace-html",
+      "agentflow-workspace-image",
       "agentflow-node-reference",
       "agentflow-placeholder-reference",
       "agentflow-runtime-reference",
     ],
     legacyDefaultKeys: [
+      [
+        "agentflow-workspace-graph",
+        "agentflow-workspace-markdown",
+        "agentflow-workspace-mermaid",
+        "agentflow-workspace-ascii",
+        "agentflow-workspace-chart",
+        "agentflow-workspace-table",
+        "agentflow-node-reference",
+        "agentflow-placeholder-reference",
+        "agentflow-runtime-reference",
+      ],
+      [
+        "agentflow-workspace-graph",
+        "agentflow-workspace-markdown",
+        "agentflow-workspace-mermaid",
+        "agentflow-workspace-ascii",
+        "agentflow-node-reference",
+        "agentflow-placeholder-reference",
+        "agentflow-runtime-reference",
+      ],
       [
         "agentflow-flow-add-instances",
         "agentflow-flow-edit-node-fields",
@@ -1101,6 +1130,7 @@ const WORKSPACE_TEXT_EXTS = new Set([
   ".mjs",
   ".cjs",
 ]);
+const WORKSPACE_IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"]);
 
 function resolveWorkspaceFilePath(workspaceRoot, relPath) {
   const root = path.resolve(workspaceRoot);
@@ -1120,9 +1150,33 @@ function workspaceFileIcon(fileName, isDir = false) {
   if ([".yaml", ".yml", ".json"].includes(ext)) return "data_object";
   if (ext === ".css") return "palette";
   if (ext === ".html") return "web";
+  if (WORKSPACE_IMAGE_EXTS.has(ext)) return "image";
   return "draft";
 }
 
+function sanitizeWorkspaceUploadName(filename) {
+  const parsed = path.parse(String(filename || "image").replace(/\\/g, "/").split("/").pop() || "image");
+  const stem = (parsed.name || "image")
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80) || "image";
+  const ext = String(parsed.ext || "").toLowerCase();
+  return `${stem}${WORKSPACE_IMAGE_EXTS.has(ext) ? ext : ".png"}`;
+}
+
+function uniqueWorkspaceRelPath(workspaceRoot, relPath) {
+  let { abs, rel } = resolveWorkspaceFilePath(workspaceRoot, relPath);
+  if (!fs.existsSync(abs)) return { abs, rel };
+  const parsed = path.parse(rel);
+  for (let i = 1; i < 1000; i += 1) {
+    const candidate = path.posix.join(parsed.dir, `${parsed.name}-${i}${parsed.ext}`);
+    const resolved = resolveWorkspaceFilePath(workspaceRoot, candidate);
+    if (!fs.existsSync(resolved.abs)) return resolved;
+  }
+  return { abs, rel };
+}
+
 function readWorkspaceFilesRecursive(dir, root, depth = 0, maxDepth = 3, budget = { count: 0 }) {
   if (depth > maxDepth || budget.count > 500) return [];
   let entries;
@@ -1150,7 +1204,7 @@ function readWorkspaceFilesRecursive(dir, root, depth = 0, maxDepth = 3, budget
     } else if (entry.isFile()) {
       if (WORKSPACE_FILE_SKIP_FILES.has(entry.name)) continue;
       const ext = path.extname(entry.name).toLowerCase();
-      if (!WORKSPACE_TEXT_EXTS.has(ext)) continue;
+      if (!WORKSPACE_TEXT_EXTS.has(ext) && !WORKSPACE_IMAGE_EXTS.has(ext)) continue;
       let size = 0;
       try { size = fs.statSync(abs).size; } catch {}
       budget.count++;
@@ -1420,20 +1474,123 @@ function workspaceUnescapeLooseJsonString(value) {
     .trim();
 }
 
+function workspaceFindMatchingDelimiter(text, openIndex, openChar = "{", closeChar = "}") {
+  const raw = String(text || "");
+  if (raw[openIndex] !== openChar) return -1;
+  let depth = 0;
+  let quote = "";
+  let escaped = false;
+  for (let i = openIndex; i < raw.length; i += 1) {
+    const ch = raw[i];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === quote) {
+        quote = "";
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === openChar) depth += 1;
+    if (ch === closeChar) {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+function workspaceParseLooseJsonValue(text, startIndex, limitIndex = String(text || "").length) {
+  const raw = String(text || "");
+  let i = startIndex;
+  while (i < limitIndex && /\s/.test(raw[i])) i += 1;
+  if (i >= limitIndex) return { value: "", end: i };
+  const ch = raw[i];
+  if (ch === "{" || ch === "[") {
+    const close = workspaceFindMatchingDelimiter(raw, i, ch, ch === "{" ? "}" : "]");
+    const end = close >= 0 ? close + 1 : limitIndex;
+    const slice = raw.slice(i, end).trim();
+    try {
+      return { value: workspaceStringifyOutputValue(JSON.parse(slice)), end };
+    } catch {
+      return { value: slice, end };
+    }
+  }
+  if (ch === '"' || ch === "'") {
+    const quote = ch;
+    let escaped = false;
+    let end = i + 1;
+    for (; end < limitIndex; end += 1) {
+      const c = raw[end];
+      if (escaped) {
+        escaped = false;
+      } else if (c === "\\") {
+        escaped = true;
+      } else if (c === quote) {
+        break;
+      }
+    }
+    const body = raw.slice(i + 1, end < limitIndex ? end : limitIndex);
+    return { value: workspaceUnescapeLooseJsonString(body), end: Math.min(end + 1, limitIndex) };
+  }
+  let end = i;
+  while (end < limitIndex && raw[end] !== "," && raw[end] !== "\n" && raw[end] !== "\r" && raw[end] !== "}") end += 1;
+  const slice = raw.slice(i, end).trim().replace(/^["'`]|["'`]$/g, "");
+  return { value: workspaceUnescapeLooseJsonString(slice), end };
+}
+
 function workspaceExtractLooseOutParams(raw) {
   const text = String(raw || "");
   const out = {};
   const startMatch = /["']outParams["']\s*:\s*\{/i.exec(text);
   if (!startMatch) return out;
-  const start = startMatch.index + startMatch[0].length;
-  const end = text.indexOf("}", start);
-  const block = end >= start ? text.slice(start, end) : text.slice(start);
-  const pairRe = /["']?([A-Za-z_][A-Za-z0-9_-]*)["']?\s*:\s*(?:"([^"]*)"|'([^']*)'|([^,\n\r}]+))/g;
-  let match;
-  while ((match = pairRe.exec(block))) {
-    const key = String(match[1] || "").trim();
-    const value = match[2] ?? match[3] ?? match[4] ?? "";
-    if (key) out[key] = workspaceUnescapeLooseJsonString(value).replace(/^["'`]|["'`]$/g, "").trim();
+  const openIndex = text.indexOf("{", startMatch.index);
+  const closeIndex = workspaceFindMatchingDelimiter(text, openIndex);
+  const endLimit = closeIndex >= 0 ? closeIndex : text.length;
+  const block = text.slice(openIndex, closeIndex >= 0 ? closeIndex + 1 : text.length);
+  try {
+    const parsed = JSON.parse(block);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      for (const [key, value] of Object.entries(parsed)) {
+        const name = String(key || "").trim();
+        if (name) out[name] = workspaceStringifyOutputValue(value);
+      }
+      return out;
+    }
+  } catch {
+    /* fall through to loose top-level scanning */
+  }
+  let i = openIndex + 1;
+  while (i < endLimit) {
+    while (i < endLimit && /[\s,]/.test(text[i])) i += 1;
+    if (i >= endLimit) break;
+    let key = "";
+    if (text[i] === '"' || text[i] === "'") {
+      const quote = text[i];
+      const keyStart = i + 1;
+      i = keyStart;
+      while (i < endLimit && text[i] !== quote) i += 1;
+      key = text.slice(keyStart, i).trim();
+      i += 1;
+    } else {
+      const keyStart = i;
+      while (i < endLimit && /[A-Za-z0-9_-]/.test(text[i])) i += 1;
+      key = text.slice(keyStart, i).trim();
+    }
+    while (i < endLimit && /\s/.test(text[i])) i += 1;
+    if (text[i] !== ":") {
+      i += 1;
+      continue;
+    }
+    i += 1;
+    const parsedValue = workspaceParseLooseJsonValue(text, i, endLimit);
+    if (key) out[key] = String(parsedValue.value ?? "").trim();
+    i = parsedValue.end;
   }
   return out;
 }
@@ -2528,6 +2685,47 @@ function parseFlowsImportForm(req) {
   });
 }
 
+function parseWorkspaceUploadForm(req) {
+  return new Promise((resolve, reject) => {
+    const bb = busboy({
+      headers: req.headers,
+      limits: { files: 1, fileSize: 10 * 1024 * 1024, parts: 32 },
+    });
+    const fields = {};
+    const chunks = [];
+    let filename = "";
+    let mimeType = "";
+    let gotFile = false;
+    bb.on("field", (name, val) => {
+      fields[String(name || "")] = String(val || "");
+    });
+    bb.on("file", (name, file, info) => {
+      if (name !== "file") {
+        file.resume();
+        return;
+      }
+      gotFile = true;
+      filename = info.filename || "";
+      mimeType = info.mimeType || "";
+      file.on("data", (d) => chunks.push(d));
+      file.on("limit", () => {
+        reject(new Error("FILE_TOO_LARGE"));
+      });
+    });
+    bb.on("finish", () => {
+      resolve({
+        fields,
+        file: Buffer.concat(chunks),
+        filename,
+        mimeType,
+        gotFile,
+      });
+    });
+    bb.on("error", reject);
+    req.pipe(bb);
+  });
+}
+
 /** GET 读 flow / nodes / SSE 等 */
 function isValidFlowSourceRead(s) {
   return s === "builtin" || s === "admin" || s === "user" || s === "workspace";
@@ -3295,6 +3493,37 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/workspace/file/raw") {
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: url.searchParams.get("flowId") || "",
+          flowSource: url.searchParams.get("flowSource") || "user",
+          archived: url.searchParams.get("archived") === "1",
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        const { abs } = resolveWorkspaceFilePath(scoped.root, url.searchParams.get("path") || "");
+        if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) {
+          json(res, 404, { error: "File not found" });
+          return;
+        }
+        const ext = path.extname(abs).toLowerCase();
+        const type = MIME[ext] || "application/octet-stream";
+        const data = fs.readFileSync(abs);
+        res.writeHead(200, {
+          "Content-Type": type,
+          "Content-Length": data.length,
+          "Cache-Control": "no-store",
+        });
+        res.end(data);
+      } catch (e) {
+        json(res, /traversal/i.test(String(e.message || e)) ? 403 : 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/workspace/file") {
       let payload;
       try {
@@ -3331,6 +3560,54 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workspace/upload") {
+      let parsed;
+      try {
+        parsed = await parseWorkspaceUploadForm(req);
+      } catch (e) {
+        json(res, /FILE_TOO_LARGE/.test(String(e.message || e)) ? 413 : 400, { error: (e && e.message) || String(e) });
+        return;
+      }
+      try {
+        if (!parsed.gotFile || !parsed.file.length) {
+          json(res, 400, { error: "Missing upload file" });
+          return;
+        }
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: parsed.fields.flowId || "",
+          flowSource: parsed.fields.flowSource || "user",
+          archived: parsed.fields.archived === "1" || parsed.fields.archived === "true" || parsed.fields.flowArchived === "true",
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+          json(res, 400, { error: "Cannot write to builtin or archived pipeline workspace" });
+          return;
+        }
+        const safeName = sanitizeWorkspaceUploadName(parsed.filename);
+        const ext = path.extname(safeName).toLowerCase();
+        if (!WORKSPACE_IMAGE_EXTS.has(ext) || (parsed.mimeType && !/^image\//i.test(parsed.mimeType))) {
+          json(res, 400, { error: "Only image uploads are supported" });
+          return;
+        }
+        const targetDir = String(parsed.fields.dir || "img").trim().replace(/^[/\\]+/, "") || "img";
+        const target = uniqueWorkspaceRelPath(scoped.root, path.posix.join(targetDir.replace(/\\/g, "/"), safeName));
+        fs.mkdirSync(path.dirname(target.abs), { recursive: true });
+        fs.writeFileSync(target.abs, parsed.file);
+        json(res, 200, {
+          ok: true,
+          path: target.rel,
+          size: parsed.file.length,
+          mimeType: parsed.mimeType,
+        });
+      } catch (e) {
+        json(res, /traversal/i.test(String(e.message || e)) ? 403 : 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/workspace/folder") {
       let payload;
       try {