@vornrun/mcp 0.5.3 → 0.5.4

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 = {
@@ -994,6 +974,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,
@@ -2748,10 +2737,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({
@@ -2827,6 +2874,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",
@@ -2888,7 +3004,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,11 +3015,15 @@ 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
         };
       }
@@ -2914,7 +3035,7 @@ function registerWorkflowTools(server) {
       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 +3045,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 +3134,63 @@ 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}`
+          }
+        ]
+      };
+    }
+  );
 }
 
 // src/tools/config.ts
@@ -3371,7 +3556,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.4" : 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.4",
   "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.4",
+    "@vornrun/shared": "0.5.4",
     "tsup": "^8.5.1",
     "tsx": "^4.23.1",
     "typescript": "^6.0.3"