@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/conversation-tool-setup-batch-authorized.test.ts

@@ -0,0 +1,226 @@
+/**
+ * Tests that createToolExecutor computes `batchAuthorizedByTask` against the
+ * *dispatched* tool name, not the outer `skill_execute` wrapper. Task rules in
+ * required_tools contain underlying tool names (e.g. "gmail_archive"), so a
+ * regression here would silently break batch authorization for every
+ * skill-dispatched batch tool (gmail_archive, gmail_unsubscribe,
+ * messaging_archive_by_sender, outlook_unsubscribe).
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import type { ToolSetupContext } from "../daemon/conversation-tool-setup.js";
+import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
+import type { PermissionPrompter } from "../permissions/prompter.js";
+import type { SecretPrompter } from "../permissions/secret-prompter.js";
+import {
+  buildTaskRules,
+  clearTaskRunRules,
+  setTaskRunRules,
+} from "../tasks/ephemeral-permissions.js";
+import type { ToolExecutor } from "../tools/executor.js";
+import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+mock.module("../daemon/conversation-surfaces.js", () => ({
+  refreshSurfacesForApp: mock(() => {}),
+  surfaceProxyResolver: mock(() =>
+    Promise.resolve({ content: "", isError: false }),
+  ),
+}));
+
+mock.module("../services/published-app-updater.js", () => ({
+  updatePublishedAppDeployment: mock(() => Promise.resolve()),
+}));
+
+mock.module("../tools/browser/browser-screencast.js", () => ({
+  registerConversationSender: mock(() => {}),
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { createToolExecutor } from "../daemon/conversation-tool-setup.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
+  return {
+    conversationId: "conv-batch-auth",
+    currentRequestId: "req-1",
+    workingDir: "/tmp/test",
+    abortController: null,
+    traceEmitter: { emit: () => {} },
+    sendToClient: mock(() => {}),
+    pendingSurfaceActions: new Map(),
+    lastSurfaceAction: new Map(),
+    surfaceState: new Map<
+      string,
+      { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    >(),
+    surfaceUndoStacks: new Map(),
+    accumulatedSurfaceState: new Map(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "r" }),
+    getQueueDepth: () => 0,
+    processMessage: async () => "",
+    withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
+    memoryPolicy: { scopeId: "default", strictSideEffects: false },
+    ...overrides,
+  };
+}
+
+/** Executor spy that captures the ToolContext passed to execute(). */
+function makeCapturingExecutor(
+  result: ToolExecutionResult = { content: "ok", isError: false },
+) {
+  let captured: { name: string; ctx: ToolContext } | undefined;
+  return {
+    executor: {
+      execute: mock(
+        async (
+          name: string,
+          _input: Record<string, unknown>,
+          ctx: ToolContext,
+        ) => {
+          captured = { name, ctx };
+          return result;
+        },
+      ),
+    },
+    getCaptured: () => captured,
+  };
+}
+
+const noopPrompter = {
+  prompt: mock(async () => ({ decision: "allow" as const })),
+} as unknown as PermissionPrompter;
+const noopSecretPrompter = {
+  prompt: mock(async () => ({ cancelled: true })),
+} as unknown as SecretPrompter;
+const noopLifecycleHandler = mock(() => {});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("createToolExecutor — batchAuthorizedByTask for skill_execute dispatch", () => {
+  const taskRunId = "task-run-skill-dispatch";
+
+  afterEach(() => {
+    clearTaskRunRules(taskRunId);
+  });
+
+  test("sets batchAuthorizedByTask=true when dispatched tool is in required_tools", async () => {
+    setTaskRunRules(
+      taskRunId,
+      buildTaskRules(taskRunId, ["gmail_archive"], "/tmp"),
+    );
+
+    const ctx = makeCtx({ taskRunId });
+    const { executor, getCaptured } = makeCapturingExecutor();
+
+    const toolFn = createToolExecutor(
+      executor as unknown as ToolExecutor,
+      noopPrompter,
+      noopSecretPrompter,
+      ctx,
+      noopLifecycleHandler,
+    );
+
+    await toolFn("skill_execute", {
+      tool: "gmail_archive",
+      input: { message_ids: ["m1", "m2"] },
+    });
+
+    const captured = getCaptured();
+    expect(captured).toBeDefined();
+    expect(captured!.name).toBe("gmail_archive");
+    expect(captured!.ctx.batchAuthorizedByTask).toBe(true);
+  });
+
+  test("sets batchAuthorizedByTask=false when dispatched tool is NOT in required_tools", async () => {
+    // Task allows host_bash but not gmail_archive.
+    setTaskRunRules(
+      taskRunId,
+      buildTaskRules(taskRunId, ["host_bash"], "/tmp"),
+    );
+
+    const ctx = makeCtx({ taskRunId });
+    const { executor, getCaptured } = makeCapturingExecutor();
+
+    const toolFn = createToolExecutor(
+      executor as unknown as ToolExecutor,
+      noopPrompter,
+      noopSecretPrompter,
+      ctx,
+      noopLifecycleHandler,
+    );
+
+    await toolFn("skill_execute", {
+      tool: "gmail_archive",
+      input: { message_ids: ["m1", "m2"] },
+    });
+
+    const captured = getCaptured();
+    expect(captured).toBeDefined();
+    expect(captured!.ctx.batchAuthorizedByTask).toBe(false);
+  });
+
+  test("does not get fooled by 'skill_execute' appearing in required_tools", async () => {
+    // Regression guard: if the outer name were used, this malformed task
+    // would accidentally authorize arbitrary batch tools.
+    setTaskRunRules(
+      taskRunId,
+      buildTaskRules(taskRunId, ["skill_execute"], "/tmp"),
+    );
+
+    const ctx = makeCtx({ taskRunId });
+    const { executor, getCaptured } = makeCapturingExecutor();
+
+    const toolFn = createToolExecutor(
+      executor as unknown as ToolExecutor,
+      noopPrompter,
+      noopSecretPrompter,
+      ctx,
+      noopLifecycleHandler,
+    );
+
+    await toolFn("skill_execute", {
+      tool: "gmail_archive",
+      input: { message_ids: ["m1", "m2"] },
+    });
+
+    expect(getCaptured()!.ctx.batchAuthorizedByTask).toBe(false);
+  });
+
+  test("regular (non-skill_execute) dispatch still consults required_tools by outer name", async () => {
+    setTaskRunRules(
+      taskRunId,
+      buildTaskRules(taskRunId, ["host_bash"], "/tmp"),
+    );
+
+    const ctx = makeCtx({ taskRunId });
+    const { executor, getCaptured } = makeCapturingExecutor();
+
+    const toolFn = createToolExecutor(
+      executor as unknown as ToolExecutor,
+      noopPrompter,
+      noopSecretPrompter,
+      ctx,
+      noopLifecycleHandler,
+    );
+
+    await toolFn("host_bash", { command: "ls" });
+
+    expect(getCaptured()!.ctx.batchAuthorizedByTask).toBe(true);
+  });
+});

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -125,6 +125,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationContextWindow: () => {},
   deleteMessageById: () => ({ segmentIds: [], deletedSummaryIds: [] }),
   deleteLastExchange: () => 0,
+  getMessageById: () => null,
+  getLastUserTimestampBefore: () => 0,
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -122,6 +122,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationContextWindow: () => {},
   deleteMessageById: () => ({ segmentIds: [], deletedSummaryIds: [] }),
   deleteLastExchange: () => 0,
+  getMessageById: () => null,
+  getLastUserTimestampBefore: () => 0,
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/credential-health-service.test.ts

@@ -0,0 +1,352 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mutable state for mocks ──────────────────────────────────────────
+
+const secureKeyValues = new Map<string, string>();
+
+let mockProviders: Array<{
+  provider: string;
+  defaultScopes: string;
+  pingUrl: string | null;
+  pingMethod: string | null;
+  pingHeaders: string | null;
+  pingBody: string | null;
+}> = [];
+
+let mockConnections: Map<
+  string,
+  Array<{
+    id: string;
+    provider: string;
+    accountInfo: string | null;
+    grantedScopes: string;
+    expiresAt: number | null;
+    hasRefreshToken: number;
+    status: string;
+  }>
+> = new Map();
+
+let mockFetchResponse: { ok: boolean; status: number } = {
+  ok: true,
+  status: 200,
+};
+let mockFetchThrows = false;
+
+// ── Module mocks ─────────────────────────────────────────────────────
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async (account: string) => secureKeyValues.get(account),
+  setSecureKeyAsync: async () => {},
+  deleteSecureKeyAsync: async () => "deleted",
+  listSecureKeysAsync: async () => [],
+  getProviderKeyAsync: async () => undefined,
+  getMaskedProviderKey: () => undefined,
+}));
+
+mock.module("../oauth/oauth-store.js", () => ({
+  listProviders: () => mockProviders,
+  listActiveConnectionsByProvider: (provider: string) =>
+    mockConnections.get(provider) ?? [],
+  getProvider: (provider: string) =>
+    mockProviders.find((p) => p.provider === provider),
+  isProviderConnected: () => false,
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    debug: () => {},
+    error: () => {},
+  }),
+}));
+
+// ── Import under test ────────────────────────────────────────────────
+
+const {
+  checkAllCredentials,
+  checkCredentialForProvider,
+  _setFetchFn,
+} = await import("../credential-health/credential-health-service.js");
+
+// Inject mock fetch via the test helper (Bun's global fetch can't be
+// overridden via globalThis assignment).
+_setFetchFn((async () => {
+  if (mockFetchThrows) {
+    throw new Error("Network error");
+  }
+  return {
+    ok: mockFetchResponse.ok,
+    status: mockFetchResponse.status,
+  } as Response;
+}) as unknown as typeof fetch);
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function addProvider(
+  provider: string,
+  opts?: {
+    defaultScopes?: string[];
+    pingUrl?: string | null;
+    pingMethod?: string | null;
+  },
+) {
+  mockProviders.push({
+    provider,
+    defaultScopes: JSON.stringify(opts?.defaultScopes ?? []),
+    pingUrl: opts?.pingUrl ?? null,
+    pingMethod: opts?.pingMethod ?? null,
+    pingHeaders: null,
+    pingBody: null,
+  });
+}
+
+function addConnection(
+  provider: string,
+  id: string,
+  opts?: {
+    expiresAt?: number | null;
+    hasRefreshToken?: boolean;
+    grantedScopes?: string[];
+    accountInfo?: string | null;
+  },
+) {
+  const conns = mockConnections.get(provider) ?? [];
+  conns.push({
+    id,
+    provider,
+    accountInfo: opts?.accountInfo ?? `user@${provider}.com`,
+    grantedScopes: JSON.stringify(opts?.grantedScopes ?? []),
+    expiresAt: opts?.expiresAt ?? null,
+    hasRefreshToken: opts?.hasRefreshToken ? 1 : 0,
+    status: "active",
+  });
+  mockConnections.set(provider, conns);
+}
+
+function setToken(connectionId: string, token = "mock-token") {
+  secureKeyValues.set(
+    `oauth_connection/${connectionId}/access_token`,
+    token,
+  );
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe("credential-health-service", () => {
+  beforeEach(() => {
+    secureKeyValues.clear();
+    mockProviders = [];
+    mockConnections = new Map();
+    mockFetchResponse = { ok: true, status: 200 };
+    mockFetchThrows = false;
+  });
+
+  test("returns empty report when no providers exist", async () => {
+    const report = await checkAllCredentials();
+    expect(report.results).toHaveLength(0);
+    expect(report.unhealthy).toHaveLength(0);
+    expect(report.checkedAt).toBeGreaterThan(0);
+  });
+
+  test("returns empty report when provider has no connections", async () => {
+    addProvider("google");
+    const report = await checkAllCredentials();
+    expect(report.results).toHaveLength(0);
+    expect(report.unhealthy).toHaveLength(0);
+  });
+
+  test("returns healthy for connection with valid token and future expiry", async () => {
+    addProvider("google");
+    addConnection("google", "conn-1", {
+      expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000, // 30 days
+      hasRefreshToken: true,
+    });
+    setToken("conn-1");
+
+    const report = await checkAllCredentials();
+    expect(report.results).toHaveLength(1);
+    expect(report.results[0]!.status).toBe("healthy");
+    expect(report.unhealthy).toHaveLength(0);
+  });
+
+  test("returns missing_token when no access token in secure storage", async () => {
+    addProvider("google");
+    addConnection("google", "conn-1");
+    // Don't set token
+
+    const report = await checkAllCredentials();
+    expect(report.results).toHaveLength(1);
+    expect(report.results[0]!.status).toBe("missing_token");
+    expect(report.results[0]!.canAutoRecover).toBe(false);
+    expect(report.unhealthy).toHaveLength(1);
+  });
+
+  test("returns expired when token is past expiresAt without refresh token", async () => {
+    addProvider("google");
+    addConnection("google", "conn-1", {
+      expiresAt: Date.now() - 60_000, // 1 minute ago
+      hasRefreshToken: false,
+    });
+    setToken("conn-1");
+
+    const report = await checkAllCredentials();
+    expect(report.results[0]!.status).toBe("expired");
+    expect(report.results[0]!.canAutoRecover).toBe(false);
+  });
+
+  test("returns expiring when token is past expiresAt with refresh token", async () => {
+    addProvider("google");
+    addConnection("google", "conn-1", {
+      expiresAt: Date.now() - 60_000, // 1 minute ago
+      hasRefreshToken: true,
+    });
+    setToken("conn-1");
+
+    const report = await checkAllCredentials();
+    expect(report.results[0]!.status).toBe("expiring");
+    expect(report.results[0]!.canAutoRecover).toBe(true);
+  });
+
+  test("returns expiring when token expires within 7 days without refresh token", async () => {
+    addProvider("google");
+    addConnection("google", "conn-1", {
+      expiresAt: Date.now() + 3 * 24 * 60 * 60 * 1000, // 3 days from now
+      hasRefreshToken: false,
+    });
+    setToken("conn-1");
+
+    const report = await checkAllCredentials();
+    expect(report.results[0]!.status).toBe("expiring");
+    expect(report.results[0]!.canAutoRecover).toBe(false);
+  });
+
+  test("returns healthy when token expires within 7 days but has refresh token", async () => {
+    addProvider("google");
+    addConnection("google", "conn-1", {
+      expiresAt: Date.now() + 3 * 24 * 60 * 60 * 1000, // 3 days from now
+      hasRefreshToken: true,
+    });
+    setToken("conn-1");
+
+    const report = await checkAllCredentials();
+    expect(report.results[0]!.status).toBe("healthy");
+  });
+
+  test("returns missing_scopes when grantedScopes is subset of defaultScopes", async () => {
+    addProvider("slack", {
+      defaultScopes: ["chat:write", "channels:read", "im:write"],
+    });
+    addConnection("slack", "conn-1", {
+      grantedScopes: ["chat:write"],
+      expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000,
+    });
+    setToken("conn-1");
+
+    const report = await checkAllCredentials();
+    expect(report.results[0]!.status).toBe("missing_scopes");
+    expect(report.results[0]!.missingScopes).toEqual([
+      "channels:read",
+      "im:write",
+    ]);
+    expect(report.results[0]!.canAutoRecover).toBe(false);
+  });
+
+  test("returns revoked when ping returns 401", async () => {
+    mockFetchResponse = { ok: false, status: 401 };
+    addProvider("google", {
+      pingUrl: "https://www.googleapis.com/oauth2/v2/userinfo",
+    });
+    addConnection("google", "conn-1", {
+      expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000,
+    });
+    setToken("conn-1");
+
+    const report = await checkAllCredentials();
+    expect(report.results[0]!.status).toBe("revoked");
+    expect(report.results[0]!.canAutoRecover).toBe(false);
+  });
+
+  test("returns ping_failed on non-auth ping error", async () => {
+    mockFetchResponse = { ok: false, status: 500 };
+    addProvider("google", {
+      pingUrl: "https://www.googleapis.com/oauth2/v2/userinfo",
+    });
+    addConnection("google", "conn-1", {
+      expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000,
+    });
+    setToken("conn-1");
+
+    const report = await checkAllCredentials();
+    expect(report.results[0]!.status).toBe("ping_failed");
+  });
+
+  test("returns ping_failed on network error (does not throw)", async () => {
+    mockFetchThrows = true;
+    addProvider("google", {
+      pingUrl: "https://www.googleapis.com/oauth2/v2/userinfo",
+    });
+    addConnection("google", "conn-1", {
+      expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000,
+    });
+    setToken("conn-1");
+
+    const report = await checkAllCredentials();
+    // Network error -> ping_failed (non-auth), not an exception
+    expect(report.results[0]!.status).toBe("ping_failed");
+  });
+
+  test("checks multiple providers and connections", async () => {
+    addProvider("google");
+    addProvider("slack", {
+      defaultScopes: ["chat:write", "channels:read"],
+    });
+
+    addConnection("google", "conn-g1");
+    setToken("conn-g1");
+    addConnection("slack", "conn-s1", {
+      grantedScopes: ["chat:write", "channels:read"],
+      expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000,
+    });
+    setToken("conn-s1");
+
+    const report = await checkAllCredentials();
+    expect(report.results).toHaveLength(2);
+
+    const google = report.results.find((r) => r.provider === "google");
+    const slack = report.results.find((r) => r.provider === "slack");
+
+    // Google: token set, no expiry -> healthy
+    expect(google!.status).toBe("healthy");
+    // Slack: all scopes present, valid token -> healthy
+    expect(slack!.status).toBe("healthy");
+  });
+
+  describe("checkCredentialForProvider", () => {
+    test("returns null when no connections exist", async () => {
+      const result = await checkCredentialForProvider("google");
+      expect(result).toBeNull();
+    });
+
+    test("returns health result for the most recent connection", async () => {
+      addProvider("google");
+      addConnection("google", "conn-1", {
+        expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000,
+      });
+      setToken("conn-1");
+
+      const result = await checkCredentialForProvider("google");
+      expect(result).not.toBeNull();
+      expect(result!.status).toBe("healthy");
+      expect(result!.connectionId).toBe("conn-1");
+    });
+
+    test("returns unhealthy for missing token", async () => {
+      addProvider("google");
+      addConnection("google", "conn-1");
+
+      const result = await checkCredentialForProvider("google");
+      expect(result!.status).toBe("missing_token");
+    });
+  });
+});

package/src/__tests__/credential-security-invariants.test.ts

@@ -172,7 +172,6 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/handlers/config-vercel.ts", // Vercel API token management
       "runtime/routes/integrations/twilio.ts", // Twilio credential management (HTTP control-plane)
       "security/token-manager.ts", // OAuth token refresh flow
-      "email/providers/index.ts", // email provider API key lookup
       "tools/network/script-proxy/session-manager.ts", // proxy credential injection at runtime
       "calls/call-domain.ts", // caller identity resolution (user phone number lookup)
       "calls/twilio-config.ts", // call infrastructure credential lookup
@@ -185,6 +184,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/channel-readiness-service.ts", // channel readiness probes for Telegram connectivity
       "messaging/providers/whatsapp/adapter.ts", // WhatsApp credential lookup for connectivity check
       "messaging/providers/slack/adapter.ts", // Slack bot token lookup for Socket Mode connectivity check
+      "credential-health/credential-health-service.ts", // proactive credential health monitoring
       "daemon/handlers/config-slack-channel.ts", // Slack channel config credential management
       "providers/managed-proxy/context.ts", // managed proxy API key lookup for provider initialization
       "platform/client.ts", // platform client credential store fallback for standalone CLI auth
@@ -200,10 +200,8 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "oauth/oauth-store.ts", // OAuth provider disconnect (delete stored tokens)
       "oauth/manual-token-connection.ts", // manual-token provider backfill (credential store existence check)
       "workspace/provider-commit-message-generator.ts", // commit message generation provider key lookup
-      "config/bundled-skills/transcribe/tools/transcribe-media.ts", // transcription tool API key lookup
       "config/bundled-skills/image-studio/tools/media-generate-image.ts", // image generation tool API key lookup
       "config/bundled-skills/media-processing/tools/analyze-keyframes.ts", // keyframe analysis tool API key lookup
-      "config/bundled-skills/media-processing/tools/extract-keyframes.ts", // keyframe extraction tool API key lookup
       "providers/registry.ts", // provider registry API key lookup for initialization
       "providers/provider-availability.ts", // provider availability API key check
       "media/app-icon-generator.ts", // app icon generation API key lookup
@@ -217,6 +215,10 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "providers/speech-to-text/resolve.ts", // STT provider API key lookup
       "daemon/lifecycle.ts", // CES client injection into secure-keys at startup
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
+      "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
+      "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup
+      "meet/session-manager.ts", // Meet bot container provisioning (provider API key lookup for Deepgram/TTS)
+      "credential-health/credential-health-service.ts", // credential health check reads access tokens for liveness pings
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));