@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/runtime/routes/workspace-tree-walk.ts

@@ -0,0 +1,240 @@
+/**
+ * The directory walk behind GET /v1/workspace/tree.
+ *
+ * One directory by default. With `recursive`, the whole subtree in one
+ * response, so a client can search or expand without a request per folder.
+ * The walk yields the event loop between directories and is bounded by an
+ * entry cap and a deadline; it does not descend into the runtime-state
+ * directories the workspace's own gitignore rules name.
+ */
+import type { Dirent, Stats } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { join, sep } from "node:path";
+
+import ignore from "ignore";
+
+import { WORKSPACE_GITIGNORE_RULES } from "../../workspace/git-service.js";
+import type { WorkspaceEntry } from "./workspace-utils.js";
+
+/**
+ * Entries a recursive listing returns before it stops descending and
+ * reports `truncated`. The root's own listing is always whole, so the
+ * answer is never worse than a non-recursive one.
+ */
+export const MAX_RECURSIVE_ENTRIES = 20_000;
+
+/** Wall-clock budget for one recursive walk. */
+export const MAX_RECURSIVE_WALK_MS = 3_000;
+
+/**
+ * Directories the recursive walk lists but does not enter: whatever the
+ * workspace's own gitignore rules exclude (databases, caches, dependency
+ * trees, logs), which is the one maintained statement of what in a
+ * workspace is runtime state rather than the user's files. Files those rules
+ * match are still listed; only descent is decided here.
+ */
+const descentRules = ignore().add(WORKSPACE_GITIGNORE_RULES);
+
+/** git never lists its own metadata directory, and neither does this walk. */
+const GIT_DIR = ".git";
+
+function isDescentSkipped(relativeDirPath: string, name: string): boolean {
+  return name === GIT_DIR || descentRules.ignores(`${relativeDirPath}/`);
+}
+
+export interface WorkspaceTreeWalk {
+  entries: WorkspaceEntry[];
+  /** The entry cap or the deadline stopped a recursive walk early. */
+  truncated: boolean;
+  /**
+   * Workspace-relative directories the walk listed but did not enter, for
+   * any reason: a gitignore rule, a symlink, or a directory that could not
+   * be read. A client that wants their contents asks for them one at a time.
+   */
+  skipped: string[];
+}
+
+export interface WorkspaceTreeWalkOptions {
+  /** Absolute directory to list. */
+  rootPath: string;
+  /** Absolute workspace root; entry paths are relative to it. */
+  workspaceDir: string;
+  showHidden: boolean;
+  recursive: boolean;
+  /**
+   * Per-directory size for directory entries in a non-recursive listing.
+   * Ignored when `recursive`, where directories report `size: null`.
+   */
+  directorySize?: (absPath: string) => number | null;
+  maxEntries?: number;
+  maxWalkMs?: number;
+  /** Clock for the deadline. Tests hand in a scripted one. */
+  now?: () => number;
+}
+
+function byDirectoriesThenName(a: WorkspaceEntry, b: WorkspaceEntry): number {
+  if (a.type !== b.type) {
+    return a.type === "directory" ? -1 : 1;
+  }
+  return a.name.localeCompare(b.name);
+}
+
+interface ListedDirectory {
+  entries: WorkspaceEntry[];
+  /** Directory entries in listing order, with whether each is a symlink. */
+  subdirectories: Array<{
+    absPath: string;
+    relativePath: string;
+    name: string;
+    isSymlink: boolean;
+  }>;
+}
+
+/**
+ * What a nested directory may cost a recursive walk. The listing stops
+ * before any stat work when the directory has more entries than the
+ * response has room for, and between stats once the deadline passes, so a
+ * single wide or slow directory cannot carry the walk past its bound.
+ */
+interface ListingBudget {
+  room: number;
+  deadline: number;
+}
+
+/**
+ * One directory's entries, sorted directories first then by name. Types
+ * follow `stat`, so a symlinked directory reads as a directory; the caller
+ * decides whether to enter it. Returns `null` when a budget stops the
+ * listing, in which case none of it is reported.
+ */
+async function listDirectory(
+  absDir: string,
+  {
+    workspaceDir,
+    showHidden,
+    directorySize,
+    now = Date.now,
+  }: WorkspaceTreeWalkOptions,
+  budget?: ListingBudget,
+): Promise<ListedDirectory | null> {
+  const dirents: Dirent[] = (
+    await readdir(absDir, { withFileTypes: true })
+  ).filter((dirent) => showHidden || !dirent.name.startsWith("."));
+  if (budget && dirents.length > budget.room) {
+    return null;
+  }
+  const entries: WorkspaceEntry[] = [];
+  const subdirectories: ListedDirectory["subdirectories"] = [];
+
+  for (const dirent of dirents) {
+    if (budget && now() > budget.deadline) {
+      return null;
+    }
+    const absPath = join(absDir, dirent.name);
+    let stats: Stats;
+    try {
+      stats = await stat(absPath);
+    } catch {
+      continue;
+    }
+    const isDir = stats.isDirectory();
+    // Wire paths use "/" on every host; clients key expansion and
+    // ancestry on them and never see the daemon's own separator.
+    const relativePath = absPath
+      .slice(workspaceDir.length + 1)
+      .split(sep)
+      .join("/");
+    entries.push({
+      name: dirent.name,
+      path: relativePath,
+      type: isDir ? "directory" : "file",
+      size: isDir ? (directorySize?.(absPath) ?? null) : stats.size,
+      mimeType: isDir ? null : Bun.file(absPath).type,
+      modifiedAt: stats.mtime.toISOString(),
+    });
+    if (isDir) {
+      subdirectories.push({
+        absPath,
+        relativePath,
+        name: dirent.name,
+        isSymlink: dirent.isSymbolicLink(),
+      });
+    }
+  }
+
+  entries.sort(byDirectoriesThenName);
+  subdirectories.sort((a, b) => a.name.localeCompare(b.name));
+  return { entries, subdirectories };
+}
+
+/**
+ * List `rootPath`. A recursive walk is depth-first with each directory's
+ * entries in listing order and never part of a directory, so grouping the
+ * result by parent path gives every directory's listing exactly as a
+ * non-recursive request would, or nothing for it at all.
+ *
+ * Symlinked directories are listed but never entered, so a link cannot make
+ * the walk cycle or leave the workspace; they are reported in `skipped`, as
+ * is a directory found mid-walk that cannot be read. The root's own read
+ * error is the caller's to report.
+ */
+export async function walkWorkspaceTree(
+  options: WorkspaceTreeWalkOptions,
+): Promise<WorkspaceTreeWalk> {
+  const {
+    rootPath,
+    recursive,
+    maxEntries = MAX_RECURSIVE_ENTRIES,
+    maxWalkMs = MAX_RECURSIVE_WALK_MS,
+    now = Date.now,
+  } = options;
+  // A recursive listing carries every file, so a client sums directory
+  // sizes itself and no per-directory sizer runs.
+  const listOptions = recursive
+    ? { ...options, directorySize: undefined }
+    : options;
+  // The root is listed without a budget: its listing is always whole.
+  const root = (await listDirectory(rootPath, listOptions))!;
+  if (!recursive) {
+    return { entries: root.entries, truncated: false, skipped: [] };
+  }
+
+  const deadline = now() + maxWalkMs;
+  const entries: WorkspaceEntry[] = [...root.entries];
+  const skipped: string[] = [];
+  // Reversed so the stack pops subdirectories in listing order.
+  const stack = root.subdirectories.slice().reverse();
+
+  while (stack.length > 0) {
+    const dir = stack.pop()!;
+    if (dir.isSymlink || isDescentSkipped(dir.relativePath, dir.name)) {
+      skipped.push(dir.relativePath);
+      continue;
+    }
+    if (entries.length >= maxEntries || now() > deadline) {
+      return { entries, truncated: true, skipped };
+    }
+
+    let listed: ListedDirectory | null;
+    try {
+      listed = await listDirectory(dir.absPath, listOptions, {
+        room: maxEntries - entries.length,
+        deadline,
+      });
+    } catch {
+      skipped.push(dir.relativePath);
+      continue;
+    }
+    // A directory is carried whole or not at all, so a client grouping the
+    // result by parent never mistakes part of a listing for all of it.
+    if (listed === null) {
+      return { entries, truncated: true, skipped };
+    }
+    entries.push(...listed.entries);
+    for (let i = listed.subdirectories.length - 1; i >= 0; i--) {
+      stack.push(listed.subdirectories[i]);
+    }
+  }
+
+  return { entries, truncated: false, skipped };
+}

package/src/runtime/routes/workspace-utils.ts

@@ -8,9 +8,26 @@ import {
 } from "node:fs";
 import { dirname, resolve, sep } from "node:path";
 
+import { z } from "zod";
+
 import { getWorkspaceDir } from "../../util/platform.js";
 import { BadRequestError, ConflictError } from "./errors.js";
 
+/**
+ * One workspace entry as the tree endpoint reports it. `size` is null for a
+ * directory whose recursive size was not computed.
+ */
+export const workspaceEntrySchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  type: z.enum(["file", "directory"]),
+  size: z.number().nullable(),
+  mimeType: z.string().nullable(),
+  modifiedAt: z.string(),
+});
+
+export type WorkspaceEntry = z.infer<typeof workspaceEntrySchema>;
+
 /**
  * Resolves a user-provided relative path to an absolute path within the workspace.
  * Returns the resolved absolute path, or undefined if the path escapes the workspace root.

package/src/runtime/services/__tests__/conversation-serializer.test.ts

@@ -159,3 +159,31 @@ describe("serializeConversationSummary · enabledPlugins", () => {
     expect("enabledPlugins" in summary).toBe(false);
   });
 });
+
+describe("serializeConversationSummary · title keys", () => {
+  test("resolves a stored title key for the locale", () => {
+    const summary = serializeConversationSummary({
+      conversation: makeConversationRow({
+        title: "conversation.title.generating",
+      }),
+      displayMeta: { displayOrder: null, isPinned: false, groupId: null },
+      parentCache: new Map(),
+      isProcessing: false,
+      locale: "es",
+    });
+    expect(summary.title).toBe("Generando título...");
+    expect("titleState" in summary).toBe(false);
+  });
+
+  test("passes a stored display string through", () => {
+    const summary = serialize(
+      makeConversationRow({ title: "Untitled Conversation" }),
+    );
+    expect(summary.title).toBe("Untitled Conversation");
+  });
+
+  test("passes a custom title through", () => {
+    const summary = serialize(makeConversationRow({ title: "Weekly planning" }));
+    expect(summary.title).toBe("Weekly planning");
+  });
+});

package/src/runtime/services/conversation-serializer.ts

@@ -8,6 +8,10 @@
 
 import { parseChannelId } from "../../channels/types.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
+import {
+  resolveConversationTitle,
+  type SupportedLocale,
+} from "../../i18n/index.js";
 import { buildChannelBindingMetadata } from "../../messaging/channel-binding-metadata.js";
 import {
   type AttentionState,
@@ -78,6 +82,7 @@ interface ForkLineage {
 function buildForkLineage(
   conversation: ConversationRow,
   parentCache: Map<string, ConversationRow | null>,
+  locale?: SupportedLocale,
 ): ForkLineage {
   const parentConversationId = conversation.forkParentConversationId;
   const parentMessageId = conversation.forkParentMessageId;
@@ -101,7 +106,7 @@ function buildForkLineage(
     forkParent: {
       conversationId: parentConversationId,
       messageId: parentMessageId,
-      title: parentConversation.title ?? "Untitled",
+      title: resolveConversationTitle(parentConversation.title, locale),
     },
   };
 }
@@ -178,6 +183,11 @@ export function serializeConversationSummary(params: {
    * with no daemon-store coupling.
    */
   isProcessing: boolean;
+  /**
+   * Locale used to resolve stored title keys. Omitted locale is English
+   * inside {@link resolveConversationTitle}.
+   */
+  locale?: SupportedLocale;
 }) {
   const {
     conversation,
@@ -186,14 +196,15 @@ export function serializeConversationSummary(params: {
     displayMeta,
     parentCache,
     isProcessing,
+    locale,
   } = params;
   const originChannel = parseChannelId(conversation.originChannel);
   const assistantAttention = buildAssistantAttention(attentionState);
-  const forkLineage = buildForkLineage(conversation, parentCache);
+  const forkLineage = buildForkLineage(conversation, parentCache, locale);
 
   return {
     id: conversation.id,
-    title: conversation.title ?? "Untitled",
+    title: resolveConversationTitle(conversation.title, locale),
     createdAt: conversation.createdAt,
     updatedAt: conversation.updatedAt,
     lastMessageAt: conversation.lastMessageAt,
@@ -253,6 +264,7 @@ export function serializeConversationSummary(params: {
  */
 export function buildConversationDetailResponse(
   conversationId: string,
+  locale?: SupportedLocale,
 ): { conversation: ReturnType<typeof serializeConversationSummary> } | null {
   const conversation = getConversation(conversationId);
   if (!conversation || conversation.conversationType === "private") {
@@ -274,6 +286,7 @@ export function buildConversationDetailResponse(
       // Checks in-memory flag first (hot path), falls back to the
       // persisted `processing_started_at` column for cold conversations.
       isProcessing: isConversationProcessing(conversation.id),
+      locale,
     }),
   };
 }

package/src/runtime/sync/resource-sync-events.ts

@@ -4,6 +4,7 @@ import {
   conversationMetadataSyncTag,
   SYNC_TAGS,
 } from "../../daemon/message-types/sync.js";
+import { resolveConversationTitle } from "../../i18n/index.js";
 import { syncAvatarToPlatform } from "../../platform/sync-avatar.js";
 import { getAvatarImagePath } from "../../util/platform.js";
 import { broadcastMessage } from "../assistant-event-hub.js";
@@ -257,7 +258,7 @@ export function publishConversationTitleChanged(
     {
       type: "conversation_title_updated",
       conversationId,
-      title,
+      title: resolveConversationTitle(title),
     },
     conversationId,
   );

package/src/schedule/run-script.ts

@@ -5,6 +5,7 @@ import {
 } from "../util/host-process.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
+import { safeStringSlice } from "../util/unicode.js";
 
 const log = getLogger("run-script");
 
@@ -200,7 +201,7 @@ function truncate(text: string): string {
   if (text.length <= MAX_OUTPUT_BYTES) {
     return text;
   }
-  return text.slice(0, MAX_OUTPUT_BYTES) + "\n... (truncated)";
+  return safeStringSlice(text, 0, MAX_OUTPUT_BYTES) + "\n... (truncated)";
 }
 
 /**

package/src/schedule/schedule-store.ts

@@ -23,6 +23,7 @@ import { publishSchedulesChanged } from "../runtime/sync/resource-sync-events.js
 import { UserError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { withSqliteRetry } from "../util/sqlite-retry.js";
+import { safeStringSlice } from "../util/unicode.js";
 import {
   hasOwnerDeferProvenance,
   isDeferSchedule,
@@ -1511,8 +1512,14 @@ async function finishScheduleRunRow(
           status: result.status,
           finishedAt: now,
           durationMs,
-          output: result.output?.slice(0, 10_000) ?? null,
-          error: result.error?.slice(0, 2000) ?? null,
+          output:
+            result.output === undefined
+              ? null
+              : safeStringSlice(result.output, 0, 10_000),
+          error:
+            result.error === undefined
+              ? null
+              : safeStringSlice(result.error, 0, 2000),
         })
         .where(eq(scheduleRuns.id, runId))
         .run(),

package/src/schedule/worker.ts

@@ -195,7 +195,7 @@ async function main(): Promise<void> {
   //
   // Bounded by MCP_STARTUP_GRACE_MS: unreachable servers must not hold the
   // schedules that do not use them. The connect runs on past the deadline.
-  const mcpStartup = startConfiguredMcpServers(getConfig().mcp);
+  const mcpStartup = startConfiguredMcpServers();
   await Promise.race([
     mcpStartup,
     // Unref'd so a connect that beats the deadline leaves nothing pending.

package/src/security/__tests__/ces-http-record-backend.test.ts

@@ -0,0 +1,137 @@
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+
+import type { CredentialRecord } from "@vellumai/service-contracts/credential-rpc";
+
+import * as envRegistry from "../../config/env-registry.js";
+import {
+  CesHttpRecordBackend,
+  createCesHttpRecordBackendIfConfigured,
+} from "../ces-http-record-backend.js";
+
+const ORIGINAL_URL = process.env.CES_CREDENTIAL_URL;
+const ORIGINAL_TOKEN = process.env.CES_SERVICE_TOKEN;
+
+function restoreCesHttpEnv(): void {
+  if (ORIGINAL_URL === undefined) {
+    delete process.env.CES_CREDENTIAL_URL;
+  } else {
+    process.env.CES_CREDENTIAL_URL = ORIGINAL_URL;
+  }
+  if (ORIGINAL_TOKEN === undefined) {
+    delete process.env.CES_SERVICE_TOKEN;
+  } else {
+    process.env.CES_SERVICE_TOKEN = ORIGINAL_TOKEN;
+  }
+}
+
+function fakeHttpClient(options: {
+  listRecords: () => Promise<{
+    records: Array<{ account: string; record: CredentialRecord }>;
+    unreachable: boolean;
+  }>;
+}) {
+  return {
+    getRecord: async () => ({ record: undefined, unreachable: false }),
+    setRecord: async () => false,
+    deleteRecord: async () => "error" as const,
+    listRecords: options.listRecords,
+    bulkSetRecords: async (records: Array<{ account: string }>) =>
+      records.map((entry) => ({ account: entry.account, ok: false })),
+  };
+}
+
+describe("CES HTTP credential record backend", () => {
+  afterEach(() => {
+    restoreCesHttpEnv();
+  });
+
+  test("factory returns null when the assistant is not containerized", () => {
+    const spy = spyOn(envRegistry, "getIsContainerized").mockReturnValue(false);
+    process.env.CES_CREDENTIAL_URL = "http://ces-container:8090";
+    process.env.CES_SERVICE_TOKEN = "token-123";
+    try {
+      expect(createCesHttpRecordBackendIfConfigured()).toBeNull();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("factory returns null when CES_CREDENTIAL_URL is unset", () => {
+    const spy = spyOn(envRegistry, "getIsContainerized").mockReturnValue(true);
+    delete process.env.CES_CREDENTIAL_URL;
+    process.env.CES_SERVICE_TOKEN = "token-123";
+    try {
+      expect(createCesHttpRecordBackendIfConfigured()).toBeNull();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("factory returns null when CES_SERVICE_TOKEN is unset", () => {
+    const spy = spyOn(envRegistry, "getIsContainerized").mockReturnValue(true);
+    process.env.CES_CREDENTIAL_URL = "http://ces-container:8090";
+    delete process.env.CES_SERVICE_TOKEN;
+    try {
+      expect(createCesHttpRecordBackendIfConfigured()).toBeNull();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("factory returns a backend when containerized with CES HTTP env", () => {
+    const spy = spyOn(envRegistry, "getIsContainerized").mockReturnValue(true);
+    process.env.CES_CREDENTIAL_URL = "http://ces-container:8090";
+    process.env.CES_SERVICE_TOKEN = "token-123";
+    try {
+      const backend = createCesHttpRecordBackendIfConfigured();
+      expect(backend?.name).toBe("ces-http");
+      expect(backend?.isAvailable()).toBe(true);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("list returns records when HTTP reports a reachable catalog", async () => {
+    const record: CredentialRecord = {
+      credentialId: "cred-http",
+      service: "github",
+      field: "token",
+      allowedTools: ["bash"],
+      allowedDomains: [],
+      createdAt: 1,
+      updatedAt: 2,
+    };
+    const backend = new CesHttpRecordBackend(
+      fakeHttpClient({
+        listRecords: async () => ({
+          records: [{ account: "github:token", record }],
+          unreachable: false,
+        }),
+      }),
+    );
+
+    const listed = await backend.list();
+    expect(listed).toEqual([{ account: "github:token", record }]);
+  });
+
+  test("list returns an empty catalog when HTTP is reachable and empty", async () => {
+    const backend = new CesHttpRecordBackend(
+      fakeHttpClient({
+        listRecords: async () => ({ records: [], unreachable: false }),
+      }),
+    );
+
+    const listed = await backend.list();
+    expect(listed).toEqual([]);
+  });
+
+  test("list returns null when HTTP reports the vault unreachable", async () => {
+    const backend = new CesHttpRecordBackend(
+      fakeHttpClient({
+        listRecords: async () => ({ records: [], unreachable: true }),
+      }),
+    );
+
+    expect(await backend.list()).toBeNull();
+  });
+});