@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/desktop/desktop-wallpaper.ts

@@ -1,98 +1,13 @@
-import { readAvatarState } from "../avatar/avatar-manifest.js";
-import {
-  renderNotificationAvatarPng,
-  resolveNotificationAccentHex,
-} from "../avatar/notification-avatar.js";
-import { getResvg, isResvgAvailable } from "../avatar/resvg-lazy.js";
-import { isTemplatePlaceholder } from "../daemon/handlers/identity.js";
-import { getAssistantName } from "../daemon/identity-helpers.js";
-import { escapeXmlContent } from "../util/xml.js";
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
 
-function wallpaperWordmark(
-  width: number,
-  height: number,
-  name: string | null,
-): string {
-  const normalized = name?.replace(/\s+/g, " ").trim();
-  const label =
-    normalized && !isTemplatePlaceholder(normalized) ? normalized : "Vellum";
-  const text = `<text id="wordmark" font-family="Liberation Sans, Arial, sans-serif" font-size="64" font-weight="700" letter-spacing="1.5">${escapeXmlContent(`${label} OS`)}</text>`;
-  const Resvg = getResvg();
-  const bounds = new Resvg(
-    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">${text}</svg>`,
-  ).getBBox();
-  if (!bounds || bounds.width === 0) {
-    return "";
-  }
-  const depth = 6;
-  const scale = Math.min(
-    (height * 0.06) / 64,
-    (width * 0.72) / (bounds.width + depth),
-  );
-  const x = width / 2 - (bounds.x + (bounds.width + depth) / 2) * scale;
-  const layers = Array.from({ length: depth }, (_, index) => {
-    const offset = depth - index;
-    return `<use href="#wordmark" transform="translate(${offset} ${offset})" fill="#40535b"/>`;
-  }).join("");
-  return `<defs>
-    ${text}
-    <linearGradient id="letter-face" x2="0" y2="1">
-      <stop stop-color="#ffffff"/><stop offset=".48" stop-color="#e0e9e7"/>
-      <stop offset="1" stop-color="#9eb4ba"/>
-    </linearGradient>
-  </defs>
-  <g transform="translate(${x} ${height * 0.69}) scale(${scale})">
-    <use href="#wordmark" transform="translate(9 12)" fill="#080f14" opacity=".35"/>
-    ${layers}
-    <use href="#wordmark" fill="url(#letter-face)" stroke="#e8f1ed" stroke-opacity=".4" stroke-width=".5"/>
-  </g>`;
-}
+import { isResvgAvailable } from "../avatar/resvg-lazy.js";
+import { resolveWorkerCommand } from "../util/worker-process.js";
 
-export function renderDesktopWallpaper(
-  width: number,
-  height: number,
-  avatar: Buffer | null,
-  accentHex: string | null,
-  assistantName: string | null = null,
-): Buffer {
-  const accent = /^#[\da-f]{6}$/i.test(accentHex ?? "")
-    ? accentHex!
-    : "#91a6b0";
-  const cx = width / 2;
-  const cy = height * 0.46;
-  const size = Math.min(width, height) * 0.24;
-  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">
-    <defs>
-      <linearGradient id="base" x2="1" y2="1">
-        <stop stop-color="#202a30"/><stop offset="1" stop-color="#10171c"/>
-      </linearGradient>
-      <radialGradient id="glow">
-        <stop stop-color="${accent}" stop-opacity=".24"/>
-        <stop offset="1" stop-color="${accent}" stop-opacity="0"/>
-      </radialGradient>
-      <radialGradient id="shadow">
-        <stop stop-color="#000" stop-opacity=".25"/>
-        <stop offset="1" stop-color="#000" stop-opacity="0"/>
-      </radialGradient>
-    </defs>
-    <path fill="url(#base)" d="M0 0H${width}V${height}H0z"/>
-    <ellipse cx="${cx}" cy="${cy}" rx="${height * 0.7}" ry="${height * 0.6}" fill="url(#glow)"/>
-    <g fill="none" stroke="${accent}">
-      <circle cx="${cx}" cy="${cy}" r="${size * 0.76}" stroke-opacity=".16"/>
-      <circle cx="${cx}" cy="${cy}" r="${size * 1.25}" stroke-opacity=".09"/>
-      <circle cx="${cx}" cy="${cy}" r="${size * 1.9}" stroke-opacity=".05"/>
-    </g>
-    ${
-      avatar
-        ? `<ellipse cx="${cx}" cy="${cy + size * 0.48}" rx="${size * 0.7}" ry="${size * 0.16}" fill="url(#shadow)"/>
-    <image x="${cx - size / 2}" y="${cy - size / 2}" width="${size}" height="${size}" href="data:image/png;base64,${avatar.toString("base64")}"/>`
-        : ""
-    }
-    ${wallpaperWordmark(width, height, assistantName)}
-  </svg>`;
-  const Resvg = getResvg();
-  return Buffer.from(new Resvg(svg).render().asPng());
-}
+const runFile = promisify(execFile);
 
 export async function renderCurrentDesktopWallpaper(
   width: number,
@@ -101,13 +16,30 @@ export async function renderCurrentDesktopWallpaper(
   if (!isResvgAvailable()) {
     return null;
   }
-  const state = readAvatarState();
-  const name = getAssistantName();
-  return renderDesktopWallpaper(
-    width,
-    height,
-    await renderNotificationAvatarPng(state),
-    resolveNotificationAccentHex(state),
-    name,
-  );
+  const directory = await mkdtemp(join(tmpdir(), "vellum-wallpaper-"));
+  const output = join(directory, "wallpaper.png");
+  try {
+    const [executable, ...args] = resolveWorkerCommand(
+      new URL("./desktop-wallpaper-worker.ts", import.meta.url),
+      undefined,
+    );
+    await runFile(
+      executable!,
+      [...args, String(width), String(height), output],
+      {
+        timeout: 30_000,
+        killSignal: "SIGKILL",
+        maxBuffer: 64 * 1024,
+        windowsHide: true,
+      },
+    );
+    return await readFile(output).catch((error: NodeJS.ErrnoException) => {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    });
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
 }

package/src/desktop/desktop-window-theme.ts

@@ -13,24 +13,7 @@ const BUTTON_MASKS = {
   iconify: [0, 0, 0, 0, 0x3ff, 0x3ff, 0, 0, 0, 0],
 };
 
-function windowTheme(accentHex: string | null): string {
-  const tint = (base: string, amount: number): string => {
-    if (!accentHex || !/^#[\da-f]{6}$/i.test(accentHex)) {
-      return base;
-    }
-    return (
-      "#" +
-      [1, 3, 5]
-        .map((offset) => {
-          const from = parseInt(base.slice(offset, offset + 2), 16);
-          const to = parseInt(accentHex.slice(offset, offset + 2), 16);
-          return Math.round(from + (to - from) * amount)
-            .toString(16)
-            .padStart(2, "0");
-        })
-        .join("")
-    );
-  };
+function windowTheme(): string {
   return `
 border.width: 1
 padding.width: 8
@@ -47,17 +30,15 @@ window.*.grip.bg: Flat Solid
 window.*.button.*.bg: Parentrelative
 window.*.button.*.hover.bg: Flat Solid
 window.*.button.*.pressed.bg: Flat Solid
-window.active.title.bg: Flat Gradient Horizontal
-window.active.title.bg.color: ${tint("#292930", 0.28)}
-window.active.title.bg.colorTo: #292930
+window.active.title.bg.color: #292930
 window.active.border.color: #4a4a54
 window.active.title.separator.color: #202026
 window.active.label.text.color: #f0f0f4
 window.active.handle.bg.color: #292930
 window.active.grip.bg.color: #292930
 window.active.button.*.image.color: #d4d4dc
-window.active.button.*.hover.bg.color: ${tint("#45454f", 0.22)}
-window.active.button.*.pressed.bg.color: ${tint("#555561", 0.18)}
+window.active.button.*.hover.bg.color: #45454f
+window.active.button.*.pressed.bg.color: #555561
 window.active.button.*.disabled.image.color: #62626e
 window.active.button.close.hover.bg.color: #b64150
 window.active.button.close.pressed.bg.color: #963442
@@ -97,7 +78,6 @@ osd.label.text.color: #f0f0f4
 export function writeDesktopWindowTheme(
   configDir: string,
   home?: string,
-  accentHex: string | null = null,
 ): string {
   let source: string | undefined;
   let sourcePath = "";
@@ -134,7 +114,7 @@ export function writeDesktopWindowTheme(
   mkdirSync(join(themeDir, "openbox-3"), { recursive: true });
   writeFileSync(
     join(themeDir, "openbox-3", "themerc"),
-    windowTheme(accentHex).trimStart(),
+    windowTheme().trimStart(),
   );
   for (const [name, rows] of Object.entries(BUTTON_MASKS)) {
     const bytes = rows.flatMap((row) => [row & 0xff, row >> 8]);

package/src/desktop/virtual-desktop-feature.ts

@@ -1,18 +1,68 @@
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getIsContainerized, getIsPlatform } from "../config/env-registry.js";
 import type { AssistantConfig } from "../config/schema.js";
+import type { ToolContext } from "../tools/types.js";
 
 const VIRTUAL_DESKTOP_FLAG = "assistant-desktop" as const;
 
+export function isVirtualDesktopPlatform(
+  containerized: boolean = getIsContainerized(),
+  platformHosted: boolean = getIsPlatform(),
+): boolean {
+  return platformHosted && containerized;
+}
+
 /** Gates desktop streaming and control to enabled, platform-hosted containers. */
 export function isVirtualDesktopEnabled(
-  config: AssistantConfig,
+  config?: AssistantConfig,
   containerized: boolean = getIsContainerized(),
   platformHosted: boolean = getIsPlatform(),
 ): boolean {
   return (
-    platformHosted &&
-    containerized &&
+    isVirtualDesktopPlatform(containerized, platformHosted) &&
     isAssistantFeatureFlagEnabled(VIRTUAL_DESKTOP_FLAG, config)
   );
 }
+
+export function canUseVirtualDesktop(
+  context: Pick<ToolContext, "trustClass" | "sourceActorPrincipalId">,
+  enabled: boolean = isVirtualDesktopEnabled(),
+): boolean {
+  return (
+    context.trustClass === "guardian" &&
+    !!context.sourceActorPrincipalId &&
+    enabled
+  );
+}
+
+/** Web browser turns default to the streamed desktop; native apps keep their host. */
+export function shouldUseVirtualDesktop(
+  context: Pick<
+    ToolContext,
+    "transportInterface" | "clientOs" | "trustClass" | "sourceActorPrincipalId"
+  >,
+  enabled: boolean = isVirtualDesktopEnabled(),
+): boolean {
+  return (
+    context.transportInterface === "web" &&
+    context.clientOs !== "macos" &&
+    context.clientOs !== "windows" &&
+    context.clientOs !== "linux" &&
+    canUseVirtualDesktop(context, enabled)
+  );
+}
+
+export function supportsVirtualDesktopComputerUse(toolName: string): boolean {
+  return [
+    "computer_use_observe",
+    "computer_use_click",
+    "computer_use_type_text",
+    "computer_use_key",
+    "computer_use_scroll",
+    "computer_use_drag",
+    "computer_use_wait",
+    "computer_use_sequence",
+    "computer_use_done",
+    "computer_use_respond",
+  ].includes(toolName);
+}

package/src/desktop/virtual-desktop-platform.test.ts

@@ -3,7 +3,7 @@ import { afterEach, beforeEach, expect, spyOn, test } from "bun:test";
 import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
 import { shouldUseVirtualDesktopBrowser } from "../browser/virtual-desktop-target.js";
 import { executeDesktopBrowserOperation } from "./desktop-browser-operations.js";
-import { desktopDependencyInstaller } from "./desktop-dependencies.js";
+import { desktopDependencies } from "./desktop-dependencies.js";
 
 const originalPlatform = process.env.IS_PLATFORM;
 const originalContainerized = process.env.IS_CONTAINERIZED;
@@ -15,15 +15,13 @@ const context = {
   transportInterface: "web" as const,
   clientOs: "web" as const,
 };
-let status: ReturnType<
-  typeof spyOn<typeof desktopDependencyInstaller, "getStatus">
->;
+let status: ReturnType<typeof spyOn<typeof desktopDependencies, "getStatus">>;
 
 beforeEach(() => {
   process.env.IS_CONTAINERIZED = "true";
   process.env.IS_PLATFORM = "false";
   setOverridesForTesting({ "assistant-desktop": true });
-  status = spyOn(desktopDependencyInstaller, "getStatus").mockReturnValue({
+  status = spyOn(desktopDependencies, "getStatus").mockReturnValue({
     state: "ready",
   });
 });
@@ -51,11 +49,9 @@ test("self-hosted Docker cannot automatically select or explicitly control virtu
   expect(status).not.toHaveBeenCalled();
 });
 
-test("platform web conversations select virtual Chrome before and during installation", () => {
+test("platform web conversations select virtual Chrome even when image components are missing", () => {
   process.env.IS_PLATFORM = "true";
   expect(shouldUseVirtualDesktopBrowser(undefined, {}, context)).toBe(true);
-  status.mockReturnValue({ state: "installing" });
-  expect(shouldUseVirtualDesktopBrowser(undefined, {}, context)).toBe(true);
-  status.mockReturnValue({ state: "required" });
+  status.mockReturnValue({ state: "failed" });
   expect(shouldUseVirtualDesktopBrowser(undefined, {}, context)).toBe(true);
 });

package/src/documents/document-store.ts

@@ -5,6 +5,8 @@
  * background jobs (e.g. proactive artifact generation) can persist documents
  * without going through the HTTP layer.
  */
+import { randomUUID } from "node:crypto";
+
 import { rawAll, rawGet, rawRun } from "../persistence/raw-query.js";
 import { getLogger } from "../util/logger.js";
 
@@ -456,6 +458,27 @@ export function saveDocument(params: {
   }
 }
 
+export const DEFAULT_DOCUMENT_TITLE = "Untitled Document";
+
+/**
+ * Create a new document owned by `conversationId` under a freshly minted
+ * surface ID. A missing or empty title falls back to `DEFAULT_DOCUMENT_TITLE`.
+ */
+export function createDocument(params: {
+  conversationId: string;
+  title?: string;
+  content?: string;
+}): ReturnType<typeof saveDocument> {
+  const content = params.content ?? "";
+  return saveDocument({
+    surfaceId: `doc-${randomUUID()}`,
+    conversationId: params.conversationId,
+    title: params.title || DEFAULT_DOCUMENT_TITLE,
+    content,
+    wordCount: countWords(content),
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Find-and-replace
 // ---------------------------------------------------------------------------

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -179,10 +179,20 @@ mock.module("../../credential-health/credential-health-service.js", () => ({
 let heartbeatRunIdCounter = 0;
 let lastRunAtFromHistory: number | null = null;
 const skipHeartbeatRunCalls: Array<{ runId: string; reason: string }> = [];
+const completeHeartbeatRunCalls: Array<{
+  runId: string;
+  result: { status: string; error?: string };
+}> = [];
 mock.module("../heartbeat-run-store.js", () => ({
   insertPendingHeartbeatRun: () => `heartbeat-run-${++heartbeatRunIdCounter}`,
   startHeartbeatRun: () => true,
-  completeHeartbeatRun: () => true,
+  completeHeartbeatRun: (
+    runId: string,
+    result: { status: string; error?: string },
+  ) => {
+    completeHeartbeatRunCalls.push({ runId, result });
+    return true;
+  },
   skipHeartbeatRun: (runId: string, reason: string) => {
     skipHeartbeatRunCalls.push({ runId, reason });
   },
@@ -226,6 +236,7 @@ beforeEach(() => {
   onBroadcast = null;
   runBackgroundJobCalls.length = 0;
   skipHeartbeatRunCalls.length = 0;
+  completeHeartbeatRunCalls.length = 0;
   lastRunAtFromHistory = null;
   preFirstMessageGateOpen = true;
   seedHeartbeat();
@@ -340,14 +351,9 @@ describe("HeartbeatService", () => {
     await service.runOnce({ force: true });
 
     expect(runnerCompleted).toBe(true);
-    // No heartbeat_alert broadcast because the runner returned ok=true and
-    // there was no outer-timeout failure to surface.
-    expect(
-      broadcastedMessages.filter((m) => m.type === "heartbeat_alert"),
-    ).toHaveLength(0);
   });
 
-  test("calls alerter with the failure message when the runner reports ok=false", async () => {
+  test("records the failure on the run when the runner reports ok=false", async () => {
     runBackgroundJobImpl = async () => ({
       conversationId: STUB_CONVERSATION_ID,
       ok: false,
@@ -359,25 +365,15 @@ describe("HeartbeatService", () => {
 
     await service.runOnce({ force: true });
 
-    const alerts = broadcastedMessages.filter(
-      (m) => m.type === "heartbeat_alert",
-    );
-    expect(alerts).toHaveLength(1);
-    expect(alerts[0]).toMatchObject({
-      type: "heartbeat_alert",
-      title: "Heartbeat Failed",
-      body: "LLM call failed",
-    });
-  });
-
-  test("does not call alerter when the runner reports ok=true", async () => {
-    const service = new HeartbeatService();
-
-    await service.runOnce({ force: true });
-
-    expect(
-      broadcastedMessages.filter((m) => m.type === "heartbeat_alert"),
-    ).toHaveLength(0);
+    expect(completeHeartbeatRunCalls).toEqual([
+      {
+        runId: expect.any(String),
+        result: expect.objectContaining({
+          status: "error",
+          error: "LLM call failed",
+        }),
+      },
+    ]);
   });
 
   test("scheduled run skips with reason 'pre_first_user_message' when the user has not yet interacted", async () => {

package/src/heartbeat/heartbeat-service.ts

@@ -3,7 +3,6 @@ import { join } from "node:path";
 
 import { channelForBotProvider } from "@vellumai/service-contracts/channels";
 
-import type { HeartbeatAlertEvent } from "../api/events/heartbeat-alert.js";
 import { getConfig } from "../config/loader.js";
 import type { HeartbeatConfig } from "../config/schemas/heartbeat.js";
 import { warmGuardianBindings } from "../contacts/guardian-delivery-reader.js";
@@ -737,17 +736,6 @@ export class HeartbeatService {
       }
     } catch (err) {
       log.error({ err }, "Credential health check failed");
-      try {
-        broadcastMessage({
-          type: "heartbeat_alert",
-          title: "Credential Health Check Failed",
-          body:
-            "Could not verify OAuth credential health. " +
-            (err instanceof Error ? err.message : String(err)),
-        } satisfies HeartbeatAlertEvent);
-      } catch {
-        // Last resort — alerter itself failed. Already logged above.
-      }
     }
     return [];
   }
@@ -912,32 +900,16 @@ export class HeartbeatService {
       "Heartbeat failed",
     );
 
-    // The runner has already emitted `activity.failed` for the failure;
-    // we still record the run-level error and broadcast the in-app
-    // heartbeat alert so the existing surfacing keeps working.
-    // Map the runner's error classification onto the run-store's status
-    // enum so the run history preserves the timeout / error distinction.
+    // The runner has already emitted `activity.failed` for the failure, so
+    // this only records the run-level error. Map the runner's error
+    // classification onto the run-store's status enum so the run history
+    // preserves the timeout / error distinction.
     const runStatus = result.errorKind === "timeout" ? "timeout" : "error";
-    const transitioned = completeHeartbeatRun(runId, {
+    completeHeartbeatRun(runId, {
       status: runStatus,
       conversationId: conversationId ?? result.conversationId,
       error: result.error?.message ?? "Unknown error",
     });
-
-    // Only fire the in-app alerter when our completion is the one that
-    // actually wrote — otherwise a parallel finalizer (e.g. a startup
-    // recovery sweep) already alerted for this run.
-    if (transitioned) {
-      try {
-        broadcastMessage({
-          type: "heartbeat_alert",
-          title: "Heartbeat Failed",
-          body: result.error?.message ?? "Unknown error",
-        } satisfies HeartbeatAlertEvent);
-      } catch (alertErr) {
-        log.error({ alertErr }, "Failed to broadcast heartbeat alert");
-      }
-    }
   }
 
   private readChecklist(): string {