@fre4x/comfyui 1.0.61 → 1.0.62

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

@@ -30723,6 +30723,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;
 }
@@ -30856,6 +30864,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 {
@@ -30874,7 +30885,29 @@ ${detailSummary}` : error48.message
 }
 async function validateWorkflowPath(targetPath) {
   const resolvedPath = path.resolve(targetPath);
-  const allowedRoots = [
+  const allowedRoots = getWorkflowDirectories();
+  const isAllowed = allowedRoots.some(
+    (root) => resolvedPath.startsWith(path.resolve(root))
+  );
+  if (!isAllowed) {
+    throw new WorkflowInputError(
+      `Access denied: ${targetPath} is outside allowed workflow directories.`,
+      "workflow_file_path"
+    );
+  }
+  try {
+    await fs.access(resolvedPath);
+    return resolvedPath;
+  } catch {
+    throw new WorkflowInputError(
+      `Workflow file not found: ${targetPath}`,
+      "workflow_file_path",
+      "not_found"
+    );
+  }
+}
+function getWorkflowDirectories(extraPath) {
+  const directories = [
     path.join(
       homedir(),
       "comfy",
@@ -30886,20 +30919,285 @@ async function validateWorkflowPath(targetPath) {
     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"
+    );
+  }
+  if (path.basename(trimmed) !== trimmed) {
+    throw new WorkflowInputError(
+      "Filename must not include directory separators.",
+      "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;
+    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"
+      );
+    }
+    const validatedPath = await validateWorkflowPath(targetPath);
+    return {
+      targetPath: validatedPath,
+      content: await fs.readFile(validatedPath, "utf8")
+    };
+  }
+  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 {
-    await fs.access(resolvedPath);
-    return resolvedPath;
+    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 {
+    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 : "";
+    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 : "";
+    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)) {
@@ -30937,6 +31235,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 under ./workflows."),
+  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.")
@@ -31158,122 +31470,112 @@ async function handleWaitForWorkflow(args) {
     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;
-              }
-            }
-          }
-          if (found) break;
-        } catch (_e) {
-        }
-      }
-      if (!found) {
-        throw new Error(`Workflow ID not found: ${args.workflow_id}`);
-      }
+    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) {
+      structuredContent.prompt = loadedWorkflow.prompt;
+    }
+    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);
     }
-    let promptObj = {};
+    const workflowsDir = path.join(process.cwd(), "workflows");
+    await fs.mkdir(workflowsDir, { recursive: true });
+    const outputFileName = deriveSavedWorkflowFileName(
+      sourcePath,
+      args.output_file_name
+    );
+    const outputPath = path.join(workflowsDir, outputFileName);
+    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) {
+      structuredContent.prompt = prompt;
+    }
+    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);
     }
@@ -31339,6 +31641,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.62",
   "description": "MCP server for ComfyUI. Execute workflows and probe server state remotely.",
   "type": "module",
   "main": "dist/index.js",