@vellumai/assistant 0.5.4 → 0.5.5

package/Dockerfile

@@ -47,57 +47,48 @@ RUN apt-get update && apt-get install -y \
     g++ \
     git \
     sudo \
+    bubblewrap \
+    htop \
+    procps \
     && rm -rf /var/lib/apt/lists/*
 
+## Alias bwrap to bubblewrap
+RUN ln -sf /usr/bin/bwrap /usr/bin/bubblewrap
+
 # Copy bun binary from builder instead of re-installing
 COPY --from=builder /root/.bun/bin/bun /usr/local/bin/bun
 RUN ln -sf /usr/local/bin/bun /usr/local/bin/bunx
 
+# Install assistant CLI launcher backed by the bundled assistant package
+RUN printf '#!/usr/bin/env sh\nexec bun run /app/assistant/src/index.ts "$@"\n' > /usr/local/bin/assistant && \
+    chmod +x /usr/local/bin/assistant
+
 # Create non-root user that also has sudo access so it can like install stuff
 RUN groupadd --system --gid 1001 assistant && \
     useradd --system --uid 1001 --gid assistant --create-home --shell /bin/bash assistant && \
     echo "assistant ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
 
-# Set up data directory
-RUN mkdir -p /home/assistant/.vellum /data && \
-    chown -R assistant:assistant /home/assistant/.vellum /data && \
-    chmod a+rwx /data
+# Set up assistant home directory for local state (device.json, etc.)
+RUN mkdir -p /home/assistant/.vellum && \
+    chown -R assistant:assistant /home/assistant/.vellum
 
 # Update PATH for assistant user
-ENV PATH="/home/assistant/.bun/bin:/data/bin:${PATH}"
+ENV PATH="/home/assistant/.bun/bin:${PATH}"
 
-# Configure package managers to use /data
-ENV BUN_INSTALL="/data/.bun"
+# Configure package managers to use assistant home
+ENV BUN_INSTALL="/home/assistant/.bun"
 ENV PATH="${BUN_INSTALL}/bin:${PATH}"
-ENV PYTHONUSERBASE="/data/.python"
+ENV PYTHONUSERBASE="/home/assistant/.python"
 ENV PATH="${PYTHONUSERBASE}/bin:${PATH}"
 
-# Configure apt/dpkg to install future packages to /data
-RUN mkdir -p /data/dpkg/info /data/dpkg/updates /data/dpkg/triggers && \
-    mkdir -p /data/usr/bin /data/usr/lib /data/usr/share && \
-    chown -R assistant:assistant /data/dpkg /data/usr
-
-# Create dpkg configuration for using /data as install prefix
-RUN echo 'Dir::State "/data/dpkg";' > /etc/apt/apt.conf.d/99data-dir && \
-    echo 'Dir::State::status "/data/dpkg/status";' >> /etc/apt/apt.conf.d/99data-dir && \
-    echo 'Dir::Cache "/data/apt/cache";' >> /etc/apt/apt.conf.d/99data-dir && \
-    echo 'DPkg::Options {"--instdir=/data/usr";"--admindir=/data/dpkg";"--force-not-root";"--force-bad-path";};' >> /etc/apt/apt.conf.d/99data-dir && \
-    mkdir -p /data/apt/cache && \
-    touch /data/dpkg/status && \
-    chown -R assistant:assistant /data/apt /data/dpkg
-
-ENV PATH="/data/usr/bin:/data/usr/sbin:${PATH}"
-ENV LD_LIBRARY_PATH="/data/usr/lib:/data/usr/lib/x86_64-linux-gnu:/data/usr/lib/aarch64-linux-gnu"
-
 # Ensure the CES bootstrap socket volume is writable by the non-root CES user.
 RUN mkdir -p /run/ces-bootstrap && chmod 777 /run/ces-bootstrap
 
-USER root
+USER assistant
 
 EXPOSE 3001
 
 ENV RUNTIME_HTTP_PORT=3001
-ENV BASE_DATA_DIR=/data
 ENV IS_CONTAINERIZED=true
 
 # Copy from builder

package/node_modules/@vellumai/ces-contracts/src/index.ts

@@ -145,3 +145,4 @@ export * from "./handles.js";
 export * from "./grants.js";
 export * from "./rpc.js";
 export * from "./rendering.js";
+export * from "./trust-rules.js";

package/node_modules/@vellumai/ces-contracts/src/trust-rules.ts

@@ -0,0 +1,42 @@
+/**
+ * Trust rule types shared between the assistant daemon and the gateway.
+ *
+ * These are extracted from `assistant/src/permissions/types.ts` and
+ * `assistant/src/permissions/trust-store.ts` so that both packages can
+ * reference a single canonical definition.
+ */
+
+// ---------------------------------------------------------------------------
+// Trust decision
+// ---------------------------------------------------------------------------
+
+/** The possible decisions a trust rule can make. */
+export type TrustDecision = "allow" | "deny" | "ask";
+
+// ---------------------------------------------------------------------------
+// Trust rule
+// ---------------------------------------------------------------------------
+
+export interface TrustRule {
+  id: string;
+  tool: string;
+  pattern: string;
+  scope: string;
+  decision: TrustDecision;
+  priority: number;
+  createdAt: number;
+  executionTarget?: string;
+  allowHighRisk?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Trust file (on-disk shape)
+// ---------------------------------------------------------------------------
+
+/** Shape of the `trust.json` file persisted to disk. */
+export interface TrustFileData {
+  version: number;
+  rules: TrustRule[];
+  /** Set to true when the user explicitly accepts the starter approval bundle. */
+  starterBundleAccepted?: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

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

@@ -222,6 +222,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "messaging/providers/telegram-bot/adapter.ts", // Telegram bot token lookup for connectivity check
       "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
       "daemon/handlers/config-slack-channel.ts", // Slack channel config credential management
       "providers/managed-proxy/context.ts", // managed proxy API key lookup for provider initialization
       "mcp/mcp-oauth-provider.ts", // MCP OAuth token/client/discovery persistence
@@ -254,6 +255,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "config/bundled-skills/slack/tools/shared.ts", // Slack skill bot token lookup
       "daemon/conversation-process.ts", // masked provider key display
       "daemon/handlers/config-model.ts", // masked provider key display
+      "providers/speech-to-text/resolve.ts", // STT provider API key lookup
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));

package/src/__tests__/openai-whisper.test.ts

@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { OpenAIWhisperProvider } from "../providers/speech-to-text/openai-whisper.js";
+
+// ---------------------------------------------------------------------------
+// Mock fetch — capture outgoing FormData so we can assert filenames
+// ---------------------------------------------------------------------------
+
+const originalFetch = globalThis.fetch;
+
+let capturedFormData: FormData | null = null;
+
+function mockFetch(
+  _url: string | URL | Request,
+  init?: RequestInit,
+): Promise<Response> {
+  if (init?.body instanceof FormData) {
+    capturedFormData = init.body;
+  }
+  return Promise.resolve(
+    new Response(JSON.stringify({ text: "hello world" }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    }),
+  );
+}
+
+beforeEach(() => {
+  capturedFormData = null;
+  globalThis.fetch = mockFetch as typeof fetch;
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("OpenAIWhisperProvider", () => {
+  const provider = new OpenAIWhisperProvider("test-api-key");
+  const dummyAudio = Buffer.from("fake-audio-data");
+
+  describe("extensionFromMime (via transcribe filename)", () => {
+    test("plain MIME type resolves to correct extension", async () => {
+      await provider.transcribe(dummyAudio, "audio/ogg");
+      const file = capturedFormData?.get("file") as File;
+      expect(file.name).toBe("audio.ogg");
+    });
+
+    test("MIME type with parameters resolves to correct extension", async () => {
+      await provider.transcribe(dummyAudio, "audio/ogg; codecs=opus");
+      const file = capturedFormData?.get("file") as File;
+      expect(file.name).toBe("audio.ogg");
+    });
+
+    test("MIME type with extra whitespace around parameters", async () => {
+      await provider.transcribe(dummyAudio, "audio/mpeg ; bitrate=128");
+      const file = capturedFormData?.get("file") as File;
+      expect(file.name).toBe("audio.mp3");
+    });
+
+    test("unknown MIME type falls back to .audio", async () => {
+      await provider.transcribe(dummyAudio, "audio/unknown-format");
+      const file = capturedFormData?.get("file") as File;
+      expect(file.name).toBe("audio.audio");
+    });
+
+    test("unknown MIME type with parameters still falls back", async () => {
+      await provider.transcribe(dummyAudio, "audio/unknown; foo=bar");
+      const file = capturedFormData?.get("file") as File;
+      expect(file.name).toBe("audio.audio");
+    });
+
+    test.each([
+      ["audio/wav", "audio.wav"],
+      ["audio/x-wav", "audio.wav"],
+      ["audio/mpeg", "audio.mp3"],
+      ["audio/mp3", "audio.mp3"],
+      ["audio/ogg", "audio.ogg"],
+      ["audio/opus", "audio.opus"],
+      ["audio/webm", "audio.webm"],
+      ["audio/mp4", "audio.m4a"],
+      ["audio/x-m4a", "audio.m4a"],
+      ["audio/flac", "audio.flac"],
+    ])("%s → %s", async (mime, expectedFilename) => {
+      await provider.transcribe(dummyAudio, mime);
+      const file = capturedFormData?.get("file") as File;
+      expect(file.name).toBe(expectedFilename);
+    });
+  });
+});

package/src/__tests__/slack-messaging-token-resolution.test.ts

@@ -0,0 +1,319 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { OAuthConnection } from "../oauth/connection.js";
+
+// ── Mocks ───────────────────────────────────────────────────────────────────
+
+const getSecureKeyAsyncMock = mock(
+  async (_key: string): Promise<string | null> => null,
+);
+const isProviderConnectedMock = mock(
+  async (_service: string): Promise<boolean> => false,
+);
+const resolveOAuthConnectionMock = mock(
+  async (
+    _service: string,
+    _opts?: { account?: string },
+  ): Promise<OAuthConnection> =>
+    ({ accessToken: "oauth-token" }) as unknown as OAuthConnection,
+);
+const getConnectionByProviderMock = mock(
+  (_provider: string): { status: string } | undefined => undefined,
+);
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyAsync: getSecureKeyAsyncMock,
+}));
+
+mock.module("../oauth/oauth-store.js", () => ({
+  isProviderConnected: isProviderConnectedMock,
+  getConnectionByProvider: getConnectionByProviderMock,
+}));
+
+mock.module("../oauth/connection-resolver.js", () => ({
+  resolveOAuthConnection: resolveOAuthConnectionMock,
+}));
+
+// Telegram adapter imports modules that need more stubs
+mock.module("../config/env.js", () => ({
+  getGatewayInternalBaseUrl: () => "http://localhost:3000",
+}));
+mock.module("../memory/conversation-key-store.js", () => ({
+  getOrCreateConversation: async () => "conv-1",
+}));
+mock.module("../memory/external-conversation-store.js", () => ({
+  getExternalConversation: () => undefined,
+  setExternalConversation: () => {},
+}));
+mock.module("../runtime/auth/token-service.js", () => ({
+  mintDaemonDeliveryToken: async () => "delivery-token",
+}));
+
+// Slack client stubs (not exercised in these tests, but required on import)
+mock.module("../messaging/providers/slack/client.js", () => ({}));
+
+// Gmail client stubs
+mock.module("../messaging/providers/gmail/client.js", () => ({}));
+mock.module("../messaging/providers/gmail/people-client.js", () => ({}));
+
+// Telegram client stubs
+mock.module("../messaging/providers/telegram-bot/client.js", () => ({}));
+
+import {
+  getProviderConnection,
+  resolveProvider,
+} from "../config/bundled-skills/messaging/tools/shared.js";
+import { gmailMessagingProvider } from "../messaging/providers/gmail/adapter.js";
+import { slackProvider } from "../messaging/providers/slack/adapter.js";
+import { telegramBotMessagingProvider } from "../messaging/providers/telegram-bot/adapter.js";
+import {
+  getConnectedProviders,
+  registerMessagingProvider,
+} from "../messaging/registry.js";
+
+// Register providers for integration tests
+registerMessagingProvider(slackProvider);
+registerMessagingProvider(gmailMessagingProvider);
+registerMessagingProvider(telegramBotMessagingProvider);
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function resetAllMocks() {
+  getSecureKeyAsyncMock.mockReset();
+  getSecureKeyAsyncMock.mockImplementation(async () => null);
+  isProviderConnectedMock.mockReset();
+  isProviderConnectedMock.mockImplementation(async () => false);
+  resolveOAuthConnectionMock.mockReset();
+  resolveOAuthConnectionMock.mockImplementation(
+    async () => ({ accessToken: "oauth-token" }) as unknown as OAuthConnection,
+  );
+  getConnectionByProviderMock.mockReset();
+  getConnectionByProviderMock.mockImplementation(() => undefined);
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+describe("Slack messaging token resolution", () => {
+  beforeEach(resetAllMocks);
+
+  // ── slackProvider.isConnected() ─────────────────────────────────────────
+
+  describe("slackProvider.isConnected()", () => {
+    test("returns true when slack_channel bot token exists in credential store", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
+        key === "credential/slack_channel/bot_token" ? "xoxb-bot-token" : null,
+      );
+
+      expect(await slackProvider.isConnected!()).toBe(true);
+    });
+
+    test("returns true even if slack_channel connection row is missing (backfill failure resilience)", async () => {
+      // Bot token exists but no connection row — isConnected should still return true
+      getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
+        key === "credential/slack_channel/bot_token" ? "xoxb-bot-token" : null,
+      );
+      // No getConnectionByProvider call expected — Slack adapter checks token first
+
+      expect(await slackProvider.isConnected!()).toBe(true);
+    });
+
+    test("returns true when only integration:slack has active OAuth connection (backwards compat)", async () => {
+      // No bot token
+      getSecureKeyAsyncMock.mockImplementation(async () => null);
+      // But OAuth provider is connected
+      isProviderConnectedMock.mockImplementation(async (service: string) =>
+        service === "integration:slack" ? true : false,
+      );
+
+      expect(await slackProvider.isConnected!()).toBe(true);
+    });
+
+    test("returns false when neither credential path exists", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async () => null);
+      isProviderConnectedMock.mockImplementation(async () => false);
+
+      expect(await slackProvider.isConnected!()).toBe(false);
+    });
+  });
+
+  // ── slackProvider.resolveConnection() ───────────────────────────────────
+
+  describe("slackProvider.resolveConnection()", () => {
+    test("returns bot token string when Socket Mode credentials exist", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
+        key === "credential/slack_channel/bot_token"
+          ? "xoxb-socket-token"
+          : null,
+      );
+
+      const result = await slackProvider.resolveConnection!();
+      expect(result).toBe("xoxb-socket-token");
+    });
+
+    test("returns bot token string even without a slack_channel connection row (token-only resilience)", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
+        key === "credential/slack_channel/bot_token" ? "xoxb-token-only" : null,
+      );
+      // No connection row — resolveConnection should still return the token
+
+      const result = await slackProvider.resolveConnection!();
+      expect(result).toBe("xoxb-token-only");
+    });
+
+    test("returns OAuthConnection when only OAuth integration:slack credentials exist (backwards compat)", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async () => null);
+      const oauthConn = {
+        accessToken: "xoxp-oauth-token",
+      } as unknown as OAuthConnection;
+      resolveOAuthConnectionMock.mockImplementation(async () => oauthConn);
+
+      const result = await slackProvider.resolveConnection!();
+      expect(result).toBe(oauthConn);
+      expect(resolveOAuthConnectionMock).toHaveBeenCalledWith(
+        "integration:slack",
+        { account: undefined },
+      );
+    });
+
+    test("throws when no credentials exist at all (no Socket Mode, no OAuth)", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async () => null);
+      resolveOAuthConnectionMock.mockImplementation(async () => {
+        throw new Error("No OAuth connection found for integration:slack");
+      });
+
+      await expect(slackProvider.resolveConnection!()).rejects.toThrow(
+        "No OAuth connection found",
+      );
+    });
+  });
+
+  // ── getProviderConnection() integration ─────────────────────────────────
+
+  describe("getProviderConnection()", () => {
+    test("returns bot token string for Slack when Socket Mode credentials exist", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
+        key === "credential/slack_channel/bot_token" ? "xoxb-conn-token" : null,
+      );
+
+      const result = await getProviderConnection(slackProvider);
+      expect(result).toBe("xoxb-conn-token");
+    });
+
+    test("returns OAuthConnection for Slack when only OAuth credentials exist (backwards compat)", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async () => null);
+      const oauthConn = {
+        accessToken: "xoxp-oauth-token",
+      } as unknown as OAuthConnection;
+      resolveOAuthConnectionMock.mockImplementation(async () => oauthConn);
+
+      const result = await getProviderConnection(slackProvider);
+      expect(result).toBe(oauthConn);
+    });
+
+    test("throws when no Slack credentials exist", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async () => null);
+      resolveOAuthConnectionMock.mockImplementation(async () => {
+        throw new Error("No OAuth connection found");
+      });
+
+      await expect(getProviderConnection(slackProvider)).rejects.toThrow(
+        "No OAuth connection found",
+      );
+    });
+
+    test('Telegram still returns "" (no resolveConnection, uses isConnected path — regression check)', async () => {
+      // Telegram has isConnected but no resolveConnection.
+      // When isConnected returns true, getProviderConnection returns ""
+      getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
+        if (key === "credential/telegram/bot_token") return "bot-token";
+        if (key === "credential/telegram/webhook_secret") return "secret";
+        return null;
+      });
+      getConnectionByProviderMock.mockImplementation((provider: string) =>
+        provider === "telegram" ? { status: "active" } : undefined,
+      );
+
+      const result = await getProviderConnection(telegramBotMessagingProvider);
+      expect(result).toBe("");
+    });
+
+    test("Gmail still calls resolveOAuthConnection (no resolveConnection, no isConnected — regression check)", async () => {
+      // Gmail has neither resolveConnection nor isConnected.
+      // getProviderConnection falls through to resolveOAuthConnection.
+      const oauthConn = {
+        accessToken: "gmail-oauth-token",
+      } as unknown as OAuthConnection;
+      resolveOAuthConnectionMock.mockImplementation(async () => oauthConn);
+
+      const result = await getProviderConnection(gmailMessagingProvider);
+      expect(result).toBe(oauthConn);
+      expect(resolveOAuthConnectionMock).toHaveBeenCalledWith(
+        "integration:google",
+        { account: undefined },
+      );
+    });
+  });
+
+  // ── resolveProvider() multi-platform behavior ───────────────────────────
+
+  describe("resolveProvider() multi-platform behavior", () => {
+    test('throws "Multiple platforms connected" when both Gmail and Slack (Socket Mode) are connected and no platform is specified', async () => {
+      // Slack connected via Socket Mode
+      getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
+        key === "credential/slack_channel/bot_token" ? "xoxb-token" : null,
+      );
+      // Gmail connected via OAuth
+      isProviderConnectedMock.mockImplementation(async (service: string) =>
+        service === "integration:google" ? true : false,
+      );
+
+      await expect(resolveProvider()).rejects.toThrow(
+        "Multiple platforms connected",
+      );
+    });
+
+    test("auto-selects Slack when it is the only connected provider", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
+        key === "credential/slack_channel/bot_token" ? "xoxb-only" : null,
+      );
+      isProviderConnectedMock.mockImplementation(async () => false);
+
+      const provider = await resolveProvider();
+      expect(provider.id).toBe("slack");
+    });
+
+    test("auto-selects Gmail when it is the only connected provider (no Slack credentials)", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async () => null);
+      isProviderConnectedMock.mockImplementation(async (service: string) =>
+        service === "integration:google" ? true : false,
+      );
+
+      const provider = await resolveProvider();
+      expect(provider.id).toBe("gmail");
+    });
+  });
+
+  // ── getConnectedProviders() ─────────────────────────────────────────────
+
+  describe("getConnectedProviders()", () => {
+    test("includes Slack when connected via Socket Mode (slack_channel)", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
+        key === "credential/slack_channel/bot_token" ? "xoxb-token" : null,
+      );
+      isProviderConnectedMock.mockImplementation(async () => false);
+
+      const connected = await getConnectedProviders();
+      const ids = connected.map((p) => p.id);
+      expect(ids).toContain("slack");
+    });
+
+    test("excludes Slack when no bot token exists", async () => {
+      getSecureKeyAsyncMock.mockImplementation(async () => null);
+      isProviderConnectedMock.mockImplementation(async () => false);
+
+      const connected = await getConnectedProviders();
+      const ids = connected.map((p) => p.id);
+      expect(ids).not.toContain("slack");
+    });
+  });
+});