@vellumai/assistant 0.8.0 → 0.8.2

package/src/runtime/routes/integrations/slack/share.ts

@@ -12,9 +12,6 @@ import {
   userInfo,
 } from "../../../../messaging/providers/slack/client.js";
 import type { SlackConversation } from "../../../../messaging/providers/slack/types.js";
-import { getConnectionByProvider } from "../../../../oauth/oauth-store.js";
-import { credentialKey } from "../../../../security/credential-key.js";
-import { getSecureKeyAsync } from "../../../../security/secure-keys.js";
 import { getLogger } from "../../../../util/logger.js";
 import {
   BadRequestError,
@@ -23,50 +20,10 @@ import {
   ServiceUnavailableError,
 } from "../../errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "../../types.js";
+import { resolveSlackToken } from "./token.js";
 
 const log = getLogger("slack-share");
 
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve a Slack token for the Share UI, mirroring the read/write auth split
- * in `messaging/providers/slack/adapter.ts`.
- *
- * For Socket Mode installs (tokens stored under `credential/slack_channel/*`),
- * prefer the user OAuth token (xoxp-) for reads when present — this lets the
- * channel picker surface channels the user belongs to but the bot doesn't.
- * Fall back to the bot token (xoxb-) otherwise.
- *
- * Writes MUST always use the bot token so posted messages come from the bot
- * identity, never the user. Passing `user_token` to chat.postMessage would
- * post as the user — unambiguously wrong for Share UI behavior.
- *
- * For legacy OAuth installs (no Socket Mode tokens), fall back to the OAuth
- * connection's access_token, which is the bot token in Slack's OAuth v2 flow.
- */
-async function resolveSlackToken(
-  mode: "read" | "write",
-): Promise<string | undefined> {
-  const botToken = await getSecureKeyAsync(
-    credentialKey("slack_channel", "bot_token"),
-  );
-  if (botToken) {
-    if (mode === "read") {
-      const userToken = await getSecureKeyAsync(
-        credentialKey("slack_channel", "user_token"),
-      );
-      return userToken ?? botToken;
-    }
-    return botToken;
-  }
-
-  const conn = getConnectionByProvider("slack");
-  if (!conn) return undefined;
-  return await getSecureKeyAsync(`oauth_connection/${conn.id}/access_token`);
-}
-
 // ---------------------------------------------------------------------------
 // GET /v1/slack/channels
 // ---------------------------------------------------------------------------
@@ -179,15 +136,11 @@ export async function handleShareToSlackChannel({
   };
 
   if (!appId || !channelId) {
-    throw new BadRequestError(
-      "Missing required fields: appId, channelId",
-    );
+    throw new BadRequestError("Missing required fields: appId, channelId");
   }
 
   if (typeof appId !== "string" || typeof channelId !== "string") {
-    throw new BadRequestError(
-      "Fields appId and channelId must be strings",
-    );
+    throw new BadRequestError("Fields appId and channelId must be strings");
   }
 
   if (message !== undefined && typeof message !== "string") {
@@ -245,8 +198,7 @@ export const ROUTES: RouteDefinition[] = [
     endpoint: "slack/channels",
     method: "GET",
     summary: "List Slack channels",
-    description:
-      "List Slack channels, groups, and DMs for the channel picker.",
+    description: "List Slack channels, groups, and DMs for the channel picker.",
     tags: ["integrations"],
     requirePolicyEnforcement: true,
     handler: () => handleListSlackChannels(),

package/src/runtime/routes/integrations/slack/token.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared Slack token resolver.
+ *
+ * Resolve a Slack token for the Share UI, mirroring the read/write auth split
+ * in `messaging/providers/slack/adapter.ts`.
+ *
+ * For Socket Mode installs (tokens stored under `credential/slack_channel/*`),
+ * prefer the user OAuth token (xoxp-) for reads when present — this lets the
+ * channel picker surface channels the user belongs to but the bot doesn't.
+ * Fall back to the bot token (xoxb-) otherwise.
+ *
+ * Writes MUST always use the bot token so posted messages come from the bot
+ * identity, never the user. Passing `user_token` to chat.postMessage would
+ * post as the user — unambiguously wrong for Share UI behavior.
+ *
+ * For legacy OAuth installs (no Socket Mode tokens), fall back to the OAuth
+ * connection's access_token, which is the bot token in Slack's OAuth v2 flow.
+ */
+
+import { getConnectionByProvider } from "../../../../oauth/oauth-store.js";
+import { credentialKey } from "../../../../security/credential-key.js";
+import { getSecureKeyAsync } from "../../../../security/secure-keys.js";
+
+export async function resolveSlackToken(
+  mode: "read" | "write",
+): Promise<string | undefined> {
+  const botToken = await getSecureKeyAsync(
+    credentialKey("slack_channel", "bot_token"),
+  );
+  if (botToken) {
+    if (mode === "read") {
+      const userToken = await getSecureKeyAsync(
+        credentialKey("slack_channel", "user_token"),
+      );
+      return userToken ?? botToken;
+    }
+    return botToken;
+  }
+
+  const conn = getConnectionByProvider("slack");
+  if (!conn) return undefined;
+  return await getSecureKeyAsync(`oauth_connection/${conn.id}/access_token`);
+}

package/src/runtime/routes/integrations/twilio.ts

@@ -95,8 +95,7 @@ export async function handleSetTwilioCredentials({
 
   // Validate credentials against Twilio API
   const authHeader =
-    "Basic " +
-    Buffer.from(`${accountSid}:${authToken}`).toString("base64");
+    "Basic " + Buffer.from(`${accountSid}:${authToken}`).toString("base64");
   try {
     const res = await fetch(
       `https://api.twilio.com/2010-04-01/Accounts/${accountSid}.json`,
@@ -121,9 +120,7 @@ export async function handleSetTwilioCredentials({
     accountSid,
   );
   if (!sidStored) {
-    throw new InternalError(
-      "Failed to store Account SID in secure storage",
-    );
+    throw new InternalError("Failed to store Account SID in secure storage");
   }
 
   const tokenStored = await setSecureKeyAsync(
@@ -132,17 +129,17 @@ export async function handleSetTwilioCredentials({
   );
   if (!tokenStored) {
     await deleteSecureKeyAsync(credentialKey("twilio", "account_sid"));
-    throw new InternalError(
-      "Failed to store Auth Token in secure storage",
-    );
+    throw new InternalError("Failed to store Auth Token in secure storage");
   }
 
   const raw = loadRawConfig();
   const twilio = (raw?.twilio ?? {}) as Record<string, unknown>;
   twilio.accountSid = accountSid;
+  twilio.setupStarted = true;
   saveRawConfig({ ...raw, twilio });
 
   upsertCredentialMetadata("twilio", "account_sid", {
+    allowedTools: ["bash"],
     injectionTemplates: [
       {
         hostPattern: "api.twilio.com",
@@ -209,9 +206,7 @@ async function handleListTwilioNumbers() {
   return { success: true, hasCredentials: true, numbers };
 }
 
-export async function handleProvisionTwilioNumber({
-  body,
-}: RouteHandlerArgs) {
+export async function handleProvisionTwilioNumber({ body }: RouteHandlerArgs) {
   if (!(await hasTwilioCredentials())) {
     throw new BadRequestError(
       "Twilio credentials not configured. Set credentials first.",
@@ -322,8 +317,7 @@ async function handleReleaseTwilioNumber({ body }: RouteHandlerArgs) {
   };
   const raw = loadRawConfig();
   const twilio = (raw?.twilio ?? {}) as Record<string, unknown>;
-  const phoneNumber =
-    requestedNumber || (twilio.phoneNumber as string) || "";
+  const phoneNumber = requestedNumber || (twilio.phoneNumber as string) || "";
 
   if (!phoneNumber) {
     throw new BadRequestError(

package/src/runtime/routes/mcp-auth-routes.ts

@@ -1,18 +1,24 @@
 /**
- * Internal routes for daemon-owned MCP OAuth flows.
+ * Internal routes for daemon-owned MCP management.
  *
  * POST internal/mcp/auth/start   — kicks off the OAuth flow in the daemon
  *                                  and returns the authorization URL
  * GET  internal/mcp/auth/status/:serverId — polls current flow status
+ * POST internal/mcp/reload       — trigger MCP server reload
+ * GET  internal/mcp/list         — list servers with health status
+ * POST internal/mcp/add          — add a new MCP server config
+ * POST internal/mcp/remove       — remove an MCP server config + credentials
  */
 
 import { z } from "zod";
 
-import { loadRawConfig } from "../../config/loader.js";
-import type { McpConfig } from "../../config/schemas/mcp.js";
+import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
+import type { McpConfig, McpServerConfig } from "../../config/schemas/mcp.js";
 import { reloadMcpServers } from "../../daemon/mcp-reload-service.js";
+import { McpClient } from "../../mcp/client.js";
 import { orchestrateMcpOAuthConnect } from "../../mcp/mcp-auth-orchestrator.js";
 import { getMcpAuthState } from "../../mcp/mcp-auth-state.js";
+import { deleteMcpOAuthCredentials } from "../../mcp/mcp-oauth-provider.js";
 import { getLogger } from "../../util/logger.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import type { RouteDefinition } from "./types.js";
@@ -79,20 +85,248 @@ function handleMcpAuthStatus({
   return { status: "error", error: state.error };
 }
 
-function handleMcpReload(_args: {
-  body?: Record<string, unknown>;
-}): { ok: true } {
-  // Fire-and-forget: reloadMcpServers() has its own reloadInProgress mutex,
-  // so concurrent calls coalesce.
+/**
+ * Fire-and-forget MCP reload. reloadMcpServers() has its own
+ * reloadInProgress mutex, so concurrent calls coalesce.
+ */
+function triggerReload(context: string): void {
   void reloadMcpServers().catch((err) => {
     log.warn(
       { err: err instanceof Error ? err.message : String(err) },
-      "internal_mcp_reload background reload failed",
+      `${context} background reload failed`,
     );
   });
+}
+
+function handleMcpReload(_args: {
+  body?: Record<string, unknown>;
+}): { ok: true } {
+  triggerReload("internal_mcp_reload");
   return { ok: true };
 }
 
+// ---------------------------------------------------------------------------
+// Health check helper
+// ---------------------------------------------------------------------------
+
+const HEALTH_CHECK_TIMEOUT_MS = 10_000;
+
+async function checkServerHealth(
+  serverId: string,
+  config: McpServerConfig,
+  timeoutMs = HEALTH_CHECK_TIMEOUT_MS,
+): Promise<string> {
+  const client = new McpClient(serverId);
+  try {
+    await Promise.race([
+      client.connect(config.transport),
+      new Promise<never>((_, reject) => {
+        const t = setTimeout(() => reject(new Error("timeout")), timeoutMs);
+        if (typeof t === "object" && "unref" in t) t.unref();
+      }),
+    ]);
+
+    if (client.isConnected) {
+      await client.disconnect();
+      return "✓ Connected";
+    }
+
+    const err = client.lastError;
+    if (err) {
+      const message = err.message;
+      if (message.includes("timeout")) {
+        return "✗ Timed out";
+      }
+      return `✗ Error: ${message}`;
+    }
+
+    return "! Needs authentication";
+  } catch (err) {
+    try {
+      await client.disconnect();
+    } catch {
+      /* ignore */
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("timeout")) {
+      return "✗ Timed out";
+    }
+    return `✗ Error: ${message}`;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// List
+// ---------------------------------------------------------------------------
+
+interface McpServerEntry {
+  id: string;
+  status: string;
+  transport: McpServerConfig["transport"];
+  enabled: boolean;
+  defaultRiskLevel: string;
+  allowedTools?: string[];
+  blockedTools?: string[];
+}
+
+async function handleMcpList(_args: {
+  body?: Record<string, unknown>;
+}): Promise<{ servers: McpServerEntry[] }> {
+  const raw = loadRawConfig();
+  const mcpConfig = raw.mcp as Partial<McpConfig> | undefined;
+  const servers = mcpConfig?.servers ?? {};
+  const entries = Object.entries(servers) as [string, McpServerConfig][];
+
+  const results: McpServerEntry[] = await Promise.all(
+    entries
+      .filter(([, config]) => config && typeof config === "object")
+      .map(async ([id, config]) => {
+        const enabled = config.enabled !== false;
+        let status: string;
+        if (!enabled) {
+          status = "✗ disabled";
+        } else {
+          status = await checkServerHealth(id, config);
+        }
+        return {
+          id,
+          status,
+          transport: config.transport,
+          enabled,
+          defaultRiskLevel: config.defaultRiskLevel ?? "high",
+          ...(config.allowedTools && { allowedTools: config.allowedTools }),
+          ...(config.blockedTools && { blockedTools: config.blockedTools }),
+        };
+      }),
+  );
+
+  return { servers: results };
+}
+
+// ---------------------------------------------------------------------------
+// Add
+// ---------------------------------------------------------------------------
+
+async function handleMcpAdd({
+  body,
+}: {
+  body?: Record<string, unknown>;
+}): Promise<{ added: true }> {
+  const {
+    name,
+    transportType,
+    url,
+    command,
+    args,
+    risk,
+    disabled,
+  } = body as {
+    name: string;
+    transportType: string;
+    url?: string;
+    command?: string;
+    args?: string[];
+    risk?: string;
+    disabled?: boolean;
+  };
+
+  const riskLevel = risk ?? "high";
+  if (!["low", "medium", "high"].includes(riskLevel)) {
+    throw new BadRequestError(
+      `Invalid risk level: ${riskLevel}. Must be low, medium, or high`,
+    );
+  }
+
+  let transport: Record<string, unknown>;
+  switch (transportType) {
+    case "stdio":
+      if (!command) {
+        throw new BadRequestError("--command is required for stdio transport");
+      }
+      transport = { type: "stdio", command, args: args ?? [] };
+      break;
+    case "sse":
+    case "streamable-http":
+      if (!url) {
+        throw new BadRequestError(
+          `--url is required for ${transportType} transport`,
+        );
+      }
+      transport = { type: transportType, url };
+      break;
+    default:
+      throw new BadRequestError(
+        `Unknown transport type: ${transportType}. Must be stdio, sse, or streamable-http`,
+      );
+  }
+
+  const raw = loadRawConfig();
+  if (!raw.mcp) raw.mcp = { servers: {} };
+  const mcpConfig = raw.mcp as Record<string, unknown>;
+  if (!mcpConfig.servers) mcpConfig.servers = {};
+  const serverMap = mcpConfig.servers as Record<string, unknown>;
+
+  if (serverMap[name]) {
+    throw new BadRequestError(
+      `MCP server "${name}" already exists. Remove it first with: assistant mcp remove ${name}`,
+    );
+  }
+
+  serverMap[name] = {
+    transport,
+    enabled: !disabled,
+    defaultRiskLevel: riskLevel,
+  };
+
+  saveRawConfig(raw);
+  triggerReload("internal_mcp_add");
+
+  return { added: true };
+}
+
+// ---------------------------------------------------------------------------
+// Remove
+// ---------------------------------------------------------------------------
+
+async function handleMcpRemove({
+  body,
+}: {
+  body?: Record<string, unknown>;
+}): Promise<{ removed: true }> {
+  const { name } = body as { name: string };
+
+  const raw = loadRawConfig();
+  const mcpConfig = raw.mcp as Record<string, unknown> | undefined;
+  const serverMap = mcpConfig?.servers as Record<string, unknown> | undefined;
+
+  if (!serverMap || !serverMap[name]) {
+    throw new NotFoundError(`MCP server "${name}" not found.`);
+  }
+
+  // Best-effort cleanup of any OAuth credentials stored for this server
+  const serverConfig = serverMap[name] as Record<string, unknown>;
+  const transport = serverConfig?.transport as
+    | Record<string, unknown>
+    | undefined;
+  if (transport?.type === "sse" || transport?.type === "streamable-http") {
+    try {
+      await deleteMcpOAuthCredentials(name);
+    } catch {
+      // Ignore — credentials may not exist
+    }
+  }
+
+  delete serverMap[name];
+  saveRawConfig(raw);
+  triggerReload("internal_mcp_remove");
+
+  return { removed: true };
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
 export const ROUTES: RouteDefinition[] = [
   {
     operationId: "internal_mcp_auth_start",
@@ -129,4 +363,44 @@ export const ROUTES: RouteDefinition[] = [
     tags: ["internal"],
     handler: handleMcpReload,
   },
+  {
+    operationId: "internal_mcp_list",
+    endpoint: "internal/mcp/list",
+    method: "GET",
+    summary: "List MCP servers with health status",
+    description:
+      "Returns configured MCP servers with live health-check results (connected, needs auth, error, disabled).",
+    tags: ["internal"],
+    handler: handleMcpList,
+  },
+  {
+    operationId: "internal_mcp_add",
+    endpoint: "internal/mcp/add",
+    method: "POST",
+    summary: "Add an MCP server configuration",
+    description:
+      "Writes a new MCP server entry to config.json and triggers a reload.",
+    tags: ["internal"],
+    requestBody: z.object({
+      name: z.string(),
+      transportType: z.string(),
+      url: z.string().optional(),
+      command: z.string().optional(),
+      args: z.array(z.string()).optional(),
+      risk: z.string().optional(),
+      disabled: z.boolean().optional(),
+    }),
+    handler: handleMcpAdd,
+  },
+  {
+    operationId: "internal_mcp_remove",
+    endpoint: "internal/mcp/remove",
+    method: "POST",
+    summary: "Remove an MCP server configuration",
+    description:
+      "Removes an MCP server from config.json, cleans up OAuth credentials, and triggers a reload.",
+    tags: ["internal"],
+    requestBody: z.object({ name: z.string() }),
+    handler: handleMcpRemove,
+  },
 ];