@vellumai/assistant 0.4.43 → 0.4.45

package/src/workspace/git-service.ts

@@ -54,7 +54,6 @@ function cleanGitEnv(workspaceDir: string): Record<string, string> {
 const WORKSPACE_GITIGNORE_RULES = [
   "data/db/",
   "data/qdrant/",
-  "data/ipc-blobs/",
   "logs/",
   "*.log",
   "*.sock",
@@ -67,7 +66,6 @@ const WORKSPACE_GITIGNORE_RULES = [
   "*.db-journal",
   "*.db-wal",
   "*.db-shm",
-  "vellum.sock",
   "vellum.pid",
   "session-token",
 ];

package/src/__tests__/account-registry.test.ts

@@ -1,258 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-const testDir = mkdtempSync(join(tmpdir(), "account-registry-test-"));
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  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"),
-  ensureDataDir: () => {},
-  getPlatformName: () => process.platform,
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../tools/registry.js", () => ({
-  registerTool: () => {},
-}));
-
-import {
-  createAccount,
-  getAccount,
-  listAccounts,
-  updateAccount,
-} from "../memory/account-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import type { ToolContext } from "../tools/types.js";
-
-// Initialize db once
-initializeDb();
-
-const _ctx: ToolContext = {
-  workingDir: "/tmp",
-  sessionId: "test-session",
-  conversationId: "test-conv",
-  trustClass: "guardian",
-};
-
-afterAll(() => {
-  resetDb();
-  mock.restore();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
-});
-
-describe("account_manage tool", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run(`DELETE FROM accounts`);
-  });
-
-  // -----------------------------------------------------------------------
-  // Create
-  // -----------------------------------------------------------------------
-  describe("create action", () => {
-    test("creates an account with auto-generated UUID", () => {
-      const record = createAccount({
-        service: "gmail",
-        username: "user@gmail.com",
-      });
-      expect(record.id).toBeTruthy();
-      // UUID v4 format: 8-4-4-4-12
-      expect(record.id).toMatch(
-        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
-      );
-    });
-
-    test("sets timestamps correctly", () => {
-      const before = Date.now();
-      const record = createAccount({ service: "github" });
-      const after = Date.now();
-
-      expect(record.createdAt).toBeGreaterThanOrEqual(before);
-      expect(record.createdAt).toBeLessThanOrEqual(after);
-      expect(record.updatedAt).toBe(record.createdAt);
-    });
-
-    test("stores all provided fields", () => {
-      const record = createAccount({
-        service: "github",
-        username: "octocat",
-        email: "octocat@github.com",
-        displayName: "Octo Cat",
-        status: "pending_verification",
-        credentialRef: "github",
-        metadata: { twoFactor: true },
-      });
-
-      expect(record.service).toBe("github");
-      expect(record.username).toBe("octocat");
-      expect(record.email).toBe("octocat@github.com");
-      expect(record.displayName).toBe("Octo Cat");
-      expect(record.status).toBe("pending_verification");
-      expect(record.credentialRef).toBe("github");
-      expect(record.metadataJson).toBe(JSON.stringify({ twoFactor: true }));
-    });
-
-    test("defaults status to active", () => {
-      const record = createAccount({ service: "gmail" });
-      expect(record.status).toBe("active");
-    });
-
-    test("returns the created record as JSON", () => {
-      const record = createAccount({ service: "slack", email: "me@slack.com" });
-      expect(record.service).toBe("slack");
-      expect(record.email).toBe("me@slack.com");
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // List
-  // -----------------------------------------------------------------------
-  describe("list action", () => {
-    test("lists all accounts", () => {
-      createAccount({ service: "gmail", username: "user1" });
-      createAccount({ service: "github", username: "user2" });
-
-      const accounts = listAccounts();
-      expect(accounts).toHaveLength(2);
-    });
-
-    test("filters by service", () => {
-      createAccount({ service: "gmail", username: "user1" });
-      createAccount({ service: "github", username: "user2" });
-      createAccount({ service: "gmail", username: "user3" });
-
-      const gmailAccounts = listAccounts({ service: "gmail" });
-      expect(gmailAccounts).toHaveLength(2);
-      expect(gmailAccounts.every((a) => a.service === "gmail")).toBe(true);
-    });
-
-    test("filters by status", () => {
-      createAccount({ service: "gmail", status: "active" });
-      createAccount({ service: "github", status: "suspended" });
-      createAccount({ service: "slack", status: "active" });
-
-      const activeAccounts = listAccounts({ status: "active" });
-      expect(activeAccounts).toHaveLength(2);
-      expect(activeAccounts.every((a) => a.status === "active")).toBe(true);
-    });
-
-    test("filters by both service and status", () => {
-      createAccount({ service: "gmail", status: "active" });
-      createAccount({ service: "gmail", status: "suspended" });
-      createAccount({ service: "github", status: "active" });
-
-      const result = listAccounts({ service: "gmail", status: "active" });
-      expect(result).toHaveLength(1);
-      expect(result[0].service).toBe("gmail");
-      expect(result[0].status).toBe("active");
-    });
-
-    test("returns empty array when no accounts exist", () => {
-      const accounts = listAccounts();
-      expect(accounts).toEqual([]);
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // Get
-  // -----------------------------------------------------------------------
-  describe("get action", () => {
-    test("retrieves an account by id", () => {
-      const created = createAccount({ service: "gmail", username: "user1" });
-      const fetched = getAccount(created.id);
-      expect(fetched).toBeDefined();
-      expect(fetched!.id).toBe(created.id);
-      expect(fetched!.service).toBe("gmail");
-      expect(fetched!.username).toBe("user1");
-    });
-
-    test("returns undefined for invalid id", () => {
-      const result = getAccount("nonexistent-id");
-      expect(result).toBeUndefined();
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // Update
-  // -----------------------------------------------------------------------
-  describe("update action", () => {
-    test("updates provided fields", () => {
-      const created = createAccount({ service: "gmail", username: "old-user" });
-      const updated = updateAccount(created.id, { username: "new-user" });
-
-      expect(updated).toBeDefined();
-      expect(updated!.username).toBe("new-user");
-      expect(updated!.service).toBe("gmail"); // unchanged
-    });
-
-    test("bumps updatedAt on update", async () => {
-      const created = createAccount({ service: "gmail" });
-      // Small delay to ensure timestamp difference
-      await new Promise((r) => setTimeout(r, 10));
-      const updated = updateAccount(created.id, { username: "updated" });
-
-      expect(updated!.updatedAt).toBeGreaterThan(created.updatedAt);
-    });
-
-    test("returns undefined for non-existent id", () => {
-      const result = updateAccount("nonexistent-id", { username: "test" });
-      expect(result).toBeUndefined();
-    });
-
-    test("updates metadata as JSON", () => {
-      const created = createAccount({ service: "github" });
-      const updated = updateAccount(created.id, {
-        metadata: { role: "admin" },
-      });
-
-      expect(updated!.metadataJson).toBe(JSON.stringify({ role: "admin" }));
-    });
-
-    test("updates status", () => {
-      const created = createAccount({ service: "gmail", status: "active" });
-      const updated = updateAccount(created.id, { status: "suspended" });
-      expect(updated!.status).toBe("suspended");
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // Tool execute() via account-registry.ts
-  // -----------------------------------------------------------------------
-  describe("account_manage tool execute", () => {
-    // We test through the account-store functions since the tool is a thin wrapper.
-    // Also test the tool's error handling for missing required fields.
-
-    test("create without service returns error message", async () => {
-      // Import the tool module to test its execute method
-      const _mod = await import("../tools/credentials/account-registry.js");
-      // The tool was registered via side-effect; we test the store functions directly
-      // and verify the tool's error-handling logic matches.
-      // Since we mocked registerTool, let's just verify the store logic.
-      // The tool delegates to createAccount, which requires service.
-    });
-
-    test("multiple accounts for same service have unique IDs", () => {
-      const a1 = createAccount({ service: "gmail", username: "user1" });
-      const a2 = createAccount({ service: "gmail", username: "user2" });
-      expect(a1.id).not.toBe(a2.id);
-    });
-  });
-});

package/src/__tests__/email-classifier.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  classifyEmails,
-  type EmailMetadata,
-} from "../messaging/email-classifier.js";
-
-describe("classifyEmails", () => {
-  test("returns empty classifications for empty input", async () => {
-    const result = await classifyEmails([]);
-    expect(result.classifications).toEqual([]);
-  });
-
-  test("accepts well-formed email metadata", () => {
-    const email: EmailMetadata = {
-      id: "msg-1",
-      from: "test@example.com",
-      subject: "Test Subject",
-      snippet: "This is a test email snippet",
-      labels: ["INBOX", "UNREAD"],
-    };
-    expect(email.id).toBe("msg-1");
-    expect(email.labels).toContain("INBOX");
-  });
-});

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

@@ -1,97 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, mock, test } from "bun:test";
-
-mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const toolsManifestPath = resolve(
-  __dirname,
-  "../config/bundled-skills/messaging/TOOLS.json",
-);
-const toolsManifest = JSON.parse(readFileSync(toolsManifestPath, "utf-8"));
-const slackToolsManifestPath = resolve(
-  __dirname,
-  "../config/bundled-skills/slack/TOOLS.json",
-);
-const slackToolsManifest = JSON.parse(
-  readFileSync(slackToolsManifestPath, "utf-8"),
-);
-
-describe("Messaging tool contract", () => {
-  const expectedGmailToolNames = [
-    "gmail_archive",
-    "gmail_batch_archive",
-    "gmail_archive_by_query",
-    "gmail_label",
-    "gmail_batch_label",
-    "gmail_trash",
-    "gmail_draft",
-    "gmail_unsubscribe",
-    "gmail_list_attachments",
-    "gmail_download_attachment",
-    "gmail_send_with_attachments",
-    "gmail_forward",
-    "gmail_summarize_thread",
-    "gmail_follow_up",
-    "gmail_triage",
-    "gmail_filters",
-    "gmail_vacation",
-    "gmail_sender_digest",
-    "gmail_outreach_scan",
-    "google_contacts",
-  ];
-
-  const expectedMessagingToolNames = [
-    "messaging_auth_test",
-    "messaging_list_conversations",
-    "messaging_read",
-    "messaging_search",
-    "messaging_send",
-    "messaging_reply",
-    "messaging_mark_read",
-    "messaging_analyze_activity",
-    "messaging_analyze_style",
-    "messaging_draft",
-  ];
-
-  const expectedSlackToolNames = ["slack_add_reaction", "slack_leave_channel"];
-
-  test("TOOLS.json manifest contains all expected gmail_* tool names", () => {
-    const manifestToolNames: string[] = toolsManifest.tools.map(
-      (t: { name: string }) => t.name,
-    );
-    for (const name of expectedGmailToolNames) {
-      expect(manifestToolNames).toContain(name);
-    }
-  });
-
-  test("TOOLS.json manifest contains all expected messaging_* tool names", () => {
-    const manifestToolNames: string[] = toolsManifest.tools.map(
-      (t: { name: string }) => t.name,
-    );
-    for (const name of expectedMessagingToolNames) {
-      expect(manifestToolNames).toContain(name);
-    }
-  });
-
-  test("TOOLS.json manifest contains all expected slack_* tool names", () => {
-    const slackToolNames: string[] = slackToolsManifest.tools.map(
-      (t: { name: string }) => t.name,
-    );
-    for (const name of expectedSlackToolNames) {
-      expect(slackToolNames).toContain(name);
-    }
-  });
-
-  test("TOOLS.json manifests contain at least the expected number of tools", () => {
-    const expectedMinimum =
-      expectedGmailToolNames.length +
-      expectedMessagingToolNames.length +
-      expectedSlackToolNames.length;
-    const totalTools =
-      toolsManifest.tools.length + slackToolsManifest.tools.length;
-    expect(totalTools).toBeGreaterThanOrEqual(expectedMinimum);
-  });
-});

package/src/__tests__/handle-user-message-secret-resume.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-
-const actualEnv = await import("../config/env.js");
-mock.module("../config/env.js", () => ({
-  ...actualEnv,
-  isHttpAuthDisabled: () => true,
-  isMonitoringEnabled: () => false,
-}));
-
-mock.module("../runtime/local-actor-identity.js", () => ({
-  resolveLocalIpcTrustContext: () => ({
-    trustClass: "guardian",
-    sourceChannel: "vellum",
-    guardianPrincipalId: "local-principal",
-  }),
-  resolveLocalIpcAuthContext: () => ({
-    scope: "ipc_v1",
-    actorPrincipalId: "local-principal",
-  }),
-}));
-
-mock.module("../config/loader.js", () => {
-  const config = {
-    daemon: { standaloneRecording: false },
-    secretDetection: {
-      enabled: true,
-      blockIngress: true,
-      customPatterns: [],
-      entropyThreshold: 3.5,
-    },
-  };
-  return {
-    getConfig: () => config,
-    loadConfig: () => config,
-    loadRawConfig: () => ({}),
-    saveConfig: () => {},
-    saveRawConfig: () => {},
-    invalidateConfigCache: () => {},
-    applyNestedDefaults: (c: unknown) => c,
-    getNestedValue: () => undefined,
-    setNestedValue: () => {},
-    syncConfigToLockfile: () => {},
-    API_KEY_PROVIDERS: [],
-  };
-});
-
-const noopLogger = {
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  debug: () => {},
-  trace: () => {},
-  fatal: () => {},
-  child: () => noopLogger,
-};
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realLogger = require("../util/logger.js");
-mock.module("../util/logger.js", () => ({
-  ...realLogger,
-  getLogger: () => noopLogger,
-  getCliLogger: () => noopLogger,
-  isDebug: () => false,
-  truncateForLog: (v: string) => v,
-  initLogger: () => {},
-  pruneOldLogFiles: () => 0,
-}));
-
-const { handleUserMessage } =
-  await import("../daemon/handlers/session-user-message.js");
-
-describe("handleUserMessage secret redirect continuation", () => {
-  test("resumes the request after secure save with redacted continuation text", async () => {
-    const sentMessages: Array<Record<string, unknown>> = [];
-    const enqueueCalls: Array<Record<string, unknown>> = [];
-    const processCalls: Array<Record<string, unknown>> = [];
-
-    const session = {
-      hasEscalationHandler: () => true,
-      redirectToSecurePrompt: (
-        _detectedTypes: string[],
-        options?: {
-          onStored?: (record: {
-            service: string;
-            field: string;
-            label: string;
-            delivery: "store" | "transient_send";
-          }) => void;
-        },
-      ) => {
-        options?.onStored?.({
-          service: "telegram",
-          field: "bot_token",
-          label: "Telegram Bot Token",
-          delivery: "store",
-        });
-      },
-      traceEmitter: { emit: () => {} },
-      enqueueMessage: (
-        content: string,
-        _attachments: unknown[],
-        _onEvent: unknown,
-        requestId: string,
-      ) => {
-        enqueueCalls.push({ content, requestId });
-        return { queued: false, requestId };
-      },
-      getQueueDepth: () => 0,
-      setTurnChannelContext: () => {},
-      setTurnInterfaceContext: () => {},
-      setAssistantId: () => {},
-      setChannelCapabilities: () => {},
-      setTrustContext: () => {},
-      setAuthContext: () => {},
-      setCommandIntent: () => {},
-      updateClient: () => {},
-      emitActivityState: () => {},
-      hasAnyPendingConfirmation: () => false,
-      hasPendingConfirmation: () => false,
-      processMessage: (
-        content: string,
-        _attachments: unknown[],
-        _onEvent: unknown,
-        requestId: string,
-      ) => {
-        processCalls.push({ content, requestId });
-        return Promise.resolve();
-      },
-    };
-
-    const ctx = {
-      sessions: new Map(),
-      cuSessions: new Map(),
-      getOrCreateSession: async () => session,
-      send: (message: Record<string, unknown>) => {
-        sentMessages.push(message);
-      },
-    };
-
-    await handleUserMessage(
-      {
-        type: "user_message",
-        sessionId: "sess-1",
-        content:
-          "Set up Telegram with my bot token 123456789:ABCDefGHIJklmnopQRSTuvwxyz012345678",
-        interface: "cli",
-      },
-      ctx as never,
-    );
-
-    expect(sentMessages[0]).toMatchObject({
-      type: "error",
-      category: "secret_blocked",
-    });
-    expect(
-      sentMessages.some((msg) => msg.type === "assistant_text_delta"),
-    ).toBe(true);
-    expect(sentMessages.some((msg) => msg.type === "message_complete")).toBe(
-      true,
-    );
-
-    expect(enqueueCalls).toHaveLength(1);
-    expect(processCalls).toHaveLength(1);
-    expect(enqueueCalls[0].content as string).toContain(
-      '<redacted type="Telegram Bot Token" />',
-    );
-    expect(enqueueCalls[0].content as string).toContain(
-      "credential telegram/bot_token",
-    );
-    expect(processCalls[0].content).toBe(enqueueCalls[0].content);
-  });
-});

package/src/__tests__/home-base-bootstrap.test.ts

@@ -1,84 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-const testRoot = mkdtempSync(join(tmpdir(), "home-base-bootstrap-test-"));
-const dataDir = join(testRoot, "data");
-const dbPath = join(testRoot, "assistant.db");
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => dataDir,
-  getDbPath: () => dbPath,
-  ensureDataDir: () => {
-    mkdirSync(dataDir, { recursive: true });
-  },
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testRoot, "test.sock"),
-  getPidPath: () => join(testRoot, "test.pid"),
-  getLogPath: () => join(testRoot, "test.log"),
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-import { getHomeBaseAppLink } from "../home-base/app-link-store.js";
-import {
-  bootstrapHomeBaseAppLink,
-  resolveHomeBaseAppId,
-} from "../home-base/bootstrap.js";
-import { deleteApp } from "../memory/app-store.js";
-import { initializeDb, resetDb } from "../memory/db.js";
-
-describe("home base bootstrap", () => {
-  beforeEach(() => {
-    resetDb();
-    rmSync(testRoot, { recursive: true, force: true });
-    mkdirSync(testRoot, { recursive: true });
-    initializeDb();
-  });
-
-  afterAll(() => {
-    resetDb();
-    rmSync(testRoot, { recursive: true, force: true });
-  });
-
-  test("creates a durable Home Base link on first bootstrap", () => {
-    const result = bootstrapHomeBaseAppLink();
-    expect(result).not.toBeNull();
-    const link = getHomeBaseAppLink();
-
-    expect(result!.linked).toBe(true);
-    expect(link).not.toBeNull();
-    expect(link?.appId).toBe(result!.appId);
-    expect(resolveHomeBaseAppId()).toBe(result!.appId);
-  });
-
-  test("reuses existing link on repeated bootstrap calls", () => {
-    const first = bootstrapHomeBaseAppLink();
-    const second = bootstrapHomeBaseAppLink();
-    expect(first).not.toBeNull();
-    expect(second).not.toBeNull();
-
-    expect(second!.appId).toBe(first!.appId);
-    expect(second!.created).toBe(false);
-  });
-
-  test("relinks when stored app id is stale", () => {
-    const first = bootstrapHomeBaseAppLink();
-    expect(first).not.toBeNull();
-    deleteApp(first!.appId);
-
-    const second = bootstrapHomeBaseAppLink();
-    expect(second).not.toBeNull();
-
-    expect(second!.appId).not.toBe(first!.appId);
-    expect(getHomeBaseAppLink()?.appId).toBe(second!.appId);
-  });
-});