@vornrun/mcp 0.5.2 → 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 = {
@@ -107,6 +87,15 @@ var DEFAULT_WORKSPACE = {
 function isTerminalTaskStatus(status) {
   return status === "done" || status === "cancelled";
 }
+var SDK_FILTER_KEYS = {
+  connectorId: "sdkConnectorId",
+  version: "sdkVersion",
+  icon: "sdkIcon"
+};
+function connectionConnectorId(connection) {
+  const packaged = connection.filters?.[SDK_FILTER_KEYS.connectorId];
+  return typeof packaged === "string" && packaged !== "" ? packaged : connection.connectorId;
+}
 
 // ../server/src/default-workflows.ts
 var DEFAULT_TASK_WORKFLOW_ID = "system:default-task-workflow";
@@ -985,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,
@@ -2308,7 +2306,7 @@ function readPort() {
     return discoverAndHeal();
   }
 }
-async function rpcCall(method, params) {
+async function rpcCall(method, params, timeoutMs = TIMEOUT_MS) {
   const result = readPort();
   if (!result.port) {
     throw new Error(result.reason === "invalid" ? PORT_FILE_INVALID_MSG : PORT_FILE_MISSING_MSG);
@@ -2318,8 +2316,8 @@ async function rpcCall(method, params) {
     const id = ++rpcId;
     const timer = setTimeout(() => {
       ws.close();
-      reject(new Error(`RPC call "${method}" timed out after ${TIMEOUT_MS}ms`));
-    }, TIMEOUT_MS);
+      reject(new Error(`RPC call "${method}" timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
     ws.on("open", () => {
       ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
     });
@@ -2739,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({
@@ -2818,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",
@@ -2879,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(),
@@ -2889,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
         };
       }
@@ -2905,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) }]
@@ -2915,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}` }] };
     }
@@ -2997,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
@@ -3097,6 +3291,249 @@ function registerWorkspaceTools(server) {
   );
 }
 
+// src/tools/connectors.ts
+import { z as z7 } from "zod";
+var PROBE_TIMEOUT_MS = 12e4;
+var json = (value) => ({
+  content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
+});
+var failure = (message) => ({
+  content: [{ type: "text", text: `Error: ${message}` }],
+  isError: true
+});
+function registerConnectorTools(server) {
+  server.tool(
+    "list_connectors",
+    "List every connector: the ones built into Vorn, the ones installable from a package, and how many connections each already has. Use this before creating a workflow that calls a connector action, or to find the id of a connector to install.",
+    {
+      installable_only: z7.boolean().optional().describe("Only connectors that are not set up yet")
+    },
+    async (args) => {
+      const [builtIns, catalog, connections, statuses] = await Promise.all([
+        rpcCall("connector:list"),
+        rpcCall("connector:catalog"),
+        rpcCall("connection:list", { connectorId: void 0 }),
+        rpcCall("connector:status")
+      ]);
+      const countFor = (id) => connections.filter((conn) => connectionConnectorId(conn) === id).length;
+      const statusFor = (id) => statuses.find((s) => s.connectorId === id);
+      const entries = [
+        ...builtIns.map((c) => ({
+          id: c.id,
+          name: c.name,
+          source: "built-in",
+          capabilities: c.capabilities,
+          connections: countFor(c.id),
+          // Only meaningful for connectors that authenticate up front; the
+          // rest report nothing rather than a misleading "not authed".
+          ...statusFor(c.id) && {
+            authenticated: statusFor(c.id).authed,
+            ...statusFor(c.id).message && { authMessage: statusFor(c.id).message }
+          }
+        })),
+        ...catalog.map((entry) => ({
+          id: entry.id,
+          name: entry.name,
+          source: "package",
+          description: entry.description,
+          package: entry.packageName,
+          capabilities: entry.capabilities,
+          connections: countFor(entry.id),
+          ...entry.auth && { auth: entry.auth }
+        }))
+      ];
+      return json(args.installable_only ? entries.filter((e) => e.connections === 0) : entries);
+    }
+  );
+  server.tool(
+    "list_connections",
+    "List configured connector connections, including when each last synced and the error from its last failure. Use this to diagnose a connector that is not producing tasks.",
+    {
+      connector_id: V.id.optional().describe("Only connections for this connector"),
+      failing_only: z7.boolean().optional().describe("Only connections whose last sync failed")
+    },
+    async (args) => {
+      const connections = await rpcCall("connection:list", {
+        connectorId: void 0
+      });
+      const visible = connections.filter((conn) => !args.connector_id || connectionConnectorId(conn) === args.connector_id).filter((conn) => !args.failing_only || !!conn.lastSyncError);
+      return json(
+        visible.map((conn) => ({
+          id: conn.id,
+          name: conn.name,
+          connectorId: connectionConnectorId(conn),
+          project: conn.executionProject,
+          syncIntervalMinutes: conn.syncIntervalMinutes,
+          lastSyncAt: conn.lastSyncAt,
+          lastSyncError: conn.lastSyncError,
+          // Deliberately not the whole `filters` blob: it holds encrypted
+          // credentials, and an agent has no use for ciphertext.
+          config: publicFilters(conn)
+        }))
+      );
+    }
+  );
+  server.tool(
+    "list_connector_actions",
+    "List the actions a connection can execute, with their input schemas. Call this before run_connector_action or before adding a callConnectorAction node to a workflow.",
+    { connection_id: V.id.describe("Connection ID") },
+    async (args) => {
+      const actions = await rpcCall(
+        "connection:listActions",
+        args.connection_id
+      );
+      if (actions.length === 0) {
+        return failure(
+          `No actions for connection "${args.connection_id}". Either the connection does not exist, or its connector exposes no actions yet \u2014 for an MCP connection, tool discovery may still be running.`
+        );
+      }
+      return json(actions);
+    }
+  );
+  server.tool(
+    "inspect_connector_package",
+    "Start a connector package and read what it offers \u2014 its triggers, actions and required environment variables \u2014 without installing it. Use this to review a connector before install_connector, or to check a local build.",
+    {
+      package: V.shortText.describe(
+        'npm package name, or a command to run a local build (e.g. "node /path/to/dist/index.js")'
+      )
+    },
+    async (args) => {
+      const result = await probe(args.package);
+      if (!result.ok) return failure(result.error);
+      return json(result.manifest);
+    }
+  );
+  server.tool(
+    "install_connector",
+    "Install a connector from the catalog or from an npm package, creating a connection ready to poll. Call list_connectors for catalog ids and inspect_connector_package to see which environment variables are needed. Secrets cannot be set this way \u2014 see the error it returns if the connector requires one.",
+    {
+      connector_id: V.id.optional().describe("Catalog connector id (from list_connectors). Use this or package."),
+      package: V.shortText.optional().describe("npm package name or launch command"),
+      name: V.title.optional().describe("Connection name (defaults to the connector name)"),
+      project: V.name.optional().describe("Vorn project tasks should be created in"),
+      trigger: V.shortText.optional().describe("Trigger type to configure (defaults to the first the connector offers)"),
+      env: z7.record(z7.string(), z7.string()).optional().describe("Non-secret environment variables the connector needs"),
+      sync_interval_minutes: z7.number().int().min(1).max(1440).optional()
+    },
+    async (args) => {
+      const 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(
+          `No connector "${args.connector_id}" in the catalog. Known: ${catalog.map((c) => c.id).join(", ") || "(none)"}. To install something not in the catalog, pass \`package\` instead.`
+        );
+      }
+      const target = entry ? entry.launch : args.package;
+      if (!target) return failure("Provide either connector_id or package.");
+      const result = await probe(target);
+      if (!result.ok) return failure(result.error);
+      const manifest = result.manifest;
+      const supplied = args.env ?? {};
+      const unknown = Object.keys(supplied).filter(
+        (name) => !manifest.env.some((e) => e.name === name)
+      );
+      if (unknown.length > 0) {
+        return failure(
+          `${manifest.name} does not use ${unknown.join(", ")}. It accepts: ${manifest.env.map((e) => e.name).join(", ") || "(none)"}.`
+        );
+      }
+      const secrets = manifest.env.filter((e) => e.secret && (e.required || supplied[e.name]));
+      if (secrets.length > 0) {
+        return failure(
+          `${manifest.name} uses the secret ${plural(secrets.length, "value")} ${secrets.map((e) => e.name).join(", ")}, which this tool cannot accept: it runs outside the desktop process, where encryption lives, so it could only store them unprotected. They must be entered by a person in Settings > Connectors to reach the OS keychain. Everything else about the connector is ready to install.`
+        );
+      }
+      const missing = manifest.env.filter((e) => e.required && !supplied[e.name]?.trim());
+      if (missing.length > 0) {
+        return failure(
+          `${manifest.name} needs ${missing.map((e) => describeEnv(e)).join(", ")}. Pass them in \`env\`.`
+        );
+      }
+      const trigger = args.trigger ? manifest.triggers.find((t) => t.type === args.trigger) : manifest.triggers[0];
+      if (args.trigger && !trigger) {
+        return failure(
+          `${manifest.name} has no trigger "${args.trigger}". It offers: ${manifest.triggers.map((t) => t.type).join(", ") || "(none)"}.`
+        );
+      }
+      const launch = typeof target === "string" ? parseLaunch(target) : target;
+      const connection = await rpcCall("connection:create", {
+        connectorId: "mcp",
+        name: args.name ?? (trigger ? `${manifest.name}: ${trigger.label}` : manifest.name),
+        filters: {
+          command: launch.command,
+          args: JSON.stringify(launch.args),
+          env: JSON.stringify(supplied),
+          [SDK_FILTER_KEYS.connectorId]: manifest.id,
+          [SDK_FILTER_KEYS.version]: manifest.version,
+          ...manifest.icon && { [SDK_FILTER_KEYS.icon]: JSON.stringify(manifest.icon) },
+          ...trigger?.filters ?? {}
+        },
+        syncIntervalMinutes: args.sync_interval_minutes ?? 5,
+        statusMapping: {},
+        ...args.project && { executionProject: args.project }
+      });
+      return json({
+        installed: manifest.name,
+        connectionId: connection.id,
+        trigger: trigger?.type,
+        note: "Poll it now with backfill_connection, or reference it from a workflow."
+      });
+    }
+  );
+  server.tool(
+    "run_connector_action",
+    "Execute one action on a connection \u2014 create an issue, run a query, close a work item. Call list_connector_actions first for the action name and its arguments.",
+    {
+      connection_id: V.id.describe("Connection ID"),
+      action: V.shortText.describe("Action name from list_connector_actions"),
+      args: z7.record(z7.string(), z7.unknown()).optional().describe("Action arguments")
+    },
+    async (args) => {
+      const result = await rpcCall("connection:executeAction", {
+        connectionId: args.connection_id,
+        action: args.action,
+        args: args.args ?? {}
+      });
+      if (!result.success) return failure(result.error ?? "Action failed");
+      return json(result);
+    }
+  );
+  server.tool(
+    "backfill_connection",
+    "Pull items from a connection now and turn them into tasks, without waiting for its poll interval. Use this to verify a connection works after installing it.",
+    { connection_id: V.id.describe("Connection ID") },
+    async (args) => {
+      const result = await rpcCall(
+        "connection:backfill",
+        { connectionId: args.connection_id },
+        PROBE_TIMEOUT_MS
+      );
+      if (result.error) return failure(result.error);
+      return json(result);
+    }
+  );
+}
+async function probe(target) {
+  const launch = typeof target === "string" ? parseLaunch(target) : target;
+  return rpcCall("connector:probeSdk", launch, PROBE_TIMEOUT_MS);
+}
+function parseLaunch(spec) {
+  const parts = spec.trim().split(/\s+/);
+  if (parts.length === 1) return { command: "npx", args: ["-y", parts[0]] };
+  return { command: parts[0], args: parts.slice(1) };
+}
+function publicFilters(conn) {
+  const hidden = /* @__PURE__ */ new Set(["secretEnv", "discoveredTools"]);
+  return Object.fromEntries(Object.entries(conn.filters ?? {}).filter(([key]) => !hidden.has(key)));
+}
+function describeEnv(entry) {
+  return entry.description ? `${entry.name} (${entry.description})` : entry.name;
+}
+function plural(count, word) {
+  return count === 1 ? word : `${word}s`;
+}
+
 // src/server.ts
 function createMcpServer(version) {
   const server = new McpServer({ name: "vorn", version }, { capabilities: { tools: {} } });
@@ -3106,6 +3543,7 @@ function createMcpServer(version) {
   registerSessionTools(server);
   registerWorkflowTools(server);
   registerWorkspaceTools(server);
+  registerConnectorTools(server);
   return server;
 }
 
@@ -3118,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.2" : 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.2",
+  "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.2",
-    "@vornrun/shared": "0.5.2",
+    "@vornrun/server": "0.5.4",
+    "@vornrun/shared": "0.5.4",
     "tsup": "^8.5.1",
     "tsx": "^4.23.1",
     "typescript": "^6.0.3"