@vornrun/mcp 0.5.2 → 0.5.3

package/dist/index.js

@@ -107,6 +107,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";
@@ -2308,7 +2317,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 +2327,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 }));
     });
@@ -3097,6 +3106,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 +3358,7 @@ function createMcpServer(version) {
   registerSessionTools(server);
   registerWorkflowTools(server);
   registerWorkspaceTools(server);
+  registerConnectorTools(server);
   return server;
 }
 
@@ -3118,7 +3371,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.3" : 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.3",
   "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.3",
+    "@vornrun/shared": "0.5.3",
     "tsup": "^8.5.1",
     "tsx": "^4.23.1",
     "typescript": "^6.0.3"