@vellumai/assistant 0.4.43 → 0.4.45

package/src/__tests__/host-shell-tool.test.ts

@@ -69,7 +69,7 @@ mock.module("../tools/terminal/sandbox.js", () => ({
 }));
 
 import { hostShellTool } from "../tools/host-terminal/host-shell.js";
-import type { ToolContext } from "../tools/types.js";
+import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
 
 const testDirs: string[] = [];
 
@@ -687,3 +687,149 @@ describe("host_bash — spawn error handling", () => {
     expect(result.content).toContain("<command_completed />");
   });
 });
+
+// ---------------------------------------------------------------------------
+// HostBashProxy delegation
+// ---------------------------------------------------------------------------
+
+describe("host_bash — proxy delegation", () => {
+  function makeMockProxy(result: ToolExecutionResult) {
+    const calls: Array<{
+      input: { command: string; working_dir?: string; timeout_seconds?: number };
+      sessionId: string;
+    }> = [];
+
+    return {
+      proxy: {
+        isAvailable: () => true,
+        request: async (
+          input: { command: string; working_dir?: string; timeout_seconds?: number },
+          sessionId: string,
+          _signal?: AbortSignal,
+        ) => {
+          calls.push({ input, sessionId });
+          return result;
+        },
+        updateSender: () => {},
+        dispose: () => {},
+        resolve: () => {},
+        hasPendingRequest: () => false,
+      },
+      calls,
+    };
+  }
+
+  test("delegates to proxy when hostBashProxy is available", async () => {
+    const proxyResult: ToolExecutionResult = {
+      content: "proxied output",
+      isError: false,
+    };
+    const { proxy, calls } = makeMockProxy(proxyResult);
+
+    const ctx: ToolContext = {
+      ...makeContext(),
+      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
+    };
+
+    spawnCalls.length = 0;
+    const result = await hostShellTool.execute(
+      { command: "echo hello", working_dir: "/tmp", timeout_seconds: 30 },
+      ctx,
+    );
+
+    expect(result).toBe(proxyResult);
+    expect(calls.length).toBe(1);
+    expect(calls[0].input.command).toBe("echo hello");
+    expect(calls[0].input.working_dir).toBe("/tmp");
+    expect(calls[0].input.timeout_seconds).toBe(30);
+    expect(calls[0].sessionId).toBe("test-session");
+    // Should NOT have spawned a local process
+    expect(spawnCalls.length).toBe(0);
+  });
+
+  test("still validates input before proxying (null bytes in command)", async () => {
+    const proxyResult: ToolExecutionResult = { content: "proxied", isError: false };
+    const { proxy, calls } = makeMockProxy(proxyResult);
+
+    const ctx: ToolContext = {
+      ...makeContext(),
+      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
+    };
+
+    const result = await hostShellTool.execute(
+      { command: "echo \0evil" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("null bytes");
+    // Proxy should NOT have been called
+    expect(calls.length).toBe(0);
+  });
+
+  test("still validates input before proxying (relative working_dir)", async () => {
+    const proxyResult: ToolExecutionResult = { content: "proxied", isError: false };
+    const { proxy, calls } = makeMockProxy(proxyResult);
+
+    const ctx: ToolContext = {
+      ...makeContext(),
+      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
+    };
+
+    const result = await hostShellTool.execute(
+      { command: "echo test", working_dir: "relative/path" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("working_dir must be absolute");
+    expect(calls.length).toBe(0);
+  });
+
+  test("falls back to local execution when proxy is not available", async () => {
+    const unavailableProxy = {
+      isAvailable: () => false,
+      request: async () => {
+        throw new Error("should not be called");
+      },
+      updateSender: () => {},
+      dispose: () => {},
+      resolve: () => {},
+      hasPendingRequest: () => false,
+    };
+
+    const dir = mkdtempSync(join(tmpdir(), "host-shell-proxy-fallback-"));
+    testDirs.push(dir);
+
+    const ctx: ToolContext = {
+      ...makeContext(),
+      hostBashProxy: unavailableProxy as unknown as ToolContext["hostBashProxy"],
+    };
+
+    spawnCalls.length = 0;
+    const result = await hostShellTool.execute(
+      { command: "echo local-fallback", working_dir: dir },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content.trim()).toBe("local-fallback");
+    // Should have spawned locally
+    expect(spawnCalls.length).toBe(1);
+  });
+
+  test("falls back to local execution when no proxy is set", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "host-shell-no-proxy-"));
+    testDirs.push(dir);
+
+    spawnCalls.length = 0;
+    const result = await hostShellTool.execute(
+      { command: "echo no-proxy", working_dir: dir },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content.trim()).toBe("no-proxy");
+    expect(spawnCalls.length).toBe(1);
+  });
+});

package/src/__tests__/http-user-message-parity.test.ts

@@ -0,0 +1,361 @@
+/**
+ * Tests for HTTP POST /v1/messages behavior after the legacy handleUserMessage
+ * legacy entry point was retired.
+ *
+ * Secret ingress blocking has been ported to the HTTP path. Recording intent
+ * interception has been deliberately retired — the HTTP path has dedicated
+ * /v1/recording/* endpoints and the model handles recording-related messages
+ * through the agent loop.
+ *
+ * Approval reply interception has parity and is covered by
+ * conversation-routes-guardian-reply.test.ts and send-endpoint-busy.test.ts.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ────────────────────────────────────────────────────────────────────────────
+// Module mocks — must be set up before any imports that pull in the mocked
+// modules. These are shared across all describe blocks in this file.
+// ────────────────────────────────────────────────────────────────────────────
+
+mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
+
+const routeGuardianReplyMock = mock(async () => ({
+  consumed: false,
+  decisionApplied: false,
+  type: "not_consumed" as const,
+})) as any;
+
+const listPendingByDestinationMock = mock(
+  (_conversationId: string, _sourceChannel?: string) =>
+    [] as Array<{ id: string; kind?: string }>,
+);
+const listCanonicalMock = mock(
+  (_filters?: Record<string, unknown>) => [] as Array<{ id: string }>,
+);
+const addMessageMock = mock(
+  async (
+    _conversationId: string,
+    role: string,
+    _content?: string,
+    _metadata?: Record<string, unknown>,
+  ) => ({
+    id: role === "user" ? "persisted-user-id" : "persisted-assistant-id",
+  }),
+);
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../memory/conversation-key-store.js", () => ({
+  getOrCreateConversation: () => ({ conversationId: "conv-parity-test" }),
+  getConversationByKey: () => null,
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentsByIds: () => [],
+}));
+
+mock.module("../runtime/guardian-reply-router.js", () => ({
+  routeGuardianReply: routeGuardianReplyMock,
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  createCanonicalGuardianRequest: () => ({
+    id: "canonical-id",
+    requestCode: "ABC123",
+  }),
+  generateCanonicalRequestCode: () => "ABC123",
+  listPendingCanonicalGuardianRequestsByDestinationConversation: (
+    conversationId: string,
+    sourceChannel?: string,
+  ) => listPendingByDestinationMock(conversationId, sourceChannel),
+  listCanonicalGuardianRequests: (filters?: Record<string, unknown>) =>
+    listCanonicalMock(filters),
+  listPendingRequestsByConversationScope: (conversationId: string) => {
+    const byDest = listPendingByDestinationMock(conversationId);
+    const bySrc = listCanonicalMock({ status: "pending", conversationId });
+    const seen = new Set<string>();
+    const result: Array<{ id: string; kind?: string }> = [];
+    for (const r of [...bySrc, ...byDest]) {
+      if (!seen.has(r.id)) {
+        seen.add(r.id);
+        result.push(r);
+      }
+    }
+    return result;
+  },
+}));
+
+mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
+  bridgeConfirmationRequestToGuardian: async () => undefined,
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: (
+    conversationId: string,
+    role: string,
+    content: string,
+    metadata?: Record<string, unknown>,
+  ) => addMessageMock(conversationId, role, content, metadata),
+}));
+
+mock.module("../runtime/local-actor-identity.js", () => ({
+  resolveLocalTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  }),
+}));
+
+mock.module("../runtime/trust-context-resolver.js", () => ({
+  resolveTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  }),
+  withSourceChannel: (sourceChannel: unknown, ctx: unknown) => ({
+    ...(ctx as Record<string, unknown>),
+    sourceChannel,
+  }),
+}));
+
+// Mock config to enable secret detection + ingress blocking
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    secretDetection: {
+      enabled: true,
+      blockIngress: true,
+      customPatterns: [],
+      entropyThreshold: 3.5,
+    },
+    model: "test",
+    provider: "test",
+    contextWindow: { maxInputTokens: 200000 },
+  }),
+}));
+
+import type { AuthContext } from "../runtime/auth/types.js";
+import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
+
+const testAuthContext: AuthContext = {
+  subject: "actor:self:test-actor",
+  principalType: "actor",
+  assistantId: "self",
+  actorPrincipalId: "test-actor",
+  scopeProfile: "actor_client_v1",
+  scopes: new Set([
+    "chat.read",
+    "chat.write",
+    "approval.read",
+    "approval.write",
+    "settings.read",
+    "settings.write",
+    "attachments.read",
+    "attachments.write",
+    "calls.read",
+    "calls.write",
+    "feature_flags.read",
+    "feature_flags.write",
+  ]),
+  policyEpoch: 1,
+};
+
+// ── Helper: create a minimal mock session ──────────────────────────────────
+function makeSession(overrides: Record<string, unknown> = {}) {
+  return {
+    setTrustContext: () => {},
+    updateClient: () => {},
+    setHostBashProxy: () => {},
+    setHostFileProxy: () => {},
+    emitConfirmationStateChanged: () => {},
+    emitActivityState: () => {},
+    setTurnChannelContext: () => {},
+    setTurnInterfaceContext: () => {},
+    ensureActorScopedHistory: async () => {},
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
+    isProcessing: () => false,
+    hasAnyPendingConfirmation: () => false,
+    denyAllPendingConfirmations: () => {},
+    enqueueMessage: () => ({ queued: true, requestId: "queued-id" }),
+    persistUserMessage: mock(async () => "persisted-user-id"),
+    runAgentLoop: mock(async () => undefined),
+    getMessages: () => [] as unknown[],
+    assistantId: "self",
+    trustContext: undefined,
+    hasPendingConfirmation: () => false,
+    ...overrides,
+  } as unknown as import("../daemon/session.js").Session;
+}
+
+// ── Helper: create an HTTP request to POST /v1/messages ────────────────────
+function makeRequest(content: string, extra: Record<string, unknown> = {}) {
+  return new Request("http://localhost/v1/messages", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      conversationKey: "parity-test-key",
+      content,
+      sourceChannel: "vellum",
+      interface: "macos",
+      ...extra,
+    }),
+  });
+}
+
+// ── Helper: send a message through handleSendMessage ───────────────────────
+async function sendMessage(
+  content: string,
+  session: import("../daemon/session.js").Session,
+  extra: Record<string, unknown> = {},
+) {
+  return handleSendMessage(
+    makeRequest(content, extra),
+    {
+      sendMessageDeps: {
+        getOrCreateSession: async () => session,
+        assistantEventHub: { publish: async () => {} } as any,
+        resolveAttachments: () => [],
+      },
+    },
+    testAuthContext,
+  );
+}
+
+// ============================================================================
+// SECRET INGRESS BLOCKING — now ported to HTTP path
+// ============================================================================
+describe("HTTP POST /v1/messages blocks secret ingress", () => {
+  beforeEach(() => {
+    routeGuardianReplyMock.mockClear();
+    listPendingByDestinationMock.mockClear();
+    listCanonicalMock.mockClear();
+    addMessageMock.mockClear();
+  });
+
+  test("handleSendMessage rejects messages containing Telegram bot token patterns", async () => {
+    const secretContent =
+      "Set up Telegram with my bot token 123456789:ABCDefGHIJklmnopQRSTuvwxyz012345678";
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const session = makeSession({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage(secretContent, session);
+
+    expect(res.status).toBe(422);
+    const body = (await res.json()) as {
+      accepted: boolean;
+      error: string;
+      message: string;
+      detectedTypes: string[];
+    };
+    expect(body.accepted).toBe(false);
+    expect(body.error).toBe("secret_blocked");
+    expect(body.detectedTypes.length).toBeGreaterThan(0);
+
+    // The message should NOT reach the agent loop
+    expect(persistUserMessage).toHaveBeenCalledTimes(0);
+    expect(runAgentLoop).toHaveBeenCalledTimes(0);
+  });
+
+  test("handleSendMessage rejects messages containing AWS credentials", async () => {
+    const secretContent =
+      "Here is my AWS key AKIAQRSTUVWXYZ123456 and secret wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY";
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const session = makeSession({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage(secretContent, session);
+
+    expect(res.status).toBe(422);
+    const body = (await res.json()) as {
+      accepted: boolean;
+      error: string;
+    };
+    expect(body.accepted).toBe(false);
+    expect(body.error).toBe("secret_blocked");
+
+    // The message should NOT reach the agent loop
+    expect(persistUserMessage).toHaveBeenCalledTimes(0);
+    expect(runAgentLoop).toHaveBeenCalledTimes(0);
+  });
+
+  test("handleSendMessage rejects messages containing Stripe live API keys", async () => {
+    const secretContent = "My Stripe key is sk_live_4eC39HqLyjWDarjtT1zdp7dc";
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const session = makeSession({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage(secretContent, session);
+
+    expect(res.status).toBe(422);
+    const body = (await res.json()) as {
+      accepted: boolean;
+      error: string;
+    };
+    expect(body.accepted).toBe(false);
+    expect(body.error).toBe("secret_blocked");
+
+    // The message should NOT reach the agent loop
+    expect(persistUserMessage).toHaveBeenCalledTimes(0);
+    expect(runAgentLoop).toHaveBeenCalledTimes(0);
+  });
+
+  test("handleSendMessage allows normal messages without secrets", async () => {
+    const normalContent = "What is the weather today?";
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const session = makeSession({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage(normalContent, session);
+
+    expect(res.status).toBe(202);
+    const body = (await res.json()) as { accepted: boolean };
+    expect(body.accepted).toBe(true);
+
+    // Normal messages proceed to the agent loop
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ============================================================================
+// RECORDING INTENT — deliberately NOT intercepted on HTTP path
+// ============================================================================
+describe("HTTP POST /v1/messages does not intercept recording intents (by design)", () => {
+  beforeEach(() => {
+    routeGuardianReplyMock.mockClear();
+    listPendingByDestinationMock.mockClear();
+    listCanonicalMock.mockClear();
+    addMessageMock.mockClear();
+  });
+
+  test("recording commands pass through to the agent loop as regular messages", async () => {
+    // The HTTP path deliberately does not intercept recording commands.
+    // Dedicated /v1/recording/* endpoints handle recording lifecycle.
+    // Text-based recording intent interception was retired with the
+    // legacy handleUserMessage entry point.
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const session = makeSession({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage("start recording", session);
+
+    expect(res.status).toBe(202);
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+  });
+
+  test("stop recording commands pass through to the agent loop", async () => {
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const session = makeSession({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage("stop recording", session);
+
+    expect(res.status).toBe(202);
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -22,7 +22,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/integration-status.test.ts

@@ -29,7 +29,6 @@ describe("integration-status", () => {
       const summary = getIntegrationSummary();
       expect(summary).toEqual([
         { name: "Gmail", category: "email", connected: false },
-        { name: "Twitter", category: "social", connected: false },
         { name: "Slack", category: "messaging", connected: false },
         { name: "Twilio", category: "telephony", connected: false },
         { name: "Telegram", category: "messaging", connected: false },
@@ -38,7 +37,6 @@ describe("integration-status", () => {
 
     test("returns all connected when all keys are set", () => {
       secureKeyValues.set("credential:integration:gmail:access_token", "tok");
-      secureKeyValues.set("credential:integration:twitter:access_token", "tok");
       secureKeyValues.set("credential:integration:slack:access_token", "tok");
       mockTwilioAccountSid = "sid";
       secureKeyValues.set("credential:twilio:auth_token", "auth");
@@ -71,7 +69,6 @@ describe("integration-status", () => {
       ]);
       expect(disconnected.map((s: { name: string }) => s.name)).toEqual([
         "Gmail",
-        "Twitter",
         "Slack",
       ]);
     });
@@ -104,20 +101,19 @@ describe("integration-status", () => {
 
       const result = formatIntegrationSummary();
       expect(result).toBe(
-        "Gmail \u2717 | Twitter \u2717 | Slack \u2717 | Twilio \u2713 | Telegram \u2713",
+        "Gmail \u2717 | Slack \u2717 | Twilio \u2713 | Telegram \u2713",
       );
     });
 
     test("all disconnected", () => {
       const result = formatIntegrationSummary();
       expect(result).toBe(
-        "Gmail \u2717 | Twitter \u2717 | Slack \u2717 | Twilio \u2717 | Telegram \u2717",
+        "Gmail \u2717 | Slack \u2717 | Twilio \u2717 | Telegram \u2717",
       );
     });
 
     test("all connected", () => {
       secureKeyValues.set("credential:integration:gmail:access_token", "tok");
-      secureKeyValues.set("credential:integration:twitter:access_token", "tok");
       secureKeyValues.set("credential:integration:slack:access_token", "tok");
       mockTwilioAccountSid = "sid";
       secureKeyValues.set("credential:twilio:auth_token", "auth");
@@ -126,7 +122,7 @@ describe("integration-status", () => {
 
       const result = formatIntegrationSummary();
       expect(result).toBe(
-        "Gmail \u2713 | Twitter \u2713 | Slack \u2713 | Twilio \u2713 | Telegram \u2713",
+        "Gmail \u2713 | Slack \u2713 | Twilio \u2713 | Telegram \u2713",
       );
     });
   });
@@ -134,7 +130,6 @@ describe("integration-status", () => {
   describe("hasCapability", () => {
     test("returns false when no integrations in category are connected", () => {
       expect(hasCapability("email")).toBe(false);
-      expect(hasCapability("social")).toBe(false);
       expect(hasCapability("messaging")).toBe(false);
     });