@fre4x/comfyui 1.0.61 → 1.0.64

package/README.md

@@ -4,18 +4,12 @@ An MCP server to interact with ComfyUI remotely. Probe server state, inspect nod
 
 ## Tools
 
-- `comfyui_get_system_info`: Get server hardware and software status.
-- `comfyui_list_object_info`: List available nodes and their schema (inputs/outputs).
-- `comfyui_execute_workflow`: Submit a workflow in API JSON format.
-- `comfyui_list_workflows`: List stored reusable workflows.
-- `comfyui_search_workflows`: Search stored workflows by name, tag, or description.
-- `comfyui_get_workflow`: Inspect a stored workflow and its editable inputs.
-- `comfyui_save_workflow`: Save a workflow for later reuse.
-- `comfyui_run_workflow`: Run a stored workflow with optional overrides.
-- `comfyui_get_history`: Retrieve job history and outputs.
+- `comfyui_inspect_node`: List available nodes or inspect one node schema.
+- `comfyui_discover_workflows`: Scan known workflow directories for stored JSON files.
+- `comfyui_get_workflow`: Normalize a stored workflow and list its editable inputs.
+- `comfyui_save_workflow`: Save a workflow into local `./workflows` with optional edits.
+- `comfyui_workflow_run`: Run a stored workflow with optional overrides.
 - `comfyui_wait_for_workflow`: Wait for workflow completion with a timeout.
-- `comfyui_get_queue`: Check current server queue.
-- `comfyui_get_view_url`: Get a direct URL for a generated file.
 
 **Do not assume `structuredContent` is what the model actually sees.** Many MCP clients
 surface `content.text` to the model first and treat `structuredContent` as secondary
@@ -28,7 +22,6 @@ IDs, and recovery hints.
 ### Environment Variables
 
 - `COMFYUI_SERVER_URL`: The URL of your ComfyUI server (default: `http://localhost:8188`).
-- `COMFYUI_WORKFLOWS_DIR`: Directory used for saved workflow registry files (default: `~/.fre4x-comfyui/workflows`).
 - `MOCK`: Set to `true` to use mock data instead of a real server.
 
 ### Claude Desktop Configuration
@@ -57,35 +50,60 @@ MOCK=true npx @fre4x/comfyui
 
 ## Workflow API Format
 
-Note: To use `comfyui_execute_workflow`, you must use the **API Format** JSON. In ComfyUI, enable "Developer Mode" in settings, then click "Save (API Format)". This format differs from the standard workflow JSON.
+`comfyui_workflow_run` and `comfyui_save_workflow` both normalize workflows into
+ComfyUI **API Format** before execution or persistence. In ComfyUI, enable
+"Developer Mode" in settings, then click "Save (API Format)" if you want the
+raw graph JSON. Standard Web UI workflow JSON is also accepted and normalized
+automatically.
 
 If you want a single call that submits and waits, pass `await: true` with a
-`timeout` value in seconds to `comfyui_execute_workflow`. For lower-level
-control, use `comfyui_wait_for_workflow` with `prompt_id`,
-`timeout_seconds`, and `poll_interval_ms`.
+`timeout` value in seconds to `comfyui_workflow_run`. For lower-level control,
+use `comfyui_wait_for_workflow` with `prompt_id` and `timeout`.
 
 ## Stored Workflow Reuse
 
-The workflow registry tools let you avoid re-sending large API JSON blobs.
+The stored-workflow tools let you avoid re-sending large API JSON blobs and give
+agents a stable local edit loop.
 
-1. Save a workflow with `comfyui_save_workflow`
-2. Inspect it with `comfyui_get_workflow`
-3. Reuse it with `comfyui_run_workflow`
+1. Save a workflow with `comfyui_save_workflow` into local `./workflows`
+2. Inspect editable paths with `comfyui_get_workflow`
+3. Persist edits with `comfyui_save_workflow` overrides
+4. Reuse it with `comfyui_workflow_run`
 
-`comfyui_run_workflow` accepts structured overrides in this form:
+`comfyui_workflow_run` and `comfyui_save_workflow` both accept dot-notation
+overrides in this form:
 
 ```json
 {
   "workflow_id": "pony-portrait-v1",
-  "overrides": [
-    {
-      "node_id": "2",
-      "input_name": "seed",
-      "value": 67890
-    }
-  ],
+  "overrides": {
+    "2.inputs.seed": 67890,
+    "6.inputs.text": "cinematic dragon portrait"
+  },
   "await": true,
-  "timeout": 90,
-  "require_images": true
+  "timeout": 90
+}
+```
+
+To inspect editable inputs and semantic hints for agent editing:
+
+```json
+{
+  "workflow_id": "pony-portrait-v1",
+  "include_prompt": false
+}
+```
+
+To save a new or edited workflow locally:
+
+```json
+{
+  "workflow_file_path": "pony-portrait-v1.json",
+  "overrides": {
+    "6.inputs.text": "studio lighting, ultra detailed",
+    "7.inputs.filename_prefix": "pony-portrait-agent"
+  },
+  "output_file_name": "pony-portrait-agent.json",
+  "overwrite": true
 }
 ```

package/dist/index.js

@@ -30630,9 +30630,16 @@ function convertWebUIToAPI(webUIJson, objectInfo) {
   const prompt = {};
   const links = webUIJson.links || [];
   const nodes = webUIJson.nodes || [];
+  const serverNodeIds = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (!node.id || !node.type || !objectInfo[node.type]) {
+      continue;
+    }
+    serverNodeIds.add(String(node.id));
+  }
   const linkMap = /* @__PURE__ */ new Map();
   for (const link of links) {
-    if (isLinkData(link)) {
+    if (isLinkData(link) && serverNodeIds.has(String(link[3]))) {
       linkMap.set(link[0], link);
     }
   }
@@ -30650,7 +30657,7 @@ function convertWebUIToAPI(webUIJson, objectInfo) {
       for (const input of node.inputs) {
         if (input.name && input.link !== null && input.link !== void 0) {
           const linkData = linkMap.get(input.link);
-          if (Array.isArray(linkData) && linkData.length >= 6) {
+          if (Array.isArray(linkData) && linkData.length >= 6 && String(linkData[3]) === nodeIdStr) {
             const originNodeId = String(linkData[1]);
             const originSlot = linkData[2];
             promptNode.inputs[input.name] = [
@@ -30723,6 +30730,14 @@ var ComfyApiError = class extends Error {
     this.name = "ComfyApiError";
   }
 };
+var WorkflowInputError = class extends Error {
+  constructor(message, field, kind = "validation") {
+    super(message);
+    this.field = field;
+    this.kind = kind;
+    this.name = "WorkflowInputError";
+  }
+};
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -30832,7 +30847,7 @@ async function fetchComfyJson(apiPath, options) {
   }
   return body;
 }
-async function fetchImageBase64(filename, type, subfolder) {
+async function fetchImageAsset(filename, type, subfolder) {
   const params = new URLSearchParams({ filename, type });
   if (subfolder) params.set("subfolder", subfolder);
   const url2 = new URL(
@@ -30845,10 +30860,47 @@ async function fetchImageBase64(filename, type, subfolder) {
   const arrayBuffer = await response.arrayBuffer();
   const mimeType = response.headers.get("content-type") || "image/png";
   return {
-    data: Buffer.from(arrayBuffer).toString("base64"),
+    buffer: Buffer.from(arrayBuffer),
     mimeType
   };
 }
+function createMockImageAsset() {
+  return {
+    buffer: Buffer.from("mock-image-data"),
+    mimeType: "image/png"
+  };
+}
+function getSessionWorkspaceDir() {
+  return process.env.MCP_WORKSPACE_DIR;
+}
+function getSafePathSegments(subfolder) {
+  if (!subfolder) return [];
+  return subfolder.split(/[/\\]/).filter((s) => s.length > 0 && s !== ".." && s !== ".");
+}
+async function saveToWorkspace(promptId, image, asset) {
+  const workspaceDir = getSessionWorkspaceDir();
+  if (!workspaceDir) {
+    return void 0;
+  }
+  const safeFileName = path.basename(image.filename);
+  const safeSubfolderSegments = getSafePathSegments(image.subfolder);
+  const relativePath = path.join(
+    "comfyui",
+    promptId,
+    ...safeSubfolderSegments,
+    safeFileName
+  );
+  const workspacePath = path.join(workspaceDir, relativePath);
+  await fs.mkdir(path.dirname(workspacePath), { recursive: true });
+  await fs.writeFile(workspacePath, asset.buffer);
+  return {
+    workspace_path: workspacePath,
+    relative_path: relativePath,
+    filename: safeFileName,
+    mime_type: asset.mimeType,
+    subfolder: image.subfolder
+  };
+}
 function handleComfyError(error48) {
   if (error48 instanceof ZodError) {
     return createValidationError(
@@ -30856,6 +30908,9 @@ function handleComfyError(error48) {
       error48.issues[0]?.message || "Invalid input."
     );
   }
+  if (error48 instanceof WorkflowInputError) {
+    return error48.kind === "not_found" ? createNotFoundError(error48.message) : createValidationError(error48.field, error48.message);
+  }
   if (error48 instanceof ComfyApiError) {
     const detailSummary = summarizeComfyErrorDetails(error48.details);
     return {
@@ -30870,11 +30925,27 @@ ${detailSummary}` : error48.message
       isError: true
     };
   }
+  const errorMessage = error48 instanceof Error ? error48.message : String(error48);
+  if (errorMessage.includes("Timeout waiting for workflow")) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `${errorMessage}.
+
+The workflow is likely still running on the server. You can re-attach to it and wait for completion by calling 'comfyui_wait_for_workflow' again with the same prompt_id.`
+        }
+      ],
+      isError: true
+    };
+  }
   return createInternalError(error48);
 }
-async function validateWorkflowPath(targetPath) {
-  const resolvedPath = path.resolve(targetPath);
-  const allowedRoots = [
+function getWorkflowDirectories(extraPath) {
+  const directories = [
+    process.cwd(),
+    path.join(process.cwd(), "workflows"),
+    path.join(homedir(), ".fre4x-comfyui", "workflows"),
     path.join(
       homedir(),
       "comfy",
@@ -30882,24 +30953,291 @@ async function validateWorkflowPath(targetPath) {
       "user",
       "default",
       "workflows"
-    ),
-    path.join(homedir(), ".fre4x-comfyui", "workflows"),
-    path.join(process.cwd(), "workflows")
+    )
   ];
-  const isAllowed = allowedRoots.some(
-    (root) => resolvedPath.startsWith(path.resolve(root))
+  if (extraPath) {
+    directories.push(extraPath);
+  }
+  return directories;
+}
+function getWorkflowNameCandidates(name) {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  if (trimmed.endsWith(".json")) {
+    return [trimmed];
+  }
+  return [trimmed, `${trimmed}.json`];
+}
+function normalizeWorkflowFileName(fileName) {
+  const trimmed = fileName.trim();
+  if (trimmed.length === 0) {
+    throw new WorkflowInputError(
+      "Filename cannot be empty.",
+      "output_file_name"
+    );
+  }
+  return trimmed.endsWith(".json") ? trimmed : `${trimmed}.json`;
+}
+function isConnectionValue(value) {
+  return Array.isArray(value) && value.length >= 2 && (typeof value[0] === "string" || typeof value[0] === "number") && typeof value[1] === "number";
+}
+async function getObjectInfo() {
+  return IS_MOCK ? MOCK_FIXTURES.object_info : await fetchComfyJson(
+    "/object_info"
   );
-  if (!isAllowed) {
-    throw new Error(
-      `Access denied: ${targetPath} is outside allowed workflow directories.`
+}
+async function resolveWorkflowReference(args) {
+  if (args.workflow_file_path) {
+    const targetPath = args.workflow_file_path;
+    try {
+      const resolvedPath = path.resolve(targetPath);
+      const content = await fs.readFile(resolvedPath, "utf8");
+      return {
+        targetPath: resolvedPath,
+        content
+      };
+    } catch {
+      if (path.basename(targetPath) === targetPath) {
+        const candidates = getWorkflowNameCandidates(targetPath);
+        for (const dir of getWorkflowDirectories()) {
+          for (const candidate of candidates) {
+            const candidatePath = path.join(dir, candidate);
+            try {
+              const content = await fs.readFile(
+                candidatePath,
+                "utf8"
+              );
+              return {
+                targetPath: candidatePath,
+                content
+              };
+            } catch {
+            }
+          }
+        }
+      }
+      throw new WorkflowInputError(
+        `Workflow file not found: ${targetPath}`,
+        "workflow_file_path",
+        "not_found"
+      );
+    }
+  }
+  if (args.workflow_id) {
+    const requestedId = args.workflow_id.trim();
+    if (requestedId.length === 0) {
+      throw new WorkflowInputError(
+        "Workflow ID cannot be empty.",
+        "workflow_id"
+      );
+    }
+    for (const dir of getWorkflowDirectories()) {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isFile() || !entry.name.endsWith(".json")) {
+            continue;
+          }
+          const fullPath = path.join(dir, entry.name);
+          const defaultId = getWorkflowId(fullPath);
+          if (requestedId === defaultId || requestedId === entry.name.replace(/\.json$/, "")) {
+            return {
+              targetPath: fullPath,
+              content: await fs.readFile(fullPath, "utf8")
+            };
+          }
+        }
+      } catch {
+      }
+    }
+    throw new WorkflowInputError(
+      `Workflow ID not found: ${args.workflow_id}`,
+      "workflow_id",
+      "not_found"
     );
   }
+  throw new WorkflowInputError(
+    "Must provide either workflow_file_path or workflow_id.",
+    "workflow_id"
+  );
+}
+async function normalizeWorkflowPrompt(workflow) {
+  if (!isRecord(workflow)) {
+    throw new WorkflowInputError(
+      "Workflow must be a JSON object.",
+      "workflow"
+    );
+  }
+  let sourceFormat = "api";
+  let normalizedWorkflow = workflow;
+  if (isWebUIFormat(normalizedWorkflow)) {
+    sourceFormat = "webui";
+    normalizedWorkflow = convertWebUIToAPI(
+      normalizedWorkflow,
+      await getObjectInfo()
+    );
+  }
+  const prompt = isRecord(normalizedWorkflow.prompt) && normalizedWorkflow.prompt ? normalizedWorkflow.prompt : normalizedWorkflow;
+  if (!isRecord(prompt)) {
+    throw new WorkflowInputError(
+      "Workflow prompt must be a JSON object.",
+      "workflow"
+    );
+  }
+  return {
+    prompt,
+    sourceFormat
+  };
+}
+async function loadWorkflow(args) {
+  const { targetPath, content } = await resolveWorkflowReference(args);
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error48) {
+    throw new WorkflowInputError(
+      `Invalid JSON in ${targetPath}: ${error48 instanceof Error ? error48.message : String(error48)}`,
+      args.workflow_file_path ? "workflow_file_path" : "workflow_id"
+    );
+  }
+  const { prompt, sourceFormat } = await normalizeWorkflowPrompt(parsed);
+  return {
+    targetPath,
+    prompt,
+    sourceFormat
+  };
+}
+function inferEditableRole(nodeId, classType, inputName, consumerMap) {
+  if (classType === "CLIPTextEncode" && inputName === "text") {
+    const consumers = consumerMap.get(nodeId) ?? [];
+    if (consumers.some((consumer) => consumer.inputName === "positive")) {
+      return "positive_prompt";
+    }
+    if (consumers.some((consumer) => consumer.inputName === "negative")) {
+      return "negative_prompt";
+    }
+    return "prompt_text";
+  }
+  switch (inputName) {
+    case "seed":
+      return "seed";
+    case "steps":
+      return "steps";
+    case "cfg":
+      return "cfg";
+    case "sampler_name":
+      return "sampler";
+    case "scheduler":
+      return "scheduler";
+    case "denoise":
+      return "denoise";
+    case "width":
+      return "width";
+    case "height":
+      return "height";
+    case "batch_size":
+      return "batch_size";
+    case "ckpt_name":
+      return "checkpoint";
+    case "filename_prefix":
+      return "filename_prefix";
+    case "text":
+      return "text";
+    default:
+      return void 0;
+  }
+}
+function formatValuePreview(value) {
+  if (typeof value === "string") {
+    return value.length > 100 ? `${value.slice(0, 97)}...` : value;
+  }
   try {
-    await fs.access(resolvedPath);
-    return resolvedPath;
+    const serialized = JSON.stringify(value);
+    if (!serialized) {
+      return String(value);
+    }
+    return serialized.length > 100 ? `${serialized.slice(0, 97)}...` : serialized;
   } catch {
-    throw new Error(`Workflow file not found: ${targetPath}`);
+    return String(value);
+  }
+}
+function analyzeEditableInputs(prompt) {
+  const consumerMap = /* @__PURE__ */ new Map();
+  for (const [nodeId, rawNode] of Object.entries(prompt)) {
+    if (!isRecord(rawNode) || !isRecord(rawNode.inputs)) {
+      continue;
+    }
+    const classType = typeof rawNode.class_type === "string" ? rawNode.class_type : "";
+    if (!classType || ["Note", "MarkdownNote", "PrimitiveNode"].includes(classType) || nodeId === "meta") {
+      continue;
+    }
+    for (const [inputName, value] of Object.entries(rawNode.inputs)) {
+      if (!isConnectionValue(value)) {
+        continue;
+      }
+      const sourceNodeId = String(value[0]);
+      const consumers = consumerMap.get(sourceNodeId) ?? [];
+      consumers.push({
+        inputName,
+        classType,
+        nodeId
+      });
+      consumerMap.set(sourceNodeId, consumers);
+    }
+  }
+  const editableInputs = [];
+  for (const [nodeId, rawNode] of Object.entries(prompt)) {
+    if (!isRecord(rawNode) || !isRecord(rawNode.inputs)) {
+      continue;
+    }
+    const classType = typeof rawNode.class_type === "string" ? rawNode.class_type : "";
+    if (!classType || ["Note", "MarkdownNote", "PrimitiveNode"].includes(classType) || nodeId === "meta") {
+      continue;
+    }
+    for (const [inputName, value] of Object.entries(rawNode.inputs)) {
+      if (isConnectionValue(value)) {
+        continue;
+      }
+      editableInputs.push({
+        path: `${nodeId}.inputs.${inputName}`,
+        node_id: nodeId,
+        class_type: classType,
+        input_name: inputName,
+        value,
+        value_preview: formatValuePreview(value),
+        role: inferEditableRole(
+          nodeId,
+          classType,
+          inputName,
+          consumerMap
+        )
+      });
+    }
+  }
+  return editableInputs.sort(
+    (left, right) => left.path.localeCompare(right.path, void 0, { numeric: true })
+  );
+}
+function formatEditableInputsText(editableInputs) {
+  if (editableInputs.length === 0) {
+    return "No literal editable inputs were detected.";
+  }
+  return formatListItems(editableInputs, (entry) => {
+    const role = entry.role ? ` [${entry.role}]` : "";
+    const classType = entry.class_type ? ` (${entry.class_type})` : "";
+    return `${entry.path}${role}${classType}: ${entry.value_preview}`;
+  });
+}
+function deriveSavedWorkflowFileName(sourcePath, requestedName) {
+  if (requestedName) {
+    return normalizeWorkflowFileName(requestedName);
+  }
+  if (sourcePath) {
+    return normalizeWorkflowFileName(path.basename(sourcePath));
   }
+  return `workflow-${Date.now()}.json`;
 }
 function applyOverrides(prompt, overrides) {
   for (const [key, value] of Object.entries(overrides)) {
@@ -30908,7 +31246,10 @@ function applyOverrides(prompt, overrides) {
     for (let i = 0; i < parts.length - 1; i++) {
       const part = parts[i];
       if (typeof current[part] !== "object" || current[part] === null) {
-        current[part] = {};
+        throw new WorkflowInputError(
+          `Invalid override path: '${key}'. The segment '${part}' does not exist or is not an object. Please check the editable inputs using 'comfyui_get_workflow' to find the correct path.`,
+          "overrides"
+        );
       }
       current = current[part];
     }
@@ -30937,6 +31278,20 @@ var WorkflowRunSchema = z3.object({
   await: z3.boolean().default(true).describe("Wait for completion and return native images."),
   timeout: z3.number().int().min(1).default(120).describe("Wait timeout in seconds.")
 });
+var GetWorkflowSchema = z3.object({
+  workflow_file_path: z3.string().optional().describe("Workflow path or filename to inspect."),
+  workflow_id: z3.string().optional().describe("Workflow identifier returned by discovery."),
+  include_prompt: z3.boolean().default(false).describe("Include normalized API JSON in structuredContent.")
+});
+var SaveWorkflowSchema = z3.object({
+  workflow: z3.unknown().optional().describe("Workflow JSON object to save locally."),
+  workflow_file_path: z3.string().optional().describe("Existing workflow path or filename to save."),
+  workflow_id: z3.string().optional().describe("Existing workflow identifier to save."),
+  overrides: z3.record(z3.string(), z3.unknown()).optional().describe("Dot-notation overrides to persist before saving."),
+  output_file_name: z3.string().optional().describe("Filename to write locally. (default: anchored to ./)"),
+  overwrite: z3.boolean().default(false).describe("Replace an existing local file when true."),
+  include_prompt: z3.boolean().default(false).describe("Include saved API JSON in structuredContent.")
+});
 var WaitForWorkflowSchema = z3.object({
   prompt_id: z3.string().describe("The prompt_id of the submitted workflow."),
   timeout: z3.number().int().min(1).default(120).describe("Wait timeout in seconds.")
@@ -30948,8 +31303,11 @@ async function handleInspectNode(args) {
     );
     if (args.node_class) {
       const node = rawInfo[args.node_class];
-      if (!node)
-        return createNotFoundError(`Node class ${args.node_class}`);
+      if (!node) {
+        return createNotFoundError(
+          `Node class '${args.node_class}' not found. Use 'comfyui_inspect_node' without arguments to see all available nodes or use the 'query' parameter to search for it.`
+        );
+      }
       return {
         content: [
           { type: "text", text: JSON.stringify(node, null, 2) }
@@ -30999,19 +31357,7 @@ function getWorkflowId(absolutePath) {
   return crypto.createHash("sha256").update(absolutePath).digest("hex").substring(0, 8);
 }
 async function handleDiscoverWorkflows(args) {
-  const pathsToScan = [
-    path.join(
-      homedir(),
-      "comfy",
-      "ComfyUI",
-      "user",
-      "default",
-      "workflows"
-    ),
-    path.join(homedir(), ".fre4x-comfyui", "workflows"),
-    path.join(process.cwd(), "workflows")
-  ];
-  if (args.directory_path) pathsToScan.push(args.directory_path);
+  const pathsToScan = getWorkflowDirectories(args.directory_path);
   const foundWorkflows = [];
   for (const dir of pathsToScan) {
     try {
@@ -31055,13 +31401,14 @@ async function handleDiscoverWorkflows(args) {
     }
   }
   if (foundWorkflows.length === 0) {
+    const text2 = `No workflows found in searched directories.
+
+Searched paths:
+${pathsToScan.map((p) => `- ${p}`).join("\n")}
+
+Hint: If your workflows are stored elsewhere, provide a custom path using the 'directory_path' parameter.`;
     return {
-      content: [
-        {
-          type: "text",
-          text: `No workflows found in searched directories.`
-        }
-      ],
+      content: [{ type: "text", text: text2 }],
       structuredContent: {
         workflows: [],
         searched_paths: pathsToScan
@@ -31116,6 +31463,7 @@ async function handleWaitForWorkflow(args) {
       args.timeout
     );
     const outputsRecord = historyEntry.outputs || {};
+    const workspaceOutputs = [];
     const content = [];
     let summaryText = `Workflow ${args.prompt_id} completed.
 `;
@@ -31123,157 +31471,194 @@ async function handleWaitForWorkflow(args) {
       if (output && Array.isArray(output.images)) {
         for (const image of output.images) {
           if (image.filename && image.type) {
-            if (!IS_MOCK) {
-              try {
-                const base643 = await fetchImageBase64(
-                  image.filename,
-                  image.type,
-                  image.subfolder
-                );
-                content.push({
-                  type: "image",
-                  data: base643.data,
-                  mimeType: base643.mimeType
-                });
-                summaryText += `Fetched image: ${image.filename}
+            try {
+              const asset = IS_MOCK ? createMockImageAsset() : await fetchImageAsset(
+                image.filename,
+                image.type,
+                image.subfolder
+              );
+              content.push({
+                type: "image",
+                data: asset.buffer.toString("base64"),
+                mimeType: asset.mimeType
+              });
+              summaryText += `Fetched image: ${image.filename}
 `;
-              } catch (e) {
-                summaryText += `Failed to fetch image ${image.filename}: ${String(e)}
+              const summary = await saveToWorkspace(
+                args.prompt_id,
+                image,
+                asset
+              );
+              if (summary) {
+                workspaceOutputs.push(summary);
+                summaryText += `Copied image to workspace: ${summary.relative_path}
 `;
               }
-            } else {
-              summaryText += `Mock image: ${image.filename}
+            } catch (e) {
+              summaryText += `Failed to fetch image ${image.filename}: ${String(e)}
 `;
             }
           }
         }
       }
     }
+    if (IS_MOCK && outputsRecord) {
+      for (const [, output] of Object.entries(outputsRecord)) {
+        if (output && Array.isArray(output.images)) {
+          for (const image of output.images) {
+            summaryText += `Mock image: ${image.filename}
+`;
+          }
+        }
+      }
+    }
     content.unshift({ type: "text", text: summaryText });
     return {
       content,
-      structuredContent: historyEntry
+      structuredContent: {
+        ...historyEntry,
+        workspace_outputs: workspaceOutputs
+      }
     };
   } catch (error48) {
     return handleComfyError(error48);
   }
 }
-async function handleWorkflowRun(args) {
+async function handleGetWorkflow(args) {
   try {
-    let content = "";
-    let targetPath = "";
-    if (args.workflow_file_path) {
-      targetPath = args.workflow_file_path;
-      try {
-        if (!targetPath.includes(path.sep)) {
-          const paths = [
-            path.join(
-              homedir(),
-              "comfy",
-              "ComfyUI",
-              "user",
-              "default",
-              "workflows",
-              targetPath
-            ),
-            path.join(
-              homedir(),
-              ".fre4x-comfyui",
-              "workflows",
-              targetPath
-            ),
-            path.join(process.cwd(), "workflows", targetPath)
-          ];
-          let found = false;
-          for (const p of paths) {
-            try {
-              content = await fs.readFile(p, "utf8");
-              targetPath = p;
-              found = true;
-              break;
-            } catch (_e) {
-            }
-          }
-          if (!found) {
-            throw new Error(
-              `Workflow file not found: ${targetPath}`
-            );
-          }
-        } else {
-          targetPath = await validateWorkflowPath(targetPath);
-          content = await fs.readFile(targetPath, "utf8");
-        }
-      } catch (err) {
-        return handleComfyError(err);
-      }
-    } else if (args.workflow_id) {
-      const pathsToScan = [
-        path.join(
-          homedir(),
-          "comfy",
-          "ComfyUI",
-          "user",
-          "default",
-          "workflows"
-        ),
-        path.join(homedir(), ".fre4x-comfyui", "workflows"),
-        path.join(process.cwd(), "workflows")
-      ];
-      let found = false;
-      for (const dir of pathsToScan) {
-        try {
-          const entries = await fs.readdir(dir, {
-            withFileTypes: true
-          });
-          for (const entry of entries) {
-            if (entry.isFile() && entry.name.endsWith(".json")) {
-              const fullPath = path.join(dir, entry.name);
-              const defaultId = getWorkflowId(fullPath);
-              if (args.workflow_id === defaultId || args.workflow_id === entry.name.replace(/\.json$/, "")) {
-                content = await fs.readFile(fullPath, "utf8");
-                targetPath = fullPath;
-                found = true;
-                break;
-              }
-            }
+    const loadedWorkflow = await loadWorkflow(args);
+    const editableInputs = analyzeEditableInputs(loadedWorkflow.prompt);
+    const workflowId = getWorkflowId(loadedWorkflow.targetPath);
+    const text = [
+      `Workflow ${workflowId} loaded from ${loadedWorkflow.targetPath}.`,
+      loadedWorkflow.sourceFormat === "webui" ? "Source format: Web UI (normalized to API format)." : "Source format: API format.",
+      `Editable inputs (${editableInputs.length}):`,
+      formatEditableInputsText(editableInputs)
+    ].join("\n");
+    const structuredContent = {
+      workflow_id: workflowId,
+      path: loadedWorkflow.targetPath,
+      source_format: loadedWorkflow.sourceFormat,
+      editable_inputs: editableInputs
+    };
+    if (args.include_prompt) {
+      const filteredPrompt = {};
+      for (const [nodeId, node] of Object.entries(
+        loadedWorkflow.prompt
+      )) {
+        if (isRecord(node)) {
+          const classType = typeof node.class_type === "string" ? node.class_type : "";
+          if (classType && !["Note", "MarkdownNote", "PrimitiveNode"].includes(
+            classType
+          ) && nodeId !== "meta") {
+            filteredPrompt[nodeId] = node;
           }
-          if (found) break;
-        } catch (_e) {
         }
       }
-      if (!found) {
-        throw new Error(`Workflow ID not found: ${args.workflow_id}`);
-      }
+      structuredContent.prompt = filteredPrompt;
+    }
+    return {
+      content: [{ type: "text", text }],
+      structuredContent
+    };
+  } catch (error48) {
+    return handleComfyError(error48);
+  }
+}
+async function handleSaveWorkflow(args) {
+  try {
+    let prompt;
+    let sourcePath;
+    if (args.workflow !== void 0) {
+      const normalized = await normalizeWorkflowPrompt(args.workflow);
+      prompt = normalized.prompt;
     } else {
-      throw new Error(
-        "Must provide either workflow_file_path or workflow_id."
+      if (!args.workflow_file_path && !args.workflow_id) {
+        return createValidationError(
+          "workflow",
+          "Provide workflow JSON or an existing workflow reference."
+        );
+      }
+      const loadedWorkflow = await loadWorkflow(args);
+      prompt = loadedWorkflow.prompt;
+      sourcePath = loadedWorkflow.targetPath;
+    }
+    if (args.overrides) {
+      applyOverrides(prompt, args.overrides);
+    }
+    const outputFileName = deriveSavedWorkflowFileName(
+      sourcePath,
+      args.output_file_name
+    );
+    if (outputFileName.includes("..")) {
+      return createValidationError(
+        "output_file_name",
+        "Directory traversal sequences (..) are not allowed."
       );
     }
-    let promptObj = {};
+    const outputPath = path.resolve(process.cwd(), outputFileName);
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    let existedBeforeSave = false;
     try {
-      promptObj = JSON.parse(content);
-    } catch (e) {
-      throw new Error(
-        `SyntaxError: Invalid JSON in ${targetPath}: ${e instanceof Error ? e.message : String(e)}`
-      );
+      await fs.access(outputPath);
+      existedBeforeSave = true;
+    } catch {
+      existedBeforeSave = false;
     }
-    if (isWebUIFormat(promptObj)) {
-      let objectInfo;
-      if (IS_MOCK) {
-        objectInfo = MOCK_FIXTURES.object_info;
-      } else {
-        objectInfo = await fetchComfyJson(
-          "/object_info"
-        );
-      }
-      promptObj = convertWebUIToAPI(
-        promptObj,
-        objectInfo
+    if (existedBeforeSave && !args.overwrite) {
+      return createValidationError(
+        "output_file_name",
+        `File already exists: ${outputFileName}. Set overwrite=true to replace it.`
       );
     }
-    if (promptObj.prompt && typeof promptObj.prompt === "object") {
-      promptObj = promptObj.prompt;
+    await fs.writeFile(
+      outputPath,
+      `${JSON.stringify(prompt, null, 2)}
+`,
+      "utf8"
+    );
+    const editableInputs = analyzeEditableInputs(prompt);
+    const workflowId = getWorkflowId(outputPath);
+    const structuredContent = {
+      workflow_id: workflowId,
+      path: outputPath,
+      source_path: sourcePath,
+      overwritten: existedBeforeSave,
+      editable_inputs: editableInputs
+    };
+    if (args.include_prompt) {
+      const filteredPrompt = {};
+      for (const [nodeId, node] of Object.entries(prompt)) {
+        if (isRecord(node)) {
+          const classType = typeof node.class_type === "string" ? node.class_type : "";
+          if (classType && !["Note", "MarkdownNote", "PrimitiveNode"].includes(
+            classType
+          ) && nodeId !== "meta") {
+            filteredPrompt[nodeId] = node;
+          }
+        }
+      }
+      structuredContent.prompt = filteredPrompt;
     }
+    const persistedChanges = args.overrides && Object.keys(args.overrides).length > 0 ? `Persisted ${Object.keys(args.overrides).length} override(s).` : "No overrides were applied.";
+    const text = [
+      `Saved workflow ${workflowId} to ${outputPath}.`,
+      persistedChanges,
+      `Editable inputs (${editableInputs.length}):`,
+      formatEditableInputsText(editableInputs)
+    ].join("\n");
+    return {
+      content: [{ type: "text", text }],
+      structuredContent
+    };
+  } catch (error48) {
+    return handleComfyError(error48);
+  }
+}
+async function handleWorkflowRun(args) {
+  try {
+    const { prompt } = await loadWorkflow(args);
+    const promptObj = { ...prompt };
     if (args.overrides) {
       applyOverrides(promptObj, args.overrides);
     }
@@ -31307,7 +31692,9 @@ async function handleWorkflowRun(args) {
       content: [
         {
           type: "text",
-          text: `Workflow submitted. prompt_id: ${result.prompt_id}, queue: ${result.number}`
+          text: `Workflow submitted. prompt_id: ${result.prompt_id}, queue: ${result.number}.
+
+To retrieve the final results or check its status later, use the 'comfyui_wait_for_workflow' tool with this prompt_id.`
         }
       ],
       structuredContent: result
@@ -31339,6 +31726,18 @@ function createServer() {
     WorkflowRunSchema.shape,
     handleWorkflowRun
   );
+  server.tool(
+    "comfyui_get_workflow",
+    "Inspect a stored workflow and list editable inputs.",
+    GetWorkflowSchema.shape,
+    handleGetWorkflow
+  );
+  server.tool(
+    "comfyui_save_workflow",
+    "Save a workflow into ./workflows with optional edits.",
+    SaveWorkflowSchema.shape,
+    handleSaveWorkflow
+  );
   server.tool(
     "comfyui_wait_for_workflow",
     "Wait for a submitted workflow to finish and fetch its images.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fre4x/comfyui",
-  "version": "1.0.61",
+  "version": "1.0.64",
   "description": "MCP server for ComfyUI. Execute workflows and probe server state remotely.",
   "type": "module",
   "main": "dist/index.js",