@vornrun/mcp 0.5.4 → 0.5.6

package/dist/index.js

@@ -415,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
     );
 
@@ -894,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: [
       {
@@ -1554,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,
@@ -1568,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(",");
@@ -2709,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,
@@ -2825,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
@@ -2833,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,
@@ -2978,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 ?? [];
@@ -3029,7 +3199,18 @@ function registerWorkflowTools(server) {
       }
       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;
@@ -3191,6 +3372,164 @@ 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
@@ -3301,6 +3640,9 @@ var failure = (message) => ({
   content: [{ type: "text", text: `Error: ${message}` }],
   isError: true
 });
+function summarize(entry) {
+  return { type: entry.type, label: entry.label };
+}
 function registerConnectorTools(server) {
   server.tool(
     "list_connectors",
@@ -3309,7 +3651,7 @@ function registerConnectorTools(server) {
       installable_only: z7.boolean().optional().describe("Only connectors that are not set up yet")
     },
     async (args) => {
-      const [builtIns, catalog, connections, statuses] = await Promise.all([
+      const [builtIns, snapshot, connections, statuses] = await Promise.all([
         rpcCall("connector:list"),
         rpcCall("connector:catalog"),
         rpcCall("connection:list", { connectorId: void 0 }),
@@ -3331,15 +3673,22 @@ function registerConnectorTools(server) {
             ...statusFor(c.id).message && { authMessage: statusFor(c.id).message }
           }
         })),
-        ...catalog.map((entry) => ({
+        ...snapshot.items.map((entry) => ({
           id: entry.id,
           name: entry.name,
           source: "package",
           description: entry.description,
           package: entry.packageName,
+          ...entry.version && { version: entry.version },
           capabilities: entry.capabilities,
           connections: countFor(entry.id),
-          ...entry.auth && { auth: entry.auth }
+          ...entry.auth && { auth: entry.auth },
+          // Generated upstream from the connector's own manifest, so an agent
+          // can tell whether a connector is worth installing without launching
+          // it — which for a list of twenty would be twenty npx processes.
+          ...entry.triggers && { triggers: entry.triggers.map(summarize) },
+          ...entry.actions && { actions: entry.actions.map(summarize) },
+          ...entry.env && { env: entry.env.map((e) => e.name) }
         }))
       ];
       return json(args.installable_only ? entries.filter((e) => e.connections === 0) : entries);
@@ -3417,7 +3766,7 @@ function registerConnectorTools(server) {
       sync_interval_minutes: z7.number().int().min(1).max(1440).optional()
     },
     async (args) => {
-      const catalog = await rpcCall("connector:catalog");
+      const { items: catalog } = await rpcCall("connector:catalog");
       const entry = args.connector_id ? catalog.find((c) => c.id === args.connector_id) : void 0;
       if (args.connector_id && !entry) {
         return failure(
@@ -3556,7 +3905,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.4" : createRequire(import.meta.url)("../package.json").version;
+  const version = true ? "0.5.6" : 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.4",
+  "version": "0.5.6",
   "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.4",
-    "@vornrun/shared": "0.5.4",
+    "@vornrun/server": "0.5.6",
+    "@vornrun/shared": "0.5.6",
     "tsup": "^8.5.1",
     "tsx": "^4.23.1",
     "typescript": "^6.0.3"