@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/notifications/types.ts

@@ -10,8 +10,7 @@
 import { ApprovalUIMetadataSchema } from "@vellumai/gateway-client";
 import { z } from "zod";
 
-import type { ChannelPolicies } from "../channels/config.js";
-import type { ChannelId } from "../channels/types.js";
+import type { DeliverableChannelId } from "../channels/config.js";
 import { AccessRequestPayloadSchema } from "./access-request-copy.js";
 import { ToolApprovalSourceViewSchema } from "./guardian-question-mode.js";
 import { UrgencySchema } from "./urgency.js";
@@ -20,12 +19,7 @@ import { UrgencySchema } from "./urgency.js";
  * Derived from the channel policy registry: only channels whose
  * deliveryEnabled flag is true are valid notification channels.
  */
-export type NotificationChannel = {
-  [K in keyof ChannelPolicies]: ChannelPolicies[K]["notification"]["deliveryEnabled"] extends true
-    ? K
-    : never;
-}[keyof ChannelPolicies] &
-  ChannelId;
+export type NotificationChannel = DeliverableChannelId;
 
 export const NotificationDeliveryStatusSchema = z.enum([
   "pending",

package/src/oauth/__tests__/seed-providers-managed.test.ts

@@ -11,6 +11,24 @@ describe("PROVIDER_SEED_DATA managed mode wiring", () => {
     expect("github-oauth" in ServicesSchema.shape).toBe(true);
   });
 
+  test("monday only exposes scopes supported by its OAuth API", () => {
+    const monday = PROVIDER_SEED_DATA.monday;
+    expect(monday).toBeDefined();
+    expect(monday.defaultScopes).not.toContain("items:read");
+    expect(monday.defaultScopes).not.toContain("items:write");
+
+    const availableScopes = monday.availableScopes;
+    expect(Array.isArray(availableScopes)).toBe(true);
+    if (Array.isArray(availableScopes)) {
+      expect(availableScopes.map(({ scope }) => scope)).not.toContain(
+        "items:read",
+      );
+      expect(availableScopes.map(({ scope }) => scope)).not.toContain(
+        "items:write",
+      );
+    }
+  });
+
   test("google base URL is host-only so relative paths select the product", () => {
     // A host-only base URL (no product path) lets a relative request path pick
     // the Google product — Gmail (/gmail/v1/...), Calendar (/calendar/v3/...),

package/src/oauth/connect-orchestrator.ts

@@ -19,6 +19,7 @@
  * - Running identity verifiers
  */
 
+import { loadConfig } from "../config/loader.js";
 import { emitPostConnectNudge } from "../home/post-connect-feed.js";
 import { invalidateAssistantSuggestedPromptsCache } from "../home/suggested-prompts-cache.js";
 import type { TokenEndpointAuthMethod } from "../security/oauth2.js";
@@ -27,6 +28,7 @@ import { getLogger } from "../util/logger.js";
 import type { OAuthConnectResult } from "./connect-types.js";
 import { verifyIdentity } from "./identity-verifier.js";
 import { getProvider } from "./oauth-store.js";
+import { isProviderVisible } from "./provider-visibility.js";
 import { storeOAuth2Tokens } from "./token-persistence.js";
 
 const log = getLogger("oauth-connect-orchestrator");
@@ -130,6 +132,20 @@ export async function orchestrateOAuthConnect(
     };
   }
 
+  // A provider gated behind a disabled feature flag is not connectable. This
+  // is the choke point every connect path funnels through (runtime routes,
+  // gateway, CLI, credential vault tool), so enforcing here covers all of
+  // them rather than relying on each entry point to check. The error matches
+  // the not-found case above so a gated provider is indistinguishable from an
+  // absent one, mirroring the provider routes.
+  if (!isProviderVisible(providerRow, loadConfig())) {
+    return {
+      success: false,
+      error: `No OAuth provider registered for "${options.service}". Ensure the provider is seeded in the database.`,
+      safeError: true,
+    };
+  }
+
   // Deserialize JSON fields from the DB row
   const dbAuthorizeParams = safeJsonParse<Record<string, string> | undefined>(
     providerRow.authorizeParams,

package/src/oauth/seed-providers.ts

@@ -684,6 +684,268 @@ export const PROVIDER_SEED_DATA: Record<
     identityResponsePaths: ["email", "preferred_username"],
   },
 
+  monday: {
+    provider: "monday",
+    authorizeUrl: "https://auth.monday.com/oauth2/authorize",
+    tokenExchangeUrl: "https://auth.monday.com/oauth2/token",
+    pingUrl: "https://api.monday.com/v2",
+    pingMethod: "POST",
+    pingHeaders: { "Content-Type": "application/json" },
+    pingBody: { query: "{ me { id name email } }" },
+    baseUrl: "https://api.monday.com",
+    displayLabel: "monday.com",
+    description: "Boards, items, docs, and updates",
+    dashboardUrl: "https://auth.monday.com/apps",
+    clientIdPlaceholder: null,
+    // Simple Icons does not host a monday.com mark (both `monday` and
+    // `mondaydotcom` 404 on the CDN), so use the documented thesvg fallback.
+    logoUrl:
+      "https://cdn.jsdelivr.net/gh/glincker/thesvg@main/public/icons/monday/default.svg",
+    // monday tokens do not expire under the legacy OAuth flow and no refresh
+    // token is issued, so there is no refreshUrl. The newer OAuth 2.1 flow
+    // adds expiry/refresh/revocation but is opt-in per app version in the
+    // Developer Center and posts JSON (not form-encoded) credentials, so it
+    // is deliberately not used here.
+    defaultScopes: [
+      "me:read",
+      "account:read",
+      "users:read",
+      "teams:read",
+      "workspaces:read",
+      "boards:read",
+      "boards:write",
+      "docs:read",
+      "updates:read",
+      "updates:write",
+      "assets:read",
+      "tags:read",
+      "notifications:write",
+    ],
+    availableScopes: [
+      { scope: "me:read", description: "Read the user's profile information" },
+      {
+        scope: "account:read",
+        description: "Read general information about the account",
+      },
+      {
+        scope: "users:read",
+        description: "Read profile information of the account's users",
+      },
+      {
+        scope: "users:write",
+        description: "Modify profile information of the account's users",
+      },
+      {
+        scope: "teams:read",
+        description: "Read information about the account's teams",
+      },
+      { scope: "teams:write", description: "Modify the account's teams" },
+      {
+        scope: "workspaces:read",
+        description: "Read a user's workspaces data",
+      },
+      {
+        scope: "workspaces:write",
+        description: "Modify a user's workspaces data",
+      },
+      { scope: "boards:read", description: "Read a user's board data" },
+      { scope: "boards:write", description: "Modify a user's board data" },
+      { scope: "docs:read", description: "Read a user's docs" },
+      { scope: "docs:write", description: "Modify a user's docs" },
+      {
+        scope: "updates:read",
+        description: "Read updates and replies the user can see",
+      },
+      {
+        scope: "updates:write",
+        description: "Post or edit updates on behalf of the user",
+      },
+      {
+        scope: "assets:read",
+        description: "Read data from assets the user has access to",
+      },
+      { scope: "tags:read", description: "Read the account's tags" },
+      {
+        scope: "notifications:write",
+        description: "Send notifications on behalf of the user",
+      },
+      {
+        scope: "webhooks:read",
+        description: "Read existing webhooks configuration",
+      },
+      {
+        scope: "webhooks:write",
+        description: "Create and modify webhooks",
+      },
+      {
+        scope: "departments:read",
+        description: "Read the account's department data",
+      },
+      {
+        scope: "departments:write",
+        description: "Modify the account's departments",
+      },
+    ],
+    tokenEndpointAuthMethod: "client_secret_post",
+    // 17337/17338 are taken by eventbrite/calendly (all three providers
+    // landed in parallel and independently picked the next free port at the
+    // time); 17339 is the real next-free slot once all three are seeded
+    // together.
+    loopbackPort: 17339,
+    managedServiceConfigKey: "monday-oauth",
+    injectionTemplates: [
+      {
+        hostPattern: "api.monday.com",
+        injectionType: "header",
+        headerName: "Authorization",
+        valuePrefix: "Bearer ",
+      },
+    ],
+    appType: "App",
+    identityUrl: "https://api.monday.com/v2",
+    identityMethod: "POST",
+    identityHeaders: { "Content-Type": "application/json" },
+    identityBody: { query: "{ me { id name email } }" },
+    identityResponsePaths: ["data.me.name", "data.me.email"],
+    featureFlag: "monday-oauth",
+  },
+
+  eventbrite: {
+    provider: "eventbrite",
+    authorizeUrl: "https://www.eventbrite.com/oauth/authorize",
+    tokenExchangeUrl: "https://www.eventbrite.com/oauth/token",
+    refreshUrl: "https://www.eventbrite.com/oauth/token",
+    pingUrl: "https://www.eventbriteapi.com/v3/users/me/",
+    baseUrl: "https://www.eventbriteapi.com",
+    displayLabel: "Eventbrite",
+    description: "Events, attendees, and ticket orders",
+    dashboardUrl: "https://www.eventbrite.com/platform/api-keys/",
+    clientIdPlaceholder: null,
+    // Simple Icons does not host an Eventbrite mark (cdn.simpleicons.org
+    // 404s), so use the documented thesvg fallback.
+    logoUrl:
+      "https://cdn.jsdelivr.net/gh/glincker/thesvg@main/public/icons/eventbrite/default.svg",
+    // Eventbrite has no granular OAuth scope system: an access token carries
+    // the full permissions of the user who authorized it, and the authorize
+    // endpoint ignores a `scope` parameter. Seed an empty set rather than
+    // inventing scope strings the provider would silently drop (same shape
+    // as Notion).
+    defaultScopes: [],
+    tokenEndpointAuthMethod: "client_secret_post",
+    loopbackPort: 17337,
+    managedServiceConfigKey: "eventbrite-oauth",
+    injectionTemplates: [
+      {
+        hostPattern: "www.eventbriteapi.com",
+        injectionType: "header",
+        headerName: "Authorization",
+        valuePrefix: "Bearer ",
+      },
+    ],
+    appType: "App",
+    identityUrl: "https://www.eventbriteapi.com/v3/users/me/",
+    identityResponsePaths: ["name", "first_name"],
+  },
+
+  calendly: {
+    provider: "calendly",
+    authorizeUrl: "https://auth.calendly.com/oauth/authorize",
+    tokenExchangeUrl: "https://auth.calendly.com/oauth/token",
+    pingUrl: "https://api.calendly.com/users/me",
+    baseUrl: "https://api.calendly.com",
+    displayLabel: "Calendly",
+    description: "Scheduling links and meetings",
+    dashboardUrl: "https://calendly.com/integrations/api_webhooks",
+    clientIdPlaceholder: null,
+    logoUrl: "https://cdn.simpleicons.org/calendly",
+    // A :write scope implicitly grants the matching :read in the same domain,
+    // so the baseline stays at the six that map to reading schedule data and
+    // creating bookings/links. Organization-wide visibility is opt-in.
+    defaultScopes: [
+      "users:read",
+      "event_types:read",
+      "scheduled_events:read",
+      "availability:read",
+      "scheduled_events:write",
+      "scheduling_links:write",
+    ],
+    availableScopes: [
+      { scope: "users:read", description: "Read the connected user's profile" },
+      {
+        scope: "event_types:read",
+        description: "Read event types and their available times",
+      },
+      {
+        scope: "event_types:write",
+        description: "Create and update event types",
+      },
+      {
+        scope: "scheduled_events:read",
+        description: "Read scheduled events and invitees",
+      },
+      {
+        scope: "scheduled_events:write",
+        description: "Create invitees, cancel events, mark no-shows",
+      },
+      {
+        scope: "availability:read",
+        description: "Read busy times and availability schedules",
+      },
+      {
+        scope: "availability:write",
+        description: "Update event type availability",
+      },
+      {
+        scope: "scheduling_links:write",
+        description: "Create single-use scheduling links",
+      },
+      {
+        scope: "shares:write",
+        description: "Create customized single-use scheduling links",
+      },
+      {
+        scope: "organizations:read",
+        description: "Read organization data and memberships",
+      },
+      {
+        scope: "groups:read",
+        description: "Read group details and relationships",
+      },
+      {
+        scope: "webhooks:read",
+        description: "Read webhook subscriptions",
+      },
+      {
+        scope: "webhooks:write",
+        description: "Create and delete webhook subscriptions",
+      },
+      { scope: "contacts:read", description: "Read contact details" },
+      {
+        scope: "contacts:write",
+        description: "Create, update, and delete contacts",
+      },
+    ],
+    tokenEndpointAuthMethod: "client_secret_basic",
+    // 17337 is taken by eventbrite (both providers landed in parallel and
+    // independently picked the next free port at the time); 17338 is the
+    // real next-free slot once both are seeded together.
+    loopbackPort: 17338,
+    managedServiceConfigKey: "calendly-oauth",
+    injectionTemplates: [
+      {
+        hostPattern: "api.calendly.com",
+        injectionType: "header",
+        headerName: "Authorization",
+        valuePrefix: "Bearer ",
+      },
+    ],
+    revokeUrl: "https://auth.calendly.com/oauth/revoke",
+    revokeBodyTemplate: { token: "{access_token}" },
+    appType: "App",
+    identityUrl: "https://api.calendly.com/users/me",
+    identityResponsePaths: ["resource.email", "resource.name"],
+  },
+
   figma: {
     provider: "figma",
     authorizeUrl: "https://www.figma.com/oauth",

package/src/permissions/checker.test.ts

@@ -547,6 +547,27 @@ describe("Permission Checker (gateway IPC)", () => {
       expect(result.level).toBe(RiskLevel.Medium);
     });
 
+    test("builds PowerShell params for Windows host_bash", async () => {
+      mockIpcClassifyRiskResult = {
+        risk: "high",
+        reason: "PowerShell mutation",
+        matchType: "registry",
+        scopeOptions: [],
+      };
+
+      await classifyRisk(
+        "host_bash",
+        { command: "Remove-Item C:\\Temp\\data" },
+        "C:\\Users\\Example",
+        undefined,
+        undefined,
+        undefined,
+        "powershell",
+      );
+
+      expect(lastClassifyRiskParams?.shell).toBe("powershell");
+    });
+
     test("builds params for file tools", async () => {
       mockIpcClassifyRiskResult = {
         risk: "low",

package/src/permissions/checker.ts

@@ -420,6 +420,7 @@ function buildClassifyRiskParams(
   input: Record<string, unknown>,
   workingDir?: string,
   manifestOverride?: ManifestOverride,
+  shell?: ClassifyRiskIpcParams["shell"],
 ): ClassifyRiskIpcParams {
   // ── Bash/host_bash ──
   if (toolName === "bash" || toolName === "host_bash") {
@@ -437,6 +438,7 @@ function buildClassifyRiskParams(
     return {
       tool: toolName,
       command: getStringField(input, "command"),
+      shell,
       workingDir,
       workspaceRoot: getWorkspaceDir(),
       isContainerized: getIsContainerized(),
@@ -577,6 +579,7 @@ export async function classifyRisk(
   _preParsed?: unknown,
   manifestOverride?: ManifestOverride,
   signal?: AbortSignal,
+  shell?: ClassifyRiskIpcParams["shell"],
 ): Promise<RiskClassificationWithMeta> {
   signal?.throwIfAborted();
 
@@ -585,6 +588,7 @@ export async function classifyRisk(
     input,
     workingDir,
     manifestOverride,
+    shell,
   );
   const gatewayResult = await ipcClassifyRisk(ipcParams, signal);
   // A mid-retry cancellation should surface as an AbortError, not the
@@ -709,6 +713,7 @@ export async function check(
     policyContext?.conversationId,
     policyContext?.executionContext,
     cellQuery,
+    policyContext?.requesterContactId,
   );
   const approvalContext: ApprovalContext = {
     riskLevel: risk,
@@ -740,6 +745,7 @@ export async function check(
       policyContext?.conversationId,
       policyContext?.executionContext,
       cellQuery,
+      policyContext?.requesterContactId,
     );
     if (freshThreshold !== null && freshThreshold !== threshold) {
       approvalDecision = defaultApprovalPolicy.evaluate({

package/src/permissions/gateway-threshold-reader.test.ts

@@ -37,6 +37,9 @@ import {
   _clearGlobalCacheForTesting,
   _resetFailureCoalesceForTesting,
   getAutoApproveThreshold,
+  getContactAutoApproveThreshold,
+  invalidateAllContactThresholdCaches,
+  invalidateContactThresholdCache,
   refreshAutoApproveThreshold,
 } from "./gateway-threshold-reader.js";
 
@@ -633,3 +636,184 @@ describe("contact cell layer failure semantics", () => {
     ).toBe("low");
   });
 });
+
+describe("contact-level ceiling", () => {
+  beforeEach(() => {
+    _clearGlobalCacheForTesting();
+    _resetFailureCoalesceForTesting();
+    ipcHandlers.clear();
+    ipcCallLog.length = 0;
+  });
+
+  test("the conversation override beats the contact ceiling", async () => {
+    ipcHandlers.set("get_conversation_threshold", () => ({
+      threshold: "none",
+    }));
+    ipcHandlers.set("get_contact_threshold", () => ({ threshold: "high" }));
+    ipcHandlers.set("resolve_channel_permission_threshold", () => ({
+      resolved: { threshold: "low", scope: "channel" },
+    }));
+    setGlobals("low");
+
+    expect(
+      await getAutoApproveThreshold(
+        "conv-ct1",
+        "conversation",
+        CELL_QUERY,
+        "contact-1",
+      ),
+    ).toBe("none");
+    expect(countCalls("get_contact_threshold")).toBe(0);
+    expect(countCalls("resolve_channel_permission_threshold")).toBe(0);
+  });
+
+  test("the contact ceiling beats the cell", async () => {
+    ipcHandlers.set("get_conversation_threshold", () => null);
+    ipcHandlers.set("get_contact_threshold", () => ({ threshold: "high" }));
+    ipcHandlers.set("resolve_channel_permission_threshold", () => ({
+      resolved: { threshold: "none", scope: "channel" },
+    }));
+    setGlobals("low");
+
+    expect(
+      await getAutoApproveThreshold(
+        "conv-ct2",
+        "conversation",
+        CELL_QUERY,
+        "contact-1",
+      ),
+    ).toBe("high");
+    expect(countCalls("resolve_channel_permission_threshold")).toBe(0);
+  });
+
+  test("the contact ceiling is not collapsed", async () => {
+    ipcHandlers.set("get_conversation_threshold", () => null);
+    ipcHandlers.set("get_contact_threshold", () => ({ threshold: "medium" }));
+    ipcHandlers.set("resolve_channel_permission_threshold", () => ({
+      resolved: { threshold: "none", scope: "channel" },
+    }));
+    setGlobals("low");
+
+    expect(
+      await getAutoApproveThreshold(
+        "conv-ct3",
+        "conversation",
+        CELL_QUERY,
+        "contact-1",
+      ),
+    ).toBe("medium");
+  });
+
+  test("a null contact ceiling inherits the cell cascade", async () => {
+    ipcHandlers.set("get_conversation_threshold", () => null);
+    ipcHandlers.set("get_contact_threshold", () => null);
+    ipcHandlers.set("resolve_channel_permission_threshold", () => ({
+      resolved: { threshold: "none", scope: "channel" },
+    }));
+    setGlobals("high");
+
+    expect(
+      await getAutoApproveThreshold(
+        "conv-ct4",
+        "conversation",
+        CELL_QUERY,
+        "contact-1",
+      ),
+    ).toBe("none");
+  });
+
+  test("a contact-threshold transport failure falls through to the cell", async () => {
+    ipcHandlers.set("get_conversation_threshold", () => null);
+    ipcHandlers.set("resolve_channel_permission_threshold", () => ({
+      resolved: { threshold: "none", scope: "channel" },
+    }));
+    setGlobals("high");
+
+    expect(
+      await getAutoApproveThreshold(
+        "conv-ct-fail",
+        "conversation",
+        CELL_QUERY,
+        "contact-1",
+      ),
+    ).toBe("none");
+  });
+
+  test("refresh honors the contact ceiling after a conversation miss", async () => {
+    ipcHandlers.set("get_conversation_threshold", () => null);
+    ipcHandlers.set("get_contact_threshold", () => ({ threshold: "high" }));
+    ipcHandlers.set("resolve_channel_permission_threshold", () => ({
+      resolved: { threshold: "none", scope: "channel" },
+    }));
+    setGlobals("low");
+
+    expect(
+      await refreshAutoApproveThreshold(
+        "conv-ct5",
+        "conversation",
+        CELL_QUERY,
+        "contact-1",
+      ),
+    ).toBe("high");
+    expect(countCalls("resolve_channel_permission_threshold")).toBe(0);
+  });
+
+  test("refresh keeps the prompt when the contact lookup fails", async () => {
+    ipcHandlers.set("get_conversation_threshold", () => null);
+    ipcHandlers.set("resolve_channel_permission_threshold", () => ({
+      resolved: { threshold: "low", scope: "channel" },
+    }));
+    setGlobals("high");
+
+    expect(
+      await refreshAutoApproveThreshold(
+        "conv-ct6",
+        "conversation",
+        CELL_QUERY,
+        "contact-1",
+      ),
+    ).toBeNull();
+    expect(countCalls("resolve_channel_permission_threshold")).toBe(0);
+  });
+
+  test("getContactAutoApproveThreshold returns a live ceiling and caches it", async () => {
+    ipcHandlers.set("get_contact_threshold", () => ({ threshold: "high" }));
+
+    expect(await getContactAutoApproveThreshold("contact-1")).toBe("high");
+    expect(await getContactAutoApproveThreshold("contact-1")).toBe("high");
+    expect(countCalls("get_contact_threshold")).toBe(1);
+  });
+
+  test("invalidateContactThresholdCache drops a cached ceiling", async () => {
+    ipcHandlers.set("get_contact_threshold", () => ({ threshold: "high" }));
+    expect(await getContactAutoApproveThreshold("contact-1")).toBe("high");
+
+    invalidateContactThresholdCache("contact-1");
+    ipcHandlers.set("get_contact_threshold", () => ({ threshold: "low" }));
+
+    expect(await getContactAutoApproveThreshold("contact-1")).toBe("low");
+    expect(countCalls("get_contact_threshold")).toBe(2);
+  });
+
+  test("invalidateAllContactThresholdCaches drops every cached ceiling", async () => {
+    ipcHandlers.set("get_contact_threshold", () => ({ threshold: "high" }));
+    expect(await getContactAutoApproveThreshold("contact-1")).toBe("high");
+
+    invalidateAllContactThresholdCaches();
+    ipcHandlers.set("get_contact_threshold", () => ({ threshold: "none" }));
+
+    expect(await getContactAutoApproveThreshold("contact-1")).toBe("none");
+    expect(countCalls("get_contact_threshold")).toBe(2);
+  });
+
+  test("getContactAutoApproveThreshold returns null for an unset contact", async () => {
+    ipcHandlers.set("get_contact_threshold", () => null);
+
+    expect(await getContactAutoApproveThreshold("contact-1")).toBeNull();
+  });
+
+  test("getContactAutoApproveThreshold returns null when contactId is missing", async () => {
+    expect(await getContactAutoApproveThreshold(undefined)).toBeNull();
+    expect(countCalls("get_contact_threshold")).toBe(0);
+  });
+});