@vellumai/assistant 0.9.0 → 0.10.0-dev.202606192226.8ed8a6a

package/src/runtime/migrations/__tests__/vbundle-builder-fd-leak.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Regression test for descriptor hygiene in the vbundle export path.
+ *
+ * `streamExportVBundle` opens every file in the workspace twice — once to hash
+ * it (Pass 1) and once to stream it into the tar (Pass 2). This test pins the
+ * invariant that those reads release their descriptors: the number of open
+ * descriptors held by the process must not grow proportionally to the number
+ * of files exported. Without that guarantee a workspace-sized export exhausts
+ * the daemon's descriptor limit (EMFILE) and every subsequent subprocess spawn
+ * fails.
+ *
+ * Descriptor counting uses `/proc/self/fd`, which only exists on Linux. The
+ * assertion is skipped on platforms without it (e.g. macOS dev machines); CI
+ * runs on Linux, so the regression stays covered there.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { assertNotLiveDb } from "../../../__tests__/assert-not-live-db.js";
+import { streamExportVBundle } from "../vbundle-builder.js";
+import { defaultV1Options } from "./v1-test-helpers.js";
+
+const PROC_SELF_FD = "/proc/self/fd";
+const hasProcFd = existsSync(PROC_SELF_FD);
+
+/** Count the descriptors currently open by this process. */
+function openFdCount(): number {
+  return readdirSync(PROC_SELF_FD).length;
+}
+
+/**
+ * Build a workspace with enough distinct files (across nested directories) that
+ * a per-file descriptor leak would be obvious against the assertion bound.
+ */
+function createPopulatedWorkspace(fileCount: number): {
+  dir: string;
+  cleanup: () => void;
+} {
+  const dir = join(
+    tmpdir(),
+    `vbundle-fd-leak-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "config.json"), JSON.stringify({ test: true }));
+  const dbDir = join(dir, "data", "db");
+  mkdirSync(dbDir, { recursive: true });
+  writeFileSync(join(dbDir, "assistant.db"), "fake-db-content");
+
+  // A spread of files under a few nested directories, each with non-trivial
+  // (multi-chunk) content so the read loop iterates more than once.
+  const filler = "x".repeat(200 * 1024);
+  for (let i = 0; i < fileCount; i++) {
+    const sub = join(dir, "data", "files", `dir-${i % 5}`);
+    mkdirSync(sub, { recursive: true });
+    writeFileSync(join(sub, `file-${i}.txt`), `${filler}\n${i}`);
+  }
+
+  return {
+    dir,
+    cleanup: () => {
+      assertNotLiveDb(dir);
+      rmSync(dir, { recursive: true, force: true });
+    },
+  };
+}
+
+describe("streamExportVBundle — descriptor lifecycle", () => {
+  test.skipIf(!hasProcFd)(
+    "does not leak a file descriptor per exported file",
+    async () => {
+      const fileCount = 60;
+      const workspace = createPopulatedWorkspace(fileCount);
+
+      // Warm-up export: first run can open and cache descriptors that legitimately
+      // persist (loggers, the daemon DB, etc.). Measuring the delta around a
+      // second export isolates per-file leakage from one-time setup.
+      let warmup: Awaited<ReturnType<typeof streamExportVBundle>> | undefined;
+      try {
+        warmup = await streamExportVBundle({
+          workspaceDir: workspace.dir,
+          ...defaultV1Options(),
+        });
+      } finally {
+        await warmup?.cleanup();
+      }
+
+      const before = openFdCount();
+
+      let result: Awaited<ReturnType<typeof streamExportVBundle>> | undefined;
+      try {
+        result = await streamExportVBundle({
+          workspaceDir: workspace.dir,
+          ...defaultV1Options(),
+        });
+        // Manifest covers every file we wrote — proves the walk actually read
+        // them (otherwise a no-op export would trivially leak nothing).
+        expect(result.manifest.contents.length).toBeGreaterThanOrEqual(
+          fileCount,
+        );
+      } finally {
+        await result?.cleanup();
+        workspace.cleanup();
+      }
+
+      const after = openFdCount();
+      const delta = after - before;
+
+      // Each export reads 2×fileCount files (hash pass + tar pass). A per-file
+      // leak would push the delta past `fileCount`. Allow a small constant for
+      // incidental descriptors (temp output file already cleaned up, jitter).
+      expect(delta).toBeLessThan(8);
+    },
+    // Two full exports of a multi-megabyte workspace (hash pass + tar pass each)
+    // do real disk I/O; the default 5s budget is tight under loaded CI runners.
+    30_000,
+  );
+});

package/src/runtime/migrations/vbundle-builder.ts

@@ -11,7 +11,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import {
   closeSync,
-  createReadStream,
   createWriteStream,
   existsSync,
   lstatSync,
@@ -21,7 +20,7 @@ import {
   readSync,
   realpathSync,
 } from "node:fs";
-import { stat, unlink } from "node:fs/promises";
+import { type FileHandle, open, stat, unlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { Readable } from "node:stream";
@@ -886,9 +885,10 @@ export function walkDirectoryForMetadata(
 }
 
 /**
- * Compute SHA-256 hex digest of a file by streaming — never buffers the
- * entire file in memory. When `size` is provided, only hashes the first
- * `size` bytes to match what will be archived in the tar entry.
+ * Compute SHA-256 hex digest of a file by reading it in bounded chunks —
+ * never buffers the entire file in memory. When `size` is provided, only
+ * hashes the first `size` bytes to match what will be archived in the tar
+ * entry.
  */
 async function computeFileSha256(
   filePath: string,
@@ -896,11 +896,28 @@ async function computeFileSha256(
 ): Promise<string> {
   const hash = createHash("sha256");
   if (size === 0) return hash.digest("hex");
-  const streamOpts =
-    size !== undefined ? { start: 0, end: size - 1 } : undefined;
-  const stream = createReadStream(filePath, streamOpts);
-  for await (const chunk of stream) {
-    hash.update(chunk);
+
+  // Read through an explicitly-managed FileHandle so the descriptor is
+  // always released in `finally`. This pass opens every file in the
+  // workspace, so any per-file descriptor leak here would exhaust the
+  // daemon's file-descriptor limit (EMFILE). A bounded read loop keeps peak
+  // memory flat regardless of file size.
+  const readChunkBytes = 64 * 1024;
+  const handle = await open(filePath, "r");
+  try {
+    const chunk = Buffer.allocUnsafe(readChunkBytes);
+    let position = 0;
+    for (;;) {
+      const remaining = size !== undefined ? size - position : Infinity;
+      if (remaining <= 0) break;
+      const toRead = Math.min(chunk.length, remaining);
+      const { bytesRead } = await handle.read(chunk, 0, toRead, position);
+      if (bytesRead === 0) break;
+      hash.update(chunk.subarray(0, bytesRead));
+      position += bytesRead;
+    }
+  } finally {
+    await handle.close();
   }
   return hash.digest("hex");
 }
@@ -1056,21 +1073,33 @@ async function* generateTarStream(
       // alignment. The WAL checkpoint before export is the primary
       // consistency mechanism for the database.
       let bytesWritten = 0;
-      if (file.size > 0) {
+      if (entrySize > 0) {
+        // Read through an explicitly-managed FileHandle so the descriptor is
+        // released in `finally` even when the consumer abandons the generator
+        // mid-file. Each read uses a fresh buffer so a yielded chunk is never
+        // overwritten by the next read before the consumer drains it.
+        let handle: FileHandle | undefined;
         try {
-          const stream = createReadStream(file.diskPath, {
-            start: 0,
-            end: file.size - 1,
-          });
-          for await (const chunk of stream) {
-            const data =
-              chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
-            bytesWritten += data.length;
-            yield data;
+          handle = await open(file.diskPath, "r");
+          const readChunkBytes = 64 * 1024;
+          while (bytesWritten < entrySize) {
+            const toRead = Math.min(readChunkBytes, entrySize - bytesWritten);
+            const buf = Buffer.allocUnsafe(toRead);
+            const { bytesRead } = await handle.read(
+              buf,
+              0,
+              toRead,
+              bytesWritten,
+            );
+            if (bytesRead === 0) break;
+            bytesWritten += bytesRead;
+            yield bytesRead === buf.length ? buf : buf.subarray(0, bytesRead);
           }
         } catch {
           // File was deleted or rotated between passes — emit zeros for
           // the full declared size so the tar structure stays valid
+        } finally {
+          if (handle) await handle.close();
         }
       }
 

package/src/runtime/pending-interactions.ts

@@ -19,6 +19,7 @@
  */
 
 import type { InteractionResolutionState } from "../api/events/interaction-resolved.js";
+import type { QuestionEntry } from "../api/events/question-request.js";
 import type { UserDecision } from "../permissions/types.js";
 import { getLogger } from "../util/logger.js";
 import { broadcastMessage } from "./assistant-event-hub.js";
@@ -50,6 +51,36 @@ export interface ConfirmationDetails {
   }>;
 }
 
+/**
+ * Full batched question payload carried on a pending `question` interaction, so
+ * a history-load render can stamp the outstanding prompt back onto its tool
+ * call and rehydrate the question card on a cold reconnect. Mirrors the
+ * `question_request` event's `questions[]` — `metadata` only retains the
+ * `orderedIds`/`optionsById` the response route needs to validate submissions,
+ * which is insufficient to reconstruct the card.
+ */
+export interface QuestionDetails {
+  entries: QuestionEntry[];
+}
+
+/**
+ * Public prompt metadata for a pending `secret` interaction, retained so a
+ * cold conversation load can rehydrate the secret prompt with its full
+ * descriptive context. SECURITY: never carries the secret value — only the
+ * public fields already broadcast on the `secret_request` event.
+ */
+export interface SecretDetails {
+  service: string;
+  field: string;
+  label: string;
+  description?: string;
+  placeholder?: string;
+  purpose?: string;
+  allowedTools?: string[];
+  allowedDomains?: string[];
+  allowOneTimeSend?: boolean;
+}
+
 export interface PendingInteraction {
   /**
    * Owning conversation, when the interaction was raised inside one. Absent
@@ -69,6 +100,10 @@ export interface PendingInteraction {
     | "host_transfer"
     | "acp_confirmation";
   confirmationDetails?: ConfirmationDetails;
+  /** For a pending `question`: the full batched entries, so a history-load render can rehydrate the question card. */
+  questionDetails?: QuestionDetails;
+  /** For a pending `secret`: the public prompt metadata, so a cold load can rehydrate the secret prompt. */
+  secretDetails?: SecretDetails;
   /** For ACP permissions: resolves directly without a Conversation object. */
   directResolve?: (decision: UserDecision) => void;
   /** When set, the host_bash request should be routed to this specific client. */

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

@@ -51,6 +51,7 @@ type ListClientsResponse = {
     machineName?: string;
     connectedAt: string;
     lastActiveAt: string;
+    degraded?: boolean;
   }>;
 };
 
@@ -152,4 +153,16 @@ describe("list_clients route — same-user filter", () => {
     const ids = result.clients.map((c) => c.clientId).sort();
     expect(ids).toEqual(["client-A1", "client-B1", "client-noprincipal"]);
   });
+
+  test("includes a degraded flag (false for a freshly connected client)", () => {
+    registerClient({ clientId: "client-A1", actorPrincipalId: "user-A" });
+
+    const handler = findHandler("list_clients");
+    const result = handler({
+      headers: { "x-vellum-actor-principal-id": "user-A" },
+    }) as ListClientsResponse;
+
+    expect(result.clients).toHaveLength(1);
+    expect(result.clients[0].degraded).toBe(false);
+  });
 });

package/src/runtime/routes/__tests__/conversation-management-routes.test.ts

@@ -26,6 +26,8 @@ mock.module("../../assistant-event-hub.js", () => ({
   broadcastMessage: () => {},
 }));
 
+import { eq } from "drizzle-orm";
+
 import { getDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
 import { conversations } from "../../../memory/schema.js";
@@ -71,6 +73,10 @@ function findHandler(routes: RouteDefinition[], operationId: string) {
   return route.handler;
 }
 
+const createHandler = findHandler(
+  CONVERSATION_MANAGEMENT_ROUTES,
+  "createConversation",
+);
 const putHandler = findHandler(
   CONVERSATION_MANAGEMENT_ROUTES,
   "setConversationInferenceProfile",
@@ -112,6 +118,67 @@ function seedConversation(id: string): void {
 // Tests
 // ---------------------------------------------------------------------------
 
+describe("POST /v1/conversations (createConversation)", () => {
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  function readConversation(id: string) {
+    return getDb()
+      .select({
+        title: conversations.title,
+        isAutoTitle: conversations.isAutoTitle,
+      })
+      .from(conversations)
+      .where(eq(conversations.id, id))
+      .get();
+  }
+
+  test("with a title → persists it as a user-set title (isAutoTitle = 0)", async () => {
+    const result = (await createHandler({
+      body: { conversationType: "standard", title: "Setting up your check-in" },
+    })) as { id: string; created: boolean };
+
+    expect(result.created).toBe(true);
+    const row = readConversation(result.id);
+    expect(row?.title).toBe("Setting up your check-in");
+    // isAutoTitle = 0 keeps the async LLM titler from overwriting it.
+    expect(row?.isAutoTitle).toBe(0);
+  });
+
+  test("blank title falls back to the replaceable 'New Conversation' placeholder", async () => {
+    const result = (await createHandler({
+      body: { conversationType: "standard", title: "   " },
+    })) as { id: string; created: boolean };
+
+    expect(result.created).toBe(true);
+    const row = readConversation(result.id);
+    expect(row?.title).toBe("New Conversation");
+    // Default auto-title flag (1) leaves it replaceable by the auto-titler.
+    expect(row?.isAutoTitle).toBe(1);
+  });
+
+  test("no title → 'New Conversation' placeholder", async () => {
+    const result = (await createHandler({
+      body: { conversationType: "standard" },
+    })) as { id: string; created: boolean };
+
+    expect(result.created).toBe(true);
+    const row = readConversation(result.id);
+    expect(row?.title).toBe("New Conversation");
+    expect(row?.isAutoTitle).toBe(1);
+  });
+
+  test("non-string title → BadRequestError (not a 500), no row created", () => {
+    // The shared route adapter doesn't runtime-validate the body, so the
+    // handler must reject a malformed title before `.trim()` throws.
+    expect(() =>
+      createHandler({ body: { conversationType: "standard", title: 123 } }),
+    ).toThrow(/title must be a string/);
+    expect(getDb().select().from(conversations).all()).toHaveLength(0);
+  });
+});
+
 describe("PUT /v1/conversations/:id/inference-profile", () => {
   beforeEach(() => {
     clearConversations();