@vellumai/assistant 0.5.15 → 0.5.16

package/src/__tests__/log-export-workspace.test.ts

@@ -15,7 +15,6 @@ import {
   mkdtempSync,
   readdirSync,
   readFileSync,
-  realpathSync,
   rmSync,
   symlinkSync,
   writeFileSync,
@@ -25,29 +24,9 @@ import { join } from "node:path";
 import { afterAll, describe, expect, mock, test } from "bun:test";
 
 // Set up temp directories before mocking
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "log-export-workspace-test-")),
-);
-const testWorkspaceDir = join(testDir, "workspace");
-const testDbDir = join(testDir, "db");
-const testDbPath = join(testDbDir, "assistant.db");
-
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
+const testWorkspaceDir = testDir;
 mkdirSync(testWorkspaceDir, { recursive: true });
-mkdirSync(testDbDir, { recursive: true });
-
-mock.module("../util/platform.js", () => ({
-  getProtectedDir: () => join(testDir, "protected"),
-  getDataDir: () => testDir,
-  getWorkspaceDir: () => testWorkspaceDir,
-  getWorkspaceConfigPath: () => join(testWorkspaceDir, "config.json"),
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => testDbPath,
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -68,11 +47,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -1,8 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let TEST_DIR = "";
 
@@ -38,22 +36,6 @@ const mockConfig = {
   },
 };
 
-mock.module("../util/platform.js", () => ({
-  getProtectedDir: () => join(TEST_DIR, "protected"),
-  getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
-  getDataDir: () => TEST_DIR,
-  ensureDataDir: () => {},
-  getPidPath: () => join(TEST_DIR, "vellum.pid"),
-  getDbPath: () => join(TEST_DIR, "data", "assistant.db"),
-  getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
-  getHistoryPath: () => join(TEST_DIR, "history"),
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPlatformName: () => process.platform,
-  getClipboardCommand: () => null,
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -81,7 +63,6 @@ mock.module("../tools/terminal/sandbox.js", () => ({
 }));
 
 import { loadSkillCatalog } from "../config/skills.js";
-import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { executeDeleteManagedSkill } from "../tools/skills/delete-managed.js";
 import { SkillLoadTool } from "../tools/skills/load.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
@@ -96,14 +77,10 @@ function makeContext(): ToolContext {
 }
 
 beforeEach(() => {
-  TEST_DIR = mkdtempSync(join(tmpdir(), "lifecycle-test-"));
+  TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
   mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
 });
 
-afterEach(() => {
-  rmSync(TEST_DIR, { recursive: true, force: true });
-});
-
 describe("managed skill lifecycle: scaffold → catalog → prompt → delete", () => {
   test("full lifecycle: create skill, verify in catalog and prompt, then delete", async () => {
     // Step 1: Scaffold a managed skill
@@ -137,14 +114,7 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     expect(found!.name).toBe("Lifecycle Test");
     expect(found!.description).toBe("Integration test skill.");
 
-    // Step 4: Verify skill appears in system prompt (markdown bullet: **id**: description)
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain("**lifecycle-test**");
-    expect(prompt).toContain("Integration test skill");
-    // Dynamic Skill Authoring section moved to tool descriptions; prompt should not contain it
-    expect(prompt).not.toContain("## Dynamic Skill Authoring Workflow");
-
-    // Step 5: Delete the skill
+    // Step 4: Delete the skill
     const deleteResult = await executeDeleteManagedSkill(
       {
         skill_id: "lifecycle-test",
@@ -156,14 +126,14 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     const deleteData = JSON.parse(deleteResult.content as string);
     expect(deleteData.deleted).toBe(true);
 
-    // Step 6: Verify skill is gone from filesystem
+    // Step 5: Verify skill is gone from filesystem
     expect(existsSync(skillMdPath)).toBe(false);
 
-    // Step 7: Verify skill no longer in catalog
+    // Step 6: Verify skill no longer in catalog
     const catalogAfter = loadSkillCatalog();
     expect(catalogAfter.find((s) => s.id === "lifecycle-test")).toBeUndefined();
 
-    // Step 8: Verify SKILLS.md index no longer has the entry
+    // Step 7: Verify SKILLS.md index no longer has the entry
     const indexPath = join(TEST_DIR, "skills", "SKILLS.md");
     if (existsSync(indexPath)) {
       const indexContent = readFileSync(indexPath, "utf-8");

package/src/__tests__/managed-store.test.ts

@@ -7,8 +7,6 @@ import {
   rmSync,
   writeFileSync,
 } from "node:fs";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   afterEach,
@@ -22,12 +20,7 @@ import {
 
 import { parse as parseYaml } from "yaml";
 
-let TEST_DIR = "";
-
-mock.module("../util/platform.js", () => ({
-  getProtectedDir: () => join(TEST_DIR, "protected"),
-  getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
-}));
+const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -48,12 +41,11 @@ import {
 } from "../skills/managed-store.js";
 
 beforeEach(() => {
-  TEST_DIR = mkdtempSync(join(tmpdir(), "managed-store-test-"));
   mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
 });
 
 afterEach(() => {
-  rmSync(TEST_DIR, { recursive: true, force: true });
+  rmSync(join(TEST_DIR, "skills"), { recursive: true, force: true });
 });
 
 describe("validateManagedSkillId", () => {

package/src/__tests__/messaging-send-tool.test.ts

@@ -64,16 +64,16 @@ const getConversationMock = mock(
 );
 
 const syncMessageToDiskMock = mock(
-  (
-    _conversationId: string,
-    _messageId: string,
-    _createdAtMs: number,
-  ) => {},
+  (_conversationId: string, _messageId: string, _createdAtMs: number) => {},
 );
 
 const getBindingByChannelChatMock = mock(
   (_sourceChannel: string, _externalChatId: string) =>
-    null as { conversationId: string; sourceChannel: string; externalChatId: string } | null,
+    null as {
+      conversationId: string;
+      sourceChannel: string;
+      externalChatId: string;
+    } | null,
 );
 
 mock.module("../memory/conversation-crud.js", () => ({

package/src/__tests__/migration-cross-version-compatibility.test.ts

@@ -20,19 +20,15 @@
 import { createHash } from "node:crypto";
 import {
   mkdirSync,
-  mkdtempSync,
   readdirSync,
   readFileSync,
-  realpathSync,
   rmSync,
   unlinkSync,
   writeFileSync,
 } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { gzipSync } from "node:zlib";
 import {
-  afterAll,
   afterEach,
   beforeAll,
   beforeEach,
@@ -50,27 +46,11 @@ function toArrayBuffer(data: Uint8Array): ArrayBuffer {
   ) as ArrayBuffer;
 }
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "migration-cross-version-test-")),
-);
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
 const testDbDir = join(testDir, "data", "db");
 const testDbPath = join(testDbDir, "assistant.db");
 const testConfigPath = join(testDir, "config.json");
 
-mock.module("../util/platform.js", () => ({
-  getProtectedDir: () => join(testDir, "protected"),
-  getDataDir: () => join(testDir, "data"),
-  getWorkspaceDir: () => testDir,
-  getWorkspaceConfigPath: () => testConfigPath,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => testDbPath,
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -137,14 +117,6 @@ beforeAll(() => {
   writeFileSync(testConfigPath, JSON.stringify(EXISTING_CONFIG, null, 2));
 });
 
-afterAll(() => {
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
-});
-
 // Restore test files before each test
 beforeEach(() => {
   mkdirSync(testDbDir, { recursive: true });

package/src/__tests__/migration-export-http.test.ts

@@ -12,39 +12,16 @@
  * - Integration: existing routes are unaffected by the new endpoint
  */
 import { createHash } from "node:crypto";
-import {
-  mkdirSync,
-  mkdtempSync,
-  realpathSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gunzipSync } from "node:zlib";
-import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
+import { beforeAll, describe, expect, mock, test } from "bun:test";
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "migration-export-http-test-")),
-);
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
 const testDbDir = join(testDir, "data", "db");
 const testDbPath = join(testDbDir, "assistant.db");
 const testConfigPath = join(testDir, "config.json");
 
-mock.module("../util/platform.js", () => ({
-  getProtectedDir: () => join(testDir, "protected"),
-  getDataDir: () => join(testDir, "data"),
-  getWorkspaceDir: () => testDir,
-  getWorkspaceConfigPath: () => testConfigPath,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => testDbPath,
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -101,14 +78,6 @@ beforeAll(() => {
   writeFileSync(testConfigPath, JSON.stringify(TEST_CONFIG, null, 2));
 });
 
-afterAll(() => {
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
-});
-
 // ---------------------------------------------------------------------------
 // Tar parsing helper (mirrors vbundle-validator's internal parser)
 // ---------------------------------------------------------------------------

package/src/__tests__/migration-import-commit-http.test.ts

@@ -15,19 +15,15 @@ import { createHash } from "node:crypto";
 import {
   existsSync,
   mkdirSync,
-  mkdtempSync,
   readdirSync,
   readFileSync,
-  realpathSync,
   rmSync,
   unlinkSync,
   writeFileSync,
 } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { gzipSync } from "node:zlib";
 import {
-  afterAll,
   afterEach,
   beforeAll,
   beforeEach,
@@ -45,27 +41,11 @@ function toArrayBuffer(data: Uint8Array): ArrayBuffer {
   ) as ArrayBuffer;
 }
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "migration-import-commit-http-test-")),
-);
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
 const testDbDir = join(testDir, "data", "db");
 const testDbPath = join(testDbDir, "assistant.db");
 const testConfigPath = join(testDir, "config.json");
 
-mock.module("../util/platform.js", () => ({
-  getProtectedDir: () => join(testDir, "protected"),
-  getDataDir: () => join(testDir, "data"),
-  getWorkspaceDir: () => testDir,
-  getWorkspaceConfigPath: () => testConfigPath,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => testDbPath,
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -119,14 +99,6 @@ beforeAll(() => {
   writeFileSync(testConfigPath, JSON.stringify(EXISTING_CONFIG, null, 2));
 });
 
-afterAll(() => {
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
-});
-
 // Restore test files before each test so mutations from previous tests
 // do not leak across test cases.
 beforeEach(() => {

package/src/__tests__/migration-import-preflight-http.test.ts

@@ -11,17 +11,10 @@
  * - Integration: existing routes are unaffected by the new endpoint
  */
 import { createHash } from "node:crypto";
-import {
-  mkdirSync,
-  mkdtempSync,
-  realpathSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gzipSync } from "node:zlib";
-import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
+import { beforeAll, describe, expect, mock, test } from "bun:test";
 
 /** Convert a Uint8Array to an ArrayBuffer for BodyInit compatibility. */
 function toArrayBuffer(data: Uint8Array): ArrayBuffer {
@@ -31,27 +24,11 @@ function toArrayBuffer(data: Uint8Array): ArrayBuffer {
   ) as ArrayBuffer;
 }
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "migration-import-preflight-http-test-")),
-);
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
 const testDbDir = join(testDir, "data", "db");
 const testDbPath = join(testDbDir, "assistant.db");
 const testConfigPath = join(testDir, "config.json");
 
-mock.module("../util/platform.js", () => ({
-  getProtectedDir: () => join(testDir, "protected"),
-  getDataDir: () => join(testDir, "data"),
-  getWorkspaceDir: () => testDir,
-  getWorkspaceConfigPath: () => testConfigPath,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => testDbPath,
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -107,14 +84,6 @@ beforeAll(() => {
   writeFileSync(testConfigPath, JSON.stringify(EXISTING_CONFIG, null, 2));
 });
 
-afterAll(() => {
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
-});
-
 // ---------------------------------------------------------------------------
 // Tar archive builder helpers (mirrors validate test)
 // ---------------------------------------------------------------------------

package/src/__tests__/no-domain-routing-in-prompt-guard.test.ts

@@ -5,7 +5,8 @@ import { describe, expect, test } from "bun:test";
 /**
  * Guard test: domain-specific routing sections must NOT appear in the system
  * prompt source file. Routing cues now live in skill frontmatter
- * (`activation-hints` / `avoid-when`) and are projected into the skills catalog.
+ * (`activation-hints` / `avoid-when`) and are seeded as capability memories
+ * for semantic discovery.
  *
  * If this test fails, you are re-introducing hardcoded routing into the system
  * prompt. Instead, add `activation-hints` to the skill's SKILL.md frontmatter.

package/src/__tests__/oauth-apps-routes.test.ts

@@ -55,7 +55,6 @@ mock.module("../oauth/oauth-store.js", () => ({
           defaultScopes: "[]",
           scopePolicy: "[]",
           extraParams: null,
-          callbackTransport: null,
           pingUrl: null,
           pingMethod: null,
           pingHeaders: null,
@@ -70,6 +69,7 @@ mock.module("../oauth/oauth-store.js", () => ({
           identityBody: null,
           identityFormat: null,
           identityOkField: null,
+          featureFlag: null,
           createdAt: 1735689500000,
           updatedAt: 1735689550000,
         }
@@ -88,16 +88,18 @@ mock.module("../oauth/oauth-store.js", () => ({
   ),
 }));
 
+const mockOrchestrateOAuthConnect = mock(() =>
+  Promise.resolve({
+    success: true,
+    deferred: false,
+    grantedScopes: [],
+    accountInfo: null,
+    refreshTokenPresent: false,
+  }),
+);
+
 mock.module("../oauth/connect-orchestrator.js", () => ({
-  orchestrateOAuthConnect: mock(() =>
-    Promise.resolve({
-      success: true,
-      deferred: false,
-      grantedScopes: [],
-      accountInfo: null,
-      refreshTokenPresent: false,
-    }),
-  ),
+  orchestrateOAuthConnect: mockOrchestrateOAuthConnect,
 }));
 
 import { oauthAppsRouteDefinitions } from "../runtime/routes/oauth-apps.js";
@@ -202,3 +204,111 @@ describe("GET /v1/oauth/apps", () => {
     expect(body.provider).toBeNull();
   });
 });
+
+describe("POST /v1/oauth/apps/:appId/connect — callback_transport", () => {
+  function connectRequest(body?: unknown) {
+    return new Request("http://localhost/v1/oauth/apps/app-1/connect", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+  }
+
+  test('callback_transport: "gateway" is accepted and passed through', async () => {
+    mockOrchestrateOAuthConnect.mockClear();
+    const req = connectRequest({ callback_transport: "gateway" });
+    const url = new URL(req.url);
+    const res = await getRoute("POST", "oauth/apps/:appId/connect").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: { appId: "app-1" },
+    });
+
+    expect(res.status).toBe(200);
+    expect(mockOrchestrateOAuthConnect).toHaveBeenCalledTimes(1);
+    const callArgs = (
+      mockOrchestrateOAuthConnect.mock.calls as unknown as Array<
+        [{ callbackTransport: string }]
+      >
+    )[0]![0];
+    expect(callArgs.callbackTransport).toBe("gateway");
+  });
+
+  test('callback_transport: "loopback" is accepted and passed through', async () => {
+    mockOrchestrateOAuthConnect.mockClear();
+    const req = connectRequest({ callback_transport: "loopback" });
+    const url = new URL(req.url);
+    const res = await getRoute("POST", "oauth/apps/:appId/connect").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: { appId: "app-1" },
+    });
+
+    expect(res.status).toBe(200);
+    expect(mockOrchestrateOAuthConnect).toHaveBeenCalledTimes(1);
+    const callArgs = (
+      mockOrchestrateOAuthConnect.mock.calls as unknown as Array<
+        [{ callbackTransport: string }]
+      >
+    )[0]![0];
+    expect(callArgs.callbackTransport).toBe("loopback");
+  });
+
+  test('omitting callback_transport defaults to "loopback"', async () => {
+    mockOrchestrateOAuthConnect.mockClear();
+    const req = connectRequest({ scopes: ["email"] });
+    const url = new URL(req.url);
+    const res = await getRoute("POST", "oauth/apps/:appId/connect").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: { appId: "app-1" },
+    });
+
+    expect(res.status).toBe(200);
+    expect(mockOrchestrateOAuthConnect).toHaveBeenCalledTimes(1);
+    const callArgs = (
+      mockOrchestrateOAuthConnect.mock.calls as unknown as Array<
+        [{ callbackTransport: string }]
+      >
+    )[0]![0];
+    expect(callArgs.callbackTransport).toBe("loopback");
+  });
+
+  test('invalid callback_transport "websocket" returns 400', async () => {
+    mockOrchestrateOAuthConnect.mockClear();
+    const req = connectRequest({ callback_transport: "websocket" });
+    const url = new URL(req.url);
+    const res = await getRoute("POST", "oauth/apps/:appId/connect").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: { appId: "app-1" },
+    });
+
+    expect(res.status).toBe(400);
+    expect(mockOrchestrateOAuthConnect).not.toHaveBeenCalled();
+  });
+
+  test("invalid callback_transport (number) returns 400", async () => {
+    mockOrchestrateOAuthConnect.mockClear();
+    const req = connectRequest({ callback_transport: 123 });
+    const url = new URL(req.url);
+    const res = await getRoute("POST", "oauth/apps/:appId/connect").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: { appId: "app-1" },
+    });
+
+    expect(res.status).toBe(400);
+    expect(mockOrchestrateOAuthConnect).not.toHaveBeenCalled();
+  });
+});