@vellumai/assistant 0.7.1 → 0.7.2

package/src/runtime/routes/__tests__/gateway-log-routes.test.ts

@@ -0,0 +1,242 @@
+/**
+ * Unit tests for the gateway_logs_tail IPC route handler.
+ *
+ * Covers:
+ * - Happy path: all params → correct URL with querystring
+ * - All params absent → URL with no querystring
+ * - Only n provided → querystring has only n
+ * - Gateway returns 500 with error body → Error thrown with error message
+ * - level: "INVALID" → ZodError (no gateway call)
+ * - n: 0 → ZodError (min 1 violation)
+ * - n: 1001 → ZodError (max 1000 violation)
+ * - module: "" → accepted (empty string passes zod string validation)
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { ZodError } from "zod";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be defined before importing the module under test
+// ---------------------------------------------------------------------------
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../../config/env.js", () => ({
+  getGatewayInternalBaseUrl: () => "http://localhost:9999",
+}));
+
+// ---------------------------------------------------------------------------
+// Import the module under test AFTER mocks are set up
+// ---------------------------------------------------------------------------
+
+import { ROUTES } from "../gateway-log-routes.js";
+
+const gatewayLogsTailRoute = ROUTES.find(
+  (r) => r.operationId === "gateway_logs_tail",
+)!;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeFetchMock(
+  status: number,
+  body: unknown,
+): ReturnType<typeof mock> {
+  return mock(async () => ({
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+  }));
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("gateway_logs_tail route", () => {
+  beforeEach(() => {
+    // Reset global fetch to avoid cross-test contamination
+    globalThis.fetch = undefined as unknown as typeof fetch;
+  });
+
+  test("route is registered with correct operationId, method, and endpoint", () => {
+    expect(gatewayLogsTailRoute).toBeDefined();
+    expect(gatewayLogsTailRoute.operationId).toBe("gateway_logs_tail");
+    expect(gatewayLogsTailRoute.method).toBe("GET");
+    expect(gatewayLogsTailRoute.endpoint).toBe("gateway/logs/tail");
+  });
+
+  describe("happy path — all params provided via body", () => {
+    test("calls gateway with correct URL including all query params", async () => {
+      const mockFetch = makeFetchMock(200, { entries: [] });
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      await gatewayLogsTailRoute.handler({
+        body: { n: 5, level: "warn", module: "mcp" },
+      });
+
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
+      expect(calledUrl).toBe(
+        "http://localhost:9999/v1/logs/tail?n=5&level=warn&module=mcp",
+      );
+    });
+
+    test("returns the parsed response body", async () => {
+      const responseBody = { entries: [{ msg: "hello", level: 40 }] };
+      globalThis.fetch = makeFetchMock(200, responseBody) as unknown as typeof fetch;
+
+      const result = await gatewayLogsTailRoute.handler({
+        body: { n: 5, level: "warn", module: "mcp" },
+      });
+
+      expect(result).toEqual(responseBody);
+    });
+  });
+
+  describe("all params absent", () => {
+    test("calls gateway URL with no querystring when body is empty", async () => {
+      const mockFetch = makeFetchMock(200, { entries: [] });
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      await gatewayLogsTailRoute.handler({ body: {} });
+
+      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
+      expect(calledUrl).toBe("http://localhost:9999/v1/logs/tail");
+    });
+
+    test("calls gateway URL with no querystring when no args provided", async () => {
+      const mockFetch = makeFetchMock(200, { entries: [] });
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      await gatewayLogsTailRoute.handler({});
+
+      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
+      expect(calledUrl).toBe("http://localhost:9999/v1/logs/tail");
+    });
+  });
+
+  describe("only n provided", () => {
+    test("querystring contains only n — no spurious level or module keys", async () => {
+      const mockFetch = makeFetchMock(200, { entries: [] });
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      await gatewayLogsTailRoute.handler({ body: { n: 5 } });
+
+      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
+      expect(calledUrl).toBe("http://localhost:9999/v1/logs/tail?n=5");
+      expect(calledUrl).not.toContain("level");
+      expect(calledUrl).not.toContain("module");
+    });
+  });
+
+  describe("gateway error handling", () => {
+    test("gateway 500 with { error: 'disk error' } throws Error with that message", async () => {
+      globalThis.fetch = makeFetchMock(500, {
+        error: "disk error",
+      }) as unknown as typeof fetch;
+
+      await expect(
+        gatewayLogsTailRoute.handler({ body: {} }),
+      ).rejects.toThrow("disk error");
+    });
+
+    test("gateway 500 with non-string error falls back to generic message", async () => {
+      globalThis.fetch = makeFetchMock(500, {
+        error: { nested: true },
+      }) as unknown as typeof fetch;
+
+      await expect(
+        gatewayLogsTailRoute.handler({ body: {} }),
+      ).rejects.toThrow("Gateway request failed (500)");
+    });
+
+    test("gateway 500 with unparseable JSON falls back to generic message", async () => {
+      globalThis.fetch = mock(async () => ({
+        ok: false,
+        status: 500,
+        json: async () => {
+          throw new SyntaxError("Unexpected token");
+        },
+      })) as unknown as typeof fetch;
+
+      await expect(
+        gatewayLogsTailRoute.handler({ body: {} }),
+      ).rejects.toThrow("Gateway request failed (500)");
+    });
+  });
+
+  describe("zod validation", () => {
+    test("level: 'INVALID' is rejected with ZodError before calling gateway", async () => {
+      const mockFetch = makeFetchMock(200, {});
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      await expect(
+        gatewayLogsTailRoute.handler({
+          body: { level: "INVALID" },
+        }),
+      ).rejects.toBeInstanceOf(ZodError);
+
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    test("n: 0 is rejected with ZodError (min 1 violation)", async () => {
+      const mockFetch = makeFetchMock(200, {});
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      await expect(
+        gatewayLogsTailRoute.handler({ body: { n: 0 } }),
+      ).rejects.toBeInstanceOf(ZodError);
+
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    test("n: 1001 is rejected with ZodError (max 1000 violation)", async () => {
+      const mockFetch = makeFetchMock(200, {});
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      await expect(
+        gatewayLogsTailRoute.handler({ body: { n: 1001 } }),
+      ).rejects.toBeInstanceOf(ZodError);
+
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    test("module: '' is accepted (empty string passes zod string validation)", async () => {
+      const mockFetch = makeFetchMock(200, { entries: [] });
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      await expect(
+        gatewayLogsTailRoute.handler({ body: { module: "" } }),
+      ).resolves.toBeDefined();
+
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("queryParams source (HTTP GET path)", () => {
+    test("uses queryParams when provided (HTTP GET path) — string params", async () => {
+      const mockFetch = makeFetchMock(200, { entries: [] });
+      globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+      // When queryParams has values, those take precedence over body.
+      // Only string-valued params (level, module) are valid from the HTTP layer;
+      // n is numeric and must come via IPC body.
+      await gatewayLogsTailRoute.handler({
+        queryParams: { level: "info", module: "cors" },
+        body: {},
+      });
+
+      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
+      expect(calledUrl).toContain("level=info");
+      expect(calledUrl).toContain("module=cors");
+    });
+  });
+});

package/src/runtime/routes/__tests__/heartbeat-routes.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Asserts `setHeartbeatConfig` persists only user-set heartbeat fields to
+ * `config.json` and surfaces the resolved (post-default) values via the
+ * response payload.
+ */
+
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { invalidateConfigCache } from "../../../config/loader.js";
+import { ROUTES } from "../heartbeat-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+// ─── Module mocks ──────────────────────────────────────────────────────────
+
+// Stub the heartbeat service so the response-path's getInstance() returns
+// undefined (no scheduler running in tests).
+mock.module("../../../heartbeat/heartbeat-service.js", () => ({
+  HeartbeatService: {
+    getInstance: () => undefined,
+  },
+}));
+
+// ─── Setup ─────────────────────────────────────────────────────────────────
+
+let workspaceDir: string;
+let origWorkspaceDir: string | undefined;
+let configPath: string;
+
+function findHandler(operationId: string): RouteDefinition["handler"] {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath, "utf-8"));
+}
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-hbr-"));
+  origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+  configPath = join(workspaceDir, "config.json");
+  invalidateConfigCache();
+});
+
+afterEach(() => {
+  if (origWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
+  }
+  invalidateConfigCache();
+  try {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  } catch {
+    // best-effort cleanup
+  }
+});
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("setHeartbeatConfig handler", () => {
+  test("persists only user-set fields when starting from a config with no heartbeat block", async () => {
+    writeFileSync(
+      configPath,
+      JSON.stringify({ provider: "anthropic" }, null, 2) + "\n",
+    );
+
+    const handler = findHandler("updateHeartbeatConfig");
+    const result = (await handler({ body: { enabled: true } })) as {
+      enabled: boolean;
+      intervalMs: number;
+      activeHoursStart: number | null;
+      activeHoursEnd: number | null;
+      success: boolean;
+    };
+
+    // On-disk: only user-set heartbeat fields, no schema defaults baked in.
+    const onDisk = readConfig();
+    expect(onDisk).toEqual({
+      provider: "anthropic",
+      heartbeat: { enabled: true },
+    });
+
+    // Response: schema-default intervalMs surfaces, proving cache
+    // invalidation + getConfig() read picked up the new on-disk state.
+    expect(result.success).toBe(true);
+    expect(result.enabled).toBe(true);
+    expect(result.intervalMs).toBe(6 * 3_600_000);
+    expect(result.activeHoursStart).toBe(8);
+    expect(result.activeHoursEnd).toBe(22);
+  });
+
+  test("merges patch into existing heartbeat block instead of overwriting", async () => {
+    writeFileSync(
+      configPath,
+      JSON.stringify({ heartbeat: { intervalMs: 60000 } }, null, 2) + "\n",
+    );
+
+    const handler = findHandler("updateHeartbeatConfig");
+    await handler({ body: { enabled: true } });
+
+    const onDisk = readConfig();
+    expect(onDisk).toEqual({
+      heartbeat: { intervalMs: 60000, enabled: true },
+    });
+  });
+});

package/src/runtime/routes/approval-interception-types.ts

@@ -0,0 +1,13 @@
+/**
+ * Types extracted from guardian-approval-interception.ts to break the
+ * interception ↔ guardian-text-engine-strategy cycle.
+ */
+
+export interface ApprovalInterceptionResult {
+  handled: boolean;
+  type?:
+    | "decision_applied"
+    | "assistant_turn"
+    | "guardian_decision_applied"
+    | "stale_ignored";
+}

package/src/runtime/routes/approval-strategies/guardian-text-engine-strategy.ts

@@ -17,7 +17,7 @@ import type {
   ApprovalConversationGenerator,
   ApprovalCopyGenerator,
 } from "../../http-types.js";
-import type { ApprovalInterceptionResult } from "../guardian-approval-interception.js";
+import type { ApprovalInterceptionResult } from "../approval-interception-types.js";
 import { deliverStaleApprovalReply } from "../guardian-approval-reply-helpers.js";
 
 const log = getLogger("runtime-http");

package/src/runtime/routes/backup-routes.ts

@@ -26,17 +26,11 @@ import { dirname, sep } from "node:path";
 
 import { z } from "zod";
 
-import { readBackupKey } from "../../backup/backup-key.js";
-import {
-  type BackupRunResult,
-  createSnapshotNow,
-} from "../../backup/backup-worker.js";
 import {
   listSnapshotsInDir,
   type SnapshotEntry,
 } from "../../backup/list-snapshots.js";
 import {
-  getBackupKeyPath,
   getLocalBackupsDir,
   resolveOffsiteDestinations,
 } from "../../backup/paths.js";
@@ -47,7 +41,7 @@ import { getMemoryCheckpoint } from "../../memory/checkpoints.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir, getWorkspaceHooksDir } from "../../util/platform.js";
 import { DefaultPathResolver } from "../migrations/vbundle-import-analyzer.js";
-import { BadRequestError, ConflictError, RouteError } from "./errors.js";
+import { BadRequestError, RouteError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("backup-routes");
@@ -115,23 +109,16 @@ async function validateSnapshotPath(rawPath: unknown): Promise<string> {
 }
 
 /**
- * Load the backup decryption key iff the target snapshot is encrypted.
- * Returns null for plaintext bundles. Throws BadRequestError when an
- * encrypted bundle is supplied but no key file exists.
+ * Reject encrypted snapshots — decryption has moved to the gateway (ATL-397).
+ * The assistant daemon no longer has access to the backup key.
  */
-async function loadKeyIfEncrypted(
-  snapshotPath: string,
-): Promise<Buffer | null> {
-  if (!snapshotPath.endsWith(".vbundle.enc")) {
-    return null;
-  }
-  const key = await readBackupKey(getBackupKeyPath());
-  if (key == null) {
+function rejectIfEncrypted(snapshotPath: string): void {
+  if (snapshotPath.endsWith(".vbundle.enc")) {
     throw new BadRequestError(
-      "Encrypted snapshot requires a backup key, but backup.key is missing",
+      "Encrypted snapshot restore/verify must go through the gateway, " +
+        "which owns the backup key. Use the gateway's backup endpoints instead.",
     );
   }
-  return key;
 }
 
 // ---------------------------------------------------------------------------
@@ -189,24 +176,17 @@ export async function handleBackupList(): Promise<BackupListResponse> {
   return { local, offsite, offsiteEnabled, nextRunAt };
 }
 
-export async function handleBackupCreate(): Promise<BackupRunResult> {
-  try {
-    const config = getConfig();
-    return await createSnapshotNow(config.backup, new Date());
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.startsWith("snapshot in progress")) {
-      throw new ConflictError("A snapshot is already in progress");
-    }
-    log.error({ err }, "Manual backup snapshot failed");
-    throw new RouteError(message, "INTERNAL_ERROR", 500);
-  }
+export async function handleBackupCreate(): Promise<never> {
+  throw new BadRequestError(
+    "Backup snapshot creation has moved to the gateway. " +
+      "Use the gateway's POST /v1/backups/create endpoint instead.",
+  );
 }
 
 export async function handleBackupRestore({ body }: RouteHandlerArgs) {
   const path = body?.path;
   const snapshotPath = await validateSnapshotPath(path);
-  const key = await loadKeyIfEncrypted(snapshotPath);
+  rejectIfEncrypted(snapshotPath);
 
   try {
     const pathResolver = new DefaultPathResolver(
@@ -215,7 +195,6 @@ export async function handleBackupRestore({ body }: RouteHandlerArgs) {
     );
 
     const result = await restoreFromSnapshot(snapshotPath, {
-      key: key ?? undefined,
       pathResolver,
       workspaceDir: getWorkspaceDir(),
     });
@@ -239,12 +218,10 @@ export async function handleBackupRestore({ body }: RouteHandlerArgs) {
 export async function handleBackupVerify({ body }: RouteHandlerArgs) {
   const path = body?.path;
   const snapshotPath = await validateSnapshotPath(path);
-  const key = await loadKeyIfEncrypted(snapshotPath);
+  rejectIfEncrypted(snapshotPath);
 
   try {
-    return await verifySnapshot(snapshotPath, {
-      key: key ?? undefined,
-    });
+    return await verifySnapshot(snapshotPath);
   } catch (err) {
     log.error({ err, snapshotPath }, "Snapshot verification failed");
     throw new RouteError(

package/src/runtime/routes/btw-routes.ts

@@ -18,6 +18,8 @@ import { z } from "zod";
 
 import { readNowScratchpad } from "../../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
+import { buildToolDefinitions } from "../../daemon/conversation-tool-setup.js";
+import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getConversationByKey } from "../../memory/conversation-key-store.js";
 import { resolvePersonaContext } from "../../prompts/persona-resolver.js";
 import { getLogger } from "../../util/logger.js";
@@ -35,33 +37,6 @@ const IDENTITY_INTRO_KEY = "identity-intro";
 /** Conversation key used by the client for empty-state greeting generation. */
 const GREETING_KEY = "greeting";
 
-/**
- * Parse the `## Identity Intro` section from SOUL.md.
- * Returns the first non-empty line under that heading, or null.
- */
-function readSoulIdentityIntro(): string | null {
-  try {
-    const soulPath = getWorkspacePromptPath("SOUL.md");
-    if (!existsSync(soulPath)) return null;
-    const content = readFileSync(soulPath, "utf-8");
-
-    let inSection = false;
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (/^#+\s/.test(trimmed)) {
-        inSection = trimmed.toLowerCase().includes("identity intro");
-        continue;
-      }
-      if (inSection && trimmed.length > 0) {
-        return trimmed;
-      }
-    }
-  } catch {
-    // Fall through — no SOUL.md intro available
-  }
-  return null;
-}
-
 // ---------------------------------------------------------------------------
 // SSE helpers
 // ---------------------------------------------------------------------------
@@ -94,14 +69,17 @@ async function handleBtw({
 
   // ----- Identity intro fast-path -----
   if (conversationKey === IDENTITY_INTRO_KEY) {
-    const soulIntro = readSoulIdentityIntro();
-    const fastText = soulIntro ?? getCachedIntro()?.text;
+    let fastText: string | undefined;
+    const identityPath = getWorkspacePromptPath("IDENTITY.md");
+    if (existsSync(identityPath)) {
+      const fields = parseIdentityFields(readFileSync(identityPath, "utf-8"));
+      if (fields.name) {
+        fastText = `Hi, I'm ${fields.name}!`;
+      }
+    }
+    fastText ??= getCachedIntro()?.text;
     if (fastText) {
-      log.debug(
-        soulIntro
-          ? "Returning SOUL.md identity intro"
-          : "Returning cached identity intro",
-      );
+      log.debug("Returning identity intro fast-path");
       return new ReadableStream({
         start(controller) {
           controller.enqueue(sseEvent("btw_text_delta", { text: fastText }));
@@ -129,9 +107,7 @@ async function handleBtw({
   try {
     conversation = await getOrCreateConversation(conversationId);
   } catch {
-    throw new ServiceUnavailableError(
-      "Message processing is not available",
-    );
+    throw new ServiceUnavailableError("Message processing is not available");
   }
 
   return new ReadableStream({
@@ -145,6 +121,7 @@ async function handleBtw({
           const result = await runBtwSidechain({
             content: effectiveContent,
             conversation,
+            tools: buildToolDefinitions(),
             signal: abortSignal,
             userPersona,
             channelPersona,

package/src/runtime/routes/client-routes.ts

@@ -48,6 +48,7 @@ export const ROUTES: RouteDefinition[] = [
             clientId: c.clientId,
             interfaceId: c.interfaceId,
             capabilities: c.capabilities,
+            machineName: c.machineName,
             connectedAt: c.connectedAt,
             lastActiveAt: c.lastActiveAt,
           }),