@vornrun/mcp 0.5.1 → 0.5.3

package/dist/index.js

@@ -39,6 +39,7 @@ import Database from "libsql";
 import path2 from "path";
 import os from "os";
 import fs2 from "fs";
+import { randomUUID } from "crypto";
 
 // ../server/src/logger.ts
 import pino from "pino";
@@ -106,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";
@@ -400,7 +410,12 @@ function createSchema() {
       started_at TEXT NOT NULL,
       completed_at TEXT,
       status TEXT NOT NULL DEFAULT 'running',
-      trigger_task_id TEXT
+      trigger_task_id TEXT,
+      inputs TEXT,
+      connector_item TEXT,
+      connector_inbox_id INTEGER,
+      connector_inbox_lease_token TEXT,
+      connector_inbox_disposition TEXT
     );
 
     CREATE TABLE IF NOT EXISTS workflow_run_nodes (
@@ -438,9 +453,70 @@ function createSchema() {
 
     CREATE INDEX IF NOT EXISTS idx_session_events_session ON session_events(session_id, timestamp DESC);
     CREATE INDEX IF NOT EXISTS idx_session_events_type ON session_events(event_type, timestamp DESC);
+
+    CREATE TABLE IF NOT EXISTS connector_poll_state (
+      workflow_id TEXT PRIMARY KEY REFERENCES workflows(id) ON DELETE CASCADE,
+      connection_id TEXT NOT NULL REFERENCES source_connections(id) ON DELETE CASCADE,
+      cursor TEXT,
+      last_polled_at TEXT,
+      last_error TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS connector_inbox (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      workflow_id TEXT NOT NULL REFERENCES workflows(id) ON DELETE CASCADE,
+      connection_id TEXT NOT NULL REFERENCES source_connections(id) ON DELETE CASCADE,
+      connector_id TEXT NOT NULL,
+      event_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      event_timestamp TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      attempts INTEGER NOT NULL DEFAULT 0,
+      available_at TEXT NOT NULL,
+      lease_until TEXT,
+      lease_token TEXT,
+      last_error TEXT,
+      created_at TEXT NOT NULL,
+      processed_at TEXT,
+      UNIQUE (workflow_id, connection_id, event_type, event_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_connector_inbox_ready
+      ON connector_inbox(status, available_at, lease_until);
+    CREATE INDEX IF NOT EXISTS idx_connector_inbox_connection
+      ON connector_inbox(connection_id, created_at);
   `);
   migrateSchema(d);
   verifySchema(d);
+  seedLegacyConnectorPollState(d);
+}
+function seedLegacyConnectorPollState(d) {
+  const workflows = d.prepare("SELECT id, nodes FROM workflows").all();
+  const readConnection = d.prepare(
+    "SELECT sync_cursor, last_sync_at FROM source_connections WHERE id = ?"
+  );
+  const insertState = d.prepare(
+    `INSERT OR IGNORE INTO connector_poll_state (
+       workflow_id, connection_id, cursor, last_polled_at, last_error
+     ) VALUES (?, ?, ?, ?, NULL)`
+  );
+  for (const workflow of workflows) {
+    let nodes;
+    try {
+      nodes = JSON.parse(workflow.nodes);
+    } catch {
+      continue;
+    }
+    const trigger = nodes.find(
+      (node) => node.type === "trigger" && node.config?.triggerType === "connectorPoll"
+    );
+    const connectionId = trigger?.config?.connectionId;
+    if (!connectionId) continue;
+    const connection = readConnection.get(connectionId);
+    if (!connection) continue;
+    insertState.run(workflow.id, connectionId, connection.sync_cursor, connection.last_sync_at);
+  }
 }
 function migrateSchema(d) {
   const row = d.prepare("SELECT value FROM schema_meta WHERE key = 'schema_version'").get();
@@ -642,6 +718,126 @@ function migrateSchema(d) {
     })();
     logger_default.info("[database] migrated schema to version 10 (drop session_logs)");
   }
+  if (version < 11) {
+    d.transaction(() => {
+      const runCols = d.prepare("PRAGMA table_info(workflow_runs)").all();
+      if (!runCols.some((c) => c.name === "inputs")) {
+        d.exec("ALTER TABLE workflow_runs ADD COLUMN inputs TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '11')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 11 (workflow run inputs)");
+  }
+  if (version < 12) {
+    d.transaction(() => {
+      const runCols = d.prepare("PRAGMA table_info(workflow_runs)").all();
+      if (!runCols.some((column) => column.name === "connector_inbox_id")) {
+        d.exec("ALTER TABLE workflow_runs ADD COLUMN connector_inbox_id INTEGER");
+      }
+      if (!runCols.some((column) => column.name === "connector_item")) {
+        d.exec("ALTER TABLE workflow_runs ADD COLUMN connector_item TEXT");
+      }
+      if (!runCols.some((column) => column.name === "connector_inbox_lease_token")) {
+        d.exec("ALTER TABLE workflow_runs ADD COLUMN connector_inbox_lease_token TEXT");
+      }
+      if (!runCols.some((column) => column.name === "connector_inbox_disposition")) {
+        d.exec("ALTER TABLE workflow_runs ADD COLUMN connector_inbox_disposition TEXT");
+      }
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS connector_poll_state (
+          workflow_id TEXT PRIMARY KEY REFERENCES workflows(id) ON DELETE CASCADE,
+          connection_id TEXT NOT NULL REFERENCES source_connections(id) ON DELETE CASCADE,
+          cursor TEXT,
+          last_polled_at TEXT,
+          last_error TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS connector_inbox (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          workflow_id TEXT NOT NULL REFERENCES workflows(id) ON DELETE CASCADE,
+          connection_id TEXT NOT NULL REFERENCES source_connections(id) ON DELETE CASCADE,
+          connector_id TEXT NOT NULL,
+          event_id TEXT NOT NULL,
+          event_type TEXT NOT NULL,
+          event_timestamp TEXT NOT NULL,
+          payload TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          attempts INTEGER NOT NULL DEFAULT 0,
+          available_at TEXT NOT NULL,
+          lease_until TEXT,
+          lease_token TEXT,
+          last_error TEXT,
+          created_at TEXT NOT NULL,
+          processed_at TEXT,
+          UNIQUE (workflow_id, event_type, event_id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_connector_inbox_ready
+          ON connector_inbox(status, available_at, lease_until);
+        CREATE INDEX IF NOT EXISTS idx_connector_inbox_connection
+          ON connector_inbox(connection_id, created_at);
+      `);
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '12')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 12 (durable connector ingestion)");
+  }
+  if (version < 13) {
+    d.transaction(() => {
+      const inboxCols = d.prepare("PRAGMA table_info(connector_inbox)").all();
+      if (!inboxCols.some((column) => column.name === "lease_token")) {
+        d.exec("ALTER TABLE connector_inbox ADD COLUMN lease_token TEXT");
+      }
+      d.exec(`
+        ALTER TABLE connector_inbox RENAME TO connector_inbox_v12;
+
+        CREATE TABLE connector_inbox (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          workflow_id TEXT NOT NULL REFERENCES workflows(id) ON DELETE CASCADE,
+          connection_id TEXT NOT NULL REFERENCES source_connections(id) ON DELETE CASCADE,
+          connector_id TEXT NOT NULL,
+          event_id TEXT NOT NULL,
+          event_type TEXT NOT NULL,
+          event_timestamp TEXT NOT NULL,
+          payload TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          attempts INTEGER NOT NULL DEFAULT 0,
+          available_at TEXT NOT NULL,
+          lease_until TEXT,
+          lease_token TEXT,
+          last_error TEXT,
+          created_at TEXT NOT NULL,
+          processed_at TEXT,
+          UNIQUE (workflow_id, connection_id, event_type, event_id)
+        );
+
+        INSERT INTO connector_inbox (
+          id, workflow_id, connection_id, connector_id, event_id, event_type,
+          event_timestamp, payload, status, attempts, available_at, lease_until,
+          lease_token, last_error, created_at, processed_at
+        )
+        SELECT
+          id, workflow_id, connection_id, connector_id, event_id, event_type,
+          event_timestamp, payload, status, attempts, available_at, lease_until,
+          lease_token, last_error, created_at, processed_at
+        FROM connector_inbox_v12;
+
+        DROP TABLE connector_inbox_v12;
+
+        CREATE INDEX idx_connector_inbox_ready
+          ON connector_inbox(status, available_at, lease_until);
+        CREATE INDEX idx_connector_inbox_connection
+          ON connector_inbox(connection_id, created_at);
+      `);
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '13')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 13 (connection-scoped inbox)");
+  }
 }
 function verifySchema(d) {
   const expectedByTable = {
@@ -679,6 +875,31 @@ function verifySchema(d) {
         ddl: "ALTER TABLE agent_commands ADD COLUMN headless_args TEXT"
       }
     ],
+    workflow_runs: [
+      { column: "inputs", ddl: "ALTER TABLE workflow_runs ADD COLUMN inputs TEXT" },
+      {
+        column: "connector_item",
+        ddl: "ALTER TABLE workflow_runs ADD COLUMN connector_item TEXT"
+      },
+      {
+        column: "connector_inbox_id",
+        ddl: "ALTER TABLE workflow_runs ADD COLUMN connector_inbox_id INTEGER"
+      },
+      {
+        column: "connector_inbox_lease_token",
+        ddl: "ALTER TABLE workflow_runs ADD COLUMN connector_inbox_lease_token TEXT"
+      },
+      {
+        column: "connector_inbox_disposition",
+        ddl: "ALTER TABLE workflow_runs ADD COLUMN connector_inbox_disposition TEXT"
+      }
+    ],
+    connector_inbox: [
+      {
+        column: "lease_token",
+        ddl: "ALTER TABLE connector_inbox ADD COLUMN lease_token TEXT"
+      }
+    ],
     workflow_run_nodes: [
       { column: "agent_type", ddl: "ALTER TABLE workflow_run_nodes ADD COLUMN agent_type TEXT" },
       {
@@ -886,13 +1107,30 @@ function saveConfig(config) {
         p.workspaceId ?? "personal"
       );
     }
-    d.prepare("DELETE FROM workflows").run();
-    const insertWorkflow = d.prepare(
+    const workflows = config.workflows ?? [];
+    const workflowIds = new Set(workflows.map((workflow) => workflow.id));
+    const existingWorkflowIds = d.prepare("SELECT id FROM workflows").all();
+    const deleteWorkflow = d.prepare("DELETE FROM workflows WHERE id = ?");
+    for (const { id } of existingWorkflowIds) {
+      if (!workflowIds.has(id)) deleteWorkflow.run(id);
+    }
+    const upsertWorkflow = d.prepare(
       `INSERT INTO workflows (id, name, icon, icon_color, nodes, edges, enabled, last_run_at, last_run_status, stagger_delay_ms, workspace_id)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name = excluded.name,
+         icon = excluded.icon,
+         icon_color = excluded.icon_color,
+         nodes = excluded.nodes,
+         edges = excluded.edges,
+         enabled = excluded.enabled,
+         last_run_at = excluded.last_run_at,
+         last_run_status = excluded.last_run_status,
+         stagger_delay_ms = excluded.stagger_delay_ms,
+         workspace_id = excluded.workspace_id`
     );
-    for (const w of config.workflows ?? []) {
-      insertWorkflow.run(
+    for (const w of workflows) {
+      upsertWorkflow.run(
         w.id,
         w.name,
         w.icon,
@@ -1357,17 +1595,37 @@ function fetchNodesByRunIds(d, runIds) {
   }
   return out;
 }
+function parseRunInputs(raw) {
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function mapRunRows(rows, nodesByRun) {
-  return rows.map((r) => ({
-    runId: r.id,
-    workflowId: r.workflow_id,
-    startedAt: r.started_at,
-    ...r.completed_at != null && { completedAt: r.completed_at },
-    status: r.status,
-    ...r.trigger_task_id != null && { triggerTaskId: r.trigger_task_id },
-    ...r.workflow_name != null && { workflowName: r.workflow_name },
-    nodeStates: nodesByRun.get(r.id) ?? []
-  }));
+  return rows.map((r) => {
+    const inputs = parseRunInputs(r.inputs);
+    const connectorItem = parseRunInputs(r.connector_item);
+    return {
+      runId: r.id,
+      workflowId: r.workflow_id,
+      startedAt: r.started_at,
+      ...r.completed_at != null && { completedAt: r.completed_at },
+      status: r.status,
+      ...r.trigger_task_id != null && { triggerTaskId: r.trigger_task_id },
+      ...inputs && { inputs },
+      ...connectorItem && { connectorItem },
+      ...r.connector_inbox_id != null && { connectorInboxId: r.connector_inbox_id },
+      ...r.connector_inbox_lease_token != null && {
+        connectorInboxLeaseToken: r.connector_inbox_lease_token
+      },
+      ...r.connector_inbox_disposition === "processed" || r.connector_inbox_disposition === "retry" ? { connectorInboxDisposition: r.connector_inbox_disposition } : {},
+      ...r.workflow_name != null && { workflowName: r.workflow_name },
+      nodeStates: nodesByRun.get(r.id) ?? []
+    };
+  });
 }
 function listWorkflowRuns(workflowId, limit = 20) {
   const d = getDb();
@@ -2059,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);
@@ -2069,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 }));
     });
@@ -2848,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: {} } });
@@ -2857,6 +3358,7 @@ function createMcpServer(version) {
   registerSessionTools(server);
   registerWorkflowTools(server);
   registerWorkspaceTools(server);
+  registerConnectorTools(server);
   return server;
 }
 
@@ -2869,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.1" : 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.1",
+  "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.1",
-    "@vornrun/shared": "0.5.1",
+    "@vornrun/server": "0.5.3",
+    "@vornrun/shared": "0.5.3",
     "tsup": "^8.5.1",
     "tsx": "^4.23.1",
     "typescript": "^6.0.3"