@vornrun/mcp 0.5.3 → 0.5.5

package/dist/index.js

@@ -50,28 +50,6 @@ var logger_default = log;
 import { execFileSync, execFile } from "child_process";
 import fs from "fs";
 import path from "path";
-function getUserShellEnv() {
-  if (process.platform === "win32") return { ...process.env };
-  try {
-    const shell = process.env.SHELL || "/bin/zsh";
-    const output = execFileSync(shell, ["-ilc", "env"], {
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const env = {};
-    for (const line of output.split("\n")) {
-      const idx = line.indexOf("=");
-      if (idx > 0) {
-        env[line.substring(0, idx)] = line.substring(idx + 1);
-      }
-    }
-    return env;
-  } catch {
-    return { ...process.env };
-  }
-}
-var resolvedEnv = getUserShellEnv();
 function getDefaultShell(configured) {
   const chosen = configured?.trim();
   if (chosen) return chosen;
@@ -95,6 +73,8 @@ function findWindowsShell() {
   if (fs.existsSync(windowsPowerShell)) return windowsPowerShell;
   return process.env.COMSPEC || "cmd.exe";
 }
+var STRIP_ENV_KEYS = ["CLAUDECODE"];
+var STRIP_ENV_KEYS_UPPER = STRIP_ENV_KEYS.map((k) => k.toUpperCase());
 
 // ../shared/src/types.ts
 var DEFAULT_WORKSPACE = {
@@ -435,6 +415,9 @@ function createSchema() {
       project_path TEXT,
       approved_at TEXT,
       diagnostics TEXT,
+      output TEXT,
+      structured_output TEXT,
+      iteration INTEGER,
       FOREIGN KEY (run_id) REFERENCES workflow_runs(id) ON DELETE CASCADE
     );
 
@@ -914,7 +897,19 @@ function verifySchema(d) {
       {
         column: "diagnostics",
         ddl: "ALTER TABLE workflow_run_nodes ADD COLUMN diagnostics TEXT"
-      }
+      },
+      // A step's result was held only in renderer memory. After a reload the
+      // typed verdict was gone, {{steps.<slug>.<field>}} silently fell back to
+      // raw logs, and verdictOf reported "completed" for a run whose agent had
+      // said otherwise — worst on a run parked at an approval gate, which is
+      // exactly the case that outlives a restart.
+      { column: "output", ddl: "ALTER TABLE workflow_run_nodes ADD COLUMN output TEXT" },
+      {
+        column: "structured_output",
+        ddl: "ALTER TABLE workflow_run_nodes ADD COLUMN structured_output TEXT"
+      },
+      // Which pass of a loop produced this row.
+      { column: "iteration", ddl: "ALTER TABLE workflow_run_nodes ADD COLUMN iteration INTEGER" }
     ],
     tasks: [
       {
@@ -994,6 +989,15 @@ function loadDefaults(d) {
       hasSeenOnboarding: map.hasSeenOnboarding
     },
     ...map.reopenSessions !== void 0 && { reopenSessions: map.reopenSessions },
+    // Saving iterates over every key in defaults, but loading is this explicit
+    // list — so a key missing here round-trips to nothing and its feature is
+    // silently inert.
+    // Array-checked rather than cast: the value came from JSON.parse of a row a
+    // user can edit, and broadcasting a non-array under a string[] type would
+    // break any consumer that trusts the declaration.
+    ...Array.isArray(map.envPassthrough) && {
+      envPassthrough: map.envPassthrough.filter((k) => typeof k === "string")
+    },
     // Terminal block rendering. Default on; the key only appears once the
     // user has toggled it, so absence means "not yet decided", not "off".
     domBlockRendering: map.domBlockRendering ?? true,
@@ -1565,6 +1569,7 @@ function rowToWorkspace(r) {
   };
 }
 function mapNodeRow(n) {
+  const structured = n.structured_output != null ? parseStructuredOutput(n.structured_output) : void 0;
   return {
     nodeId: n.node_id,
     status: n.status,
@@ -1579,9 +1584,20 @@ function mapNodeRow(n) {
     ...n.project_name != null && { projectName: n.project_name },
     ...n.project_path != null && { projectPath: n.project_path },
     ...n.approved_at != null && { approvedAt: n.approved_at },
-    ...n.diagnostics != null && { diagnostics: n.diagnostics }
+    ...n.diagnostics != null && { diagnostics: n.diagnostics },
+    ...n.output != null && { output: n.output },
+    ...structured !== void 0 && { structuredOutput: structured },
+    ...n.iteration != null && { iteration: n.iteration }
   };
 }
+function parseStructuredOutput(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function fetchNodesByRunIds(d, runIds) {
   if (runIds.length === 0) return /* @__PURE__ */ new Map();
   const placeholders = runIds.map(() => "?").join(",");
@@ -2720,6 +2736,103 @@ function registerSessionTools(server) {
 // src/tools/workflows.ts
 import crypto2 from "crypto";
 import { z as z5 } from "zod";
+
+// src/workflow-portability.ts
+var PROJECT_PATH_TOKEN = "{{project.path}}";
+var PROJECT_NAME_TOKEN = "{{project.name}}";
+var PORTABLE_FORMAT_VERSION = 1;
+function importedWorkflowId(bundle, slug) {
+  return `import:${bundle}:${slug}`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "workflow";
+}
+function portabilityBlockers(workflow) {
+  const blockers = [];
+  for (const node of workflow.nodes) {
+    const config = node.config;
+    if (node.type === "trigger" && config.triggerType === "connectorPoll") {
+      blockers.push(`the trigger polls a connector connection, which exists only on this machine`);
+    }
+    if (node.type === "callConnectorAction") {
+      blockers.push(`step "${node.label}" calls a connector action bound to a local connection`);
+    }
+  }
+  return blockers;
+}
+function toPortable(workflow, projectPath) {
+  const slug = slugify(workflow.name);
+  const nodes = workflow.nodes.map((node) => {
+    const config = { ...node.config };
+    if (node.type === "launchAgent" || node.type === "script") {
+      for (const key of ["projectPath", "cwd", "existingWorktreePath"]) {
+        const value = config[key];
+        if (typeof value === "string" && value) {
+          config[key] = replacePath(value, projectPath);
+        }
+      }
+      if (typeof config.projectName === "string" && config.projectName) {
+        config[`projectName`] = PROJECT_NAME_TOKEN;
+      }
+      delete config.remoteHostId;
+    }
+    return { ...node, config };
+  });
+  return {
+    version: PORTABLE_FORMAT_VERSION,
+    slug,
+    name: workflow.name,
+    ...workflow.icon && { icon: workflow.icon },
+    ...workflow.iconColor && { iconColor: workflow.iconColor },
+    ...workflow.staggerDelayMs !== void 0 && { staggerDelayMs: workflow.staggerDelayMs },
+    nodes,
+    edges: workflow.edges
+  };
+}
+function normalizeForCompare(p) {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function replacePath(value, projectPath) {
+  const v = normalizeForCompare(value);
+  const root = normalizeForCompare(projectPath);
+  if (v === root) return PROJECT_PATH_TOKEN;
+  if (v.startsWith(`${root}/`)) return `${PROJECT_PATH_TOKEN}/${v.slice(root.length + 1)}`;
+  return value;
+}
+function fromPortable(portable, bundle, project) {
+  const nodes = portable.nodes.map((node) => {
+    const config = { ...node.config };
+    for (const [key, value] of Object.entries(config)) {
+      if (typeof value !== "string") continue;
+      config[key] = value.split(PROJECT_PATH_TOKEN).join(project.path.replace(/[/\\]+$/, "")).split(PROJECT_NAME_TOKEN).join(project.name);
+    }
+    return { ...node, config };
+  });
+  return {
+    id: importedWorkflowId(bundle, portable.slug),
+    name: portable.name,
+    icon: portable.icon ?? "Zap",
+    iconColor: portable.iconColor ?? "#6366f1",
+    enabled: true,
+    ...portable.staggerDelayMs !== void 0 && { staggerDelayMs: portable.staggerDelayMs },
+    nodes,
+    edges: portable.edges
+  };
+}
+var MACHINE_PATH = /(^|["'\s])(\/(Users|home)\/|[A-Za-z]:[\\/]|\\\\[^\\/\s]+[\\/])/;
+function residualAbsolutePaths(portable) {
+  const found = [];
+  for (const node of portable.nodes) {
+    for (const [key, value] of Object.entries(node.config)) {
+      if (typeof value === "string" && MACHINE_PATH.test(value)) {
+        found.push(`${node.id}.${key}`);
+      }
+    }
+  }
+  return found;
+}
+
+// src/tools/workflows.ts
 var launchAgentConfigSchema = z5.object({
   agentType: z5.enum(["claude", "copilot", "codex", "opencode", "gemini"]),
   projectName: V.name,
@@ -2748,10 +2861,68 @@ var launchAgentConfigSchema = z5.object({
   message: "outputSchema requires headless: true",
   path: ["outputSchema"]
 });
+var workflowInputDefSchema = z5.object({
+  key: z5.string().regex(
+    /^[A-Za-z_][A-Za-z0-9_]*$/,
+    "key must be a valid identifier \u2014 it becomes {{inputs.<key>}}"
+  ).max(100),
+  label: V.shortText,
+  type: z5.enum(["text", "textarea", "number", "select", "boolean", "project", "branch"]),
+  required: z5.boolean().optional(),
+  defaultValue: V.shortText.optional(),
+  options: z5.array(z5.object({ value: V.shortText, label: V.shortText })).optional(),
+  placeholder: V.shortText.optional(),
+  description: V.shortText.optional()
+}).superRefine((def, ctx) => {
+  const options = def.options ?? [];
+  if (def.type === "select" && options.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["options"],
+      message: `select input "${def.key}" declares no options, so the run dialog could offer nothing`
+    });
+  }
+  if (def.defaultValue === void 0) return;
+  if (def.type === "number" && !Number.isFinite(Number(def.defaultValue))) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultValue"],
+      message: `default "${def.defaultValue}" for number input "${def.key}" is not a finite number`
+    });
+  }
+  if (def.type === "boolean" && !["true", "false"].includes(def.defaultValue)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultValue"],
+      message: `default "${def.defaultValue}" for boolean input "${def.key}" must be "true" or "false"`
+    });
+  }
+  if (def.type === "select" && options.length > 0 && !options.some((o) => o.value === def.defaultValue)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultValue"],
+      message: `default "${def.defaultValue}" for select input "${def.key}" is not one of its options`
+    });
+  }
+});
+var workflowInputsSchema = z5.array(workflowInputDefSchema).superRefine((inputs, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  inputs.forEach((def, index) => {
+    if (seen.has(def.key)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [index, "key"],
+        message: `duplicate input key "${def.key}" \u2014 only one value can survive under {{inputs.${def.key}}}`
+      });
+    }
+    seen.add(def.key);
+  });
+});
 var triggerConfigSchema = z5.union([
   z5.object({
     triggerType: z5.literal("manual"),
-    contextual: z5.boolean().optional()
+    contextual: z5.boolean().optional(),
+    inputs: workflowInputsSchema.optional()
   }),
   z5.object({ triggerType: z5.literal("once"), runAt: V.shortText }),
   z5.object({
@@ -2778,7 +2949,8 @@ var nodeSchema = z5.object({
     "condition",
     "approval",
     "createTaskFromItem",
-    "callConnectorAction"
+    "callConnectorAction",
+    "loop"
   ]),
   label: V.shortText,
   // Referenced by typed step vars as `{{steps.<slug>.<field>}}`. Set one on any
@@ -2786,7 +2958,43 @@ var nodeSchema = z5.object({
   slug: V.shortText.optional(),
   config: z5.record(z5.string(), z5.unknown()),
   position: z5.object({ x: z5.number(), y: z5.number() })
+}).superRefine((node, ctx) => {
+  if (node.type !== "loop") return;
+  const config = node.config;
+  if (!Array.isArray(config.bodyNodeIds) || config.bodyNodeIds.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["config", "bodyNodeIds"],
+      message: `loop "${node.id}" must list at least one body step in bodyNodeIds`
+    });
+  }
+  const max = config.maxIterations;
+  if (typeof max !== "number" || !Number.isInteger(max) || max < 1 || max > MAX_LOOP_ITERATIONS) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["config", "maxIterations"],
+      message: `loop "${node.id}" needs maxIterations as a whole number from 1 to ${MAX_LOOP_ITERATIONS}`
+    });
+  }
 });
+var MAX_LOOP_ITERATIONS = 10;
+function validateLoopBodies(nodes) {
+  const ids = new Set(nodes.map((n) => n.id));
+  const errors = [];
+  for (const node of nodes) {
+    if (node.type !== "loop") continue;
+    const body = node.config.bodyNodeIds ?? [];
+    for (const id of body) {
+      if (!ids.has(id)) {
+        errors.push(`loop "${node.label || node.id}" references unknown body step "${id}"`);
+      }
+    }
+    if (body.includes(node.id)) {
+      errors.push(`loop "${node.label || node.id}" lists itself as a body step`);
+    }
+  }
+  return errors;
+}
 var edgeSchema = z5.object({
   id: V.id,
   source: V.id,
@@ -2827,6 +3035,75 @@ function buildGraphFromFlat(trigger, actions) {
   }
   return { nodes, edges };
 }
+function resolveWorkflowInputs(defs, supplied) {
+  const errors = [];
+  const known = new Set(defs.map((d) => d.key));
+  for (const key of Object.keys(supplied)) {
+    if (!known.has(key)) {
+      errors.push(
+        `unknown input "${key}" \u2014 this workflow declares: ${Array.from(known).join(", ") || "(none)"}`
+      );
+    }
+  }
+  const values = {};
+  for (const def of defs) {
+    const provided = Object.prototype.hasOwnProperty.call(supplied, def.key);
+    const raw = provided ? supplied[def.key] : def.defaultValue;
+    if (def.type === "boolean") {
+      if (raw === void 0) {
+        values[def.key] = false;
+      } else if (typeof raw === "boolean") {
+        values[def.key] = raw;
+      } else if (raw === "true" || raw === "false") {
+        values[def.key] = raw === "true";
+      } else {
+        errors.push(`input "${def.key}" must be a boolean, got ${JSON.stringify(raw)}`);
+      }
+      continue;
+    }
+    if (raw === void 0 || typeof raw === "string" && raw.trim() === "") {
+      if (def.required) errors.push(`missing required input "${def.key}" (${def.label})`);
+      continue;
+    }
+    switch (def.type) {
+      case "number": {
+        if (typeof raw === "boolean") {
+          errors.push(`input "${def.key}" must be a number, got ${JSON.stringify(raw)}`);
+          break;
+        }
+        const n = typeof raw === "number" ? raw : Number(String(raw).trim());
+        if (!Number.isFinite(n)) {
+          errors.push(`input "${def.key}" must be a finite number, got ${JSON.stringify(raw)}`);
+        } else {
+          values[def.key] = n;
+        }
+        break;
+      }
+      case "select": {
+        const allowed = (def.options ?? []).map((o) => o.value);
+        if (allowed.length === 0) {
+          errors.push(`input "${def.key}" is a select but declares no options`);
+        } else if (!allowed.includes(String(raw))) {
+          errors.push(`input "${def.key}" must be one of: ${allowed.join(", ")}`);
+        } else {
+          values[def.key] = String(raw);
+        }
+        break;
+      }
+      default:
+        values[def.key] = String(raw);
+    }
+  }
+  return { values, errors };
+}
+function resolveWorkflowId(args) {
+  const id = args.workflow_id ?? args.id;
+  if (!id) return { error: "provide workflow_id" };
+  if (args.workflow_id && args.id && args.workflow_id !== args.id) {
+    return { error: "workflow_id and id disagree \u2014 pass only workflow_id" };
+  }
+  return { id };
+}
 function registerWorkflowTools(server) {
   server.tool(
     "list_workflows",
@@ -2862,6 +3139,15 @@ function registerWorkflowTools(server) {
       if (args.nodes && args.edges) {
         nodes = args.nodes;
         edges = args.edges;
+        const loopErrors = validateLoopBodies(
+          nodes
+        );
+        if (loopErrors.length > 0) {
+          return {
+            content: [{ type: "text", text: `Error: ${loopErrors.join("; ")}` }],
+            isError: true
+          };
+        }
       } else {
         const trigger = args.trigger ?? { triggerType: "manual" };
         const actions = args.actions ?? [];
@@ -2888,7 +3174,8 @@ function registerWorkflowTools(server) {
     "update_workflow",
     "Update a workflow's properties",
     {
-      id: V.id.describe("Workflow ID"),
+      workflow_id: V.id.optional().describe("Workflow ID (from list_workflows)"),
+      id: V.id.optional().describe("Deprecated alias for workflow_id"),
       name: V.title.optional(),
       nodes: z5.array(nodeSchema).optional(),
       edges: z5.array(edgeSchema).optional(),
@@ -2898,23 +3185,38 @@ function registerWorkflowTools(server) {
       stagger_delay_ms: z5.number().optional()
     },
     async (args) => {
+      const resolved = resolveWorkflowId(args);
+      if ("error" in resolved) {
+        return { content: [{ type: "text", text: `Error: ${resolved.error}` }], isError: true };
+      }
       const workflows = dbListWorkflows();
-      const workflow = workflows.find((w) => w.id === args.id);
+      const workflow = workflows.find((w) => w.id === resolved.id);
       if (!workflow) {
         return {
-          content: [{ type: "text", text: `Error: workflow "${args.id}" not found` }],
+          content: [{ type: "text", text: `Error: workflow "${resolved.id}" not found` }],
           isError: true
         };
       }
       const updates = {};
       if (args.name !== void 0) updates.name = args.name;
-      if (args.nodes !== void 0) updates.nodes = args.nodes;
+      if (args.nodes !== void 0) {
+        const loopErrors = validateLoopBodies(
+          args.nodes
+        );
+        if (loopErrors.length > 0) {
+          return {
+            content: [{ type: "text", text: `Error: ${loopErrors.join("; ")}` }],
+            isError: true
+          };
+        }
+        updates.nodes = args.nodes;
+      }
       if (args.edges !== void 0) updates.edges = args.edges;
       if (args.icon !== void 0) updates.icon = args.icon;
       if (args.icon_color !== void 0) updates.iconColor = args.icon_color;
       if (args.enabled !== void 0) updates.enabled = args.enabled;
       if (args.stagger_delay_ms !== void 0) updates.staggerDelayMs = args.stagger_delay_ms;
-      dbUpdateWorkflow(args.id, updates);
+      dbUpdateWorkflow(resolved.id, updates);
       dbSignalChange();
       return {
         content: [{ type: "text", text: JSON.stringify({ ...workflow, ...updates }, null, 2) }]
@@ -2924,17 +3226,24 @@ function registerWorkflowTools(server) {
   server.tool(
     "delete_workflow",
     "Delete a workflow",
-    { id: V.id.describe("Workflow ID") },
+    {
+      workflow_id: V.id.optional().describe("Workflow ID (from list_workflows)"),
+      id: V.id.optional().describe("Deprecated alias for workflow_id")
+    },
     async (args) => {
+      const resolved = resolveWorkflowId(args);
+      if ("error" in resolved) {
+        return { content: [{ type: "text", text: `Error: ${resolved.error}` }], isError: true };
+      }
       const workflows = dbListWorkflows();
-      const workflow = workflows.find((w) => w.id === args.id);
+      const workflow = workflows.find((w) => w.id === resolved.id);
       if (!workflow) {
         return {
-          content: [{ type: "text", text: `Error: workflow "${args.id}" not found` }],
+          content: [{ type: "text", text: `Error: workflow "${resolved.id}" not found` }],
           isError: true
         };
       }
-      dbDeleteWorkflow(args.id);
+      dbDeleteWorkflow(resolved.id);
       dbSignalChange();
       return { content: [{ type: "text", text: `Deleted workflow: ${workflow.name}` }] };
     }
@@ -3006,6 +3315,221 @@ function registerWorkflowTools(server) {
       }
     }
   );
+  server.tool(
+    "execute_workflow",
+    "Run a workflow now, as if triggered manually. Supply values for any parameters the workflow declares (see the trigger node's inputs); declared defaults fill in anything omitted. Requires the Vorn app to be running. Returns as soon as the run is queued \u2014 poll list_workflow_runs for the outcome.",
+    {
+      workflow_id: V.id.describe("Workflow ID (from list_workflows)"),
+      inputs: z5.record(z5.string(), z5.union([z5.string(), z5.number(), z5.boolean()])).optional().describe("Values for the declared parameters, keyed by input key ({{inputs.<key>}})")
+    },
+    async (args) => {
+      const workflow = dbListWorkflows().find((w) => w.id === args.workflow_id);
+      if (!workflow) {
+        return {
+          content: [{ type: "text", text: `Error: workflow "${args.workflow_id}" not found` }],
+          isError: true
+        };
+      }
+      const trigger = workflow.nodes.find((n) => n.type === "trigger")?.config;
+      const defs = trigger?.triggerType === "manual" ? trigger.inputs ?? [] : [];
+      const supplied = args.inputs ?? {};
+      let inputs;
+      if (defs.length > 0) {
+        const { values, errors } = resolveWorkflowInputs(defs, supplied);
+        if (errors.length > 0) {
+          return {
+            content: [
+              { type: "text", text: `Error: invalid inputs
+  - ${errors.join("\n  - ")}` }
+            ],
+            isError: true
+          };
+        }
+        inputs = values;
+      } else if (Object.keys(supplied).length > 0) {
+        inputs = supplied;
+      }
+      try {
+        await rpcCall("workflow:runManual", { workflowId: args.workflow_id, inputs });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+      const disabled = workflow.enabled === false ? " (workflow is disabled; manual runs still execute)" : "";
+      const shown = inputs ? `
+inputs: ${JSON.stringify(inputs, null, 2)}` : "\nno inputs";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Queued "${workflow.name}"${disabled}${shown}
+
+Run history: list_workflow_runs with workflow_id ${args.workflow_id}`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "export_workflow",
+    "Export a workflow as a portable file you can commit beside the code it drives. Absolute paths become {{project.path}} and the local remote-host binding is dropped, so it runs on another machine after import. Refuses a workflow bound to a connector connection, whose id means nothing elsewhere.",
+    {
+      workflow_id: V.id.optional().describe("Workflow ID (from list_workflows)"),
+      id: V.id.optional().describe("Deprecated alias for workflow_id")
+    },
+    async (args) => {
+      const resolved = resolveWorkflowId(args);
+      if ("error" in resolved) {
+        return { content: [{ type: "text", text: `Error: ${resolved.error}` }], isError: true };
+      }
+      const workflow = dbListWorkflows().find((w) => w.id === resolved.id);
+      if (!workflow) {
+        return {
+          content: [{ type: "text", text: `Error: workflow "${resolved.id}" not found` }],
+          isError: true
+        };
+      }
+      const blockers = portabilityBlockers(workflow);
+      if (blockers.length > 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: "${workflow.name}" cannot be exported portably because ` + blockers.join("; ") + ". Rebuild those steps without the connection, or keep this workflow local."
+            }
+          ],
+          isError: true
+        };
+      }
+      const projects = dbListProjects();
+      const projectName = workflow.nodes.map((n) => n.config.projectName).find((name) => typeof name === "string" && name.length > 0);
+      const project = projects.find((p) => p.name === projectName);
+      if (!project) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: no project named "${projectName ?? "(none)"}" is registered, so this workflow's paths cannot be made relative to anything.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const portable = toPortable(workflow, project.path);
+      const residual = residualAbsolutePaths(portable);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(portable, null, 2) + (residual.length > 0 ? `
+
+Warning: these still hold a machine-specific path and will not travel: ${residual.join(", ")}` : "")
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "import_workflow",
+    "Import a workflow exported by export_workflow, resolving {{project.path}} and {{project.name}} against a registered project. The id is derived from the bundle and the workflow's slug, so importing the same file again updates it in place instead of creating a duplicate.",
+    {
+      workflow: z5.string().max(5e5).describe("The exported workflow JSON"),
+      project_name: V.name.describe("Registered project to resolve paths against"),
+      bundle: V.name.optional().describe("Namespace for the derived id (default: the project name)")
+    },
+    async (args) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(args.workflow);
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: workflow is not valid JSON \u2014 ${String(err).slice(0, 200)}`
+            }
+          ],
+          isError: true
+        };
+      }
+      if (parsed?.version !== PORTABLE_FORMAT_VERSION) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: unsupported format version ${parsed?.version}; this build reads version ${PORTABLE_FORMAT_VERSION}`
+            }
+          ],
+          isError: true
+        };
+      }
+      if (!Array.isArray(parsed.nodes) || !Array.isArray(parsed.edges) || !parsed.name) {
+        return {
+          content: [{ type: "text", text: "Error: workflow is missing name, nodes or edges" }],
+          isError: true
+        };
+      }
+      const project = dbListProjects().find((p) => p.name === args.project_name);
+      if (!project) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: no project named "${args.project_name}". Create it first so its path is known.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const loopErrors = validateLoopBodies(
+        parsed.nodes
+      );
+      if (loopErrors.length > 0) {
+        return {
+          content: [{ type: "text", text: `Error: ${loopErrors.join("; ")}` }],
+          isError: true
+        };
+      }
+      const bundle = args.bundle ?? slugify(project.name);
+      const definition = fromPortable(
+        { ...parsed, slug: parsed.slug ?? slugify(parsed.name) },
+        bundle,
+        {
+          name: project.name,
+          path: project.path
+        }
+      );
+      const blockers = portabilityBlockers(definition);
+      if (blockers.length > 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: this workflow cannot be imported because ${blockers.join("; ")}.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const existing = dbListWorkflows().find((w) => w.id === definition.id);
+      if (existing) {
+        dbUpdateWorkflow(definition.id, definition);
+      } else {
+        dbInsertWorkflow(definition);
+      }
+      dbSignalChange();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${existing ? "Updated" : "Imported"} "${definition.name}" as ${definition.id}, resolved against ${project.path}`
+          }
+        ]
+      };
+    }
+  );
 }
 
 // src/tools/config.ts
@@ -3371,7 +3895,7 @@ console.warn = (...args) => _origError("[mcp:warn]", ...args);
 console.error = (...args) => _origError("[mcp:error]", ...args);
 async function main() {
   configManager.init();
-  const version = true ? "0.5.3" : createRequire(import.meta.url)("../package.json").version;
+  const version = true ? "0.5.5" : createRequire(import.meta.url)("../package.json").version;
   const server = createMcpServer(version);
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vornrun/mcp",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Vorn MCP server — task management, git, and workflow tools for AI coding agents",
   "type": "module",
   "license": "MIT",
@@ -38,8 +38,8 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@vornrun/server": "0.5.3",
-    "@vornrun/shared": "0.5.3",
+    "@vornrun/server": "0.5.5",
+    "@vornrun/shared": "0.5.5",
     "tsup": "^8.5.1",
     "tsx": "^4.23.1",
     "typescript": "^6.0.3"