@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/desktop/desktop-stream-bridge.test.ts

@@ -1,10 +1,11 @@
+import * as fs from "node:fs";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, describe, expect, test } from "bun:test";
+import { afterAll, describe, expect, mock, spyOn, test } from "bun:test";
 
+import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
 import { newFakeDesktop, newViewer, settle } from "./__tests__/fake-desktop.js";
-import { DesktopDependencyInstaller } from "./desktop-dependencies.js";
 import {
   type DesktopSessionManager,
   type DesktopTcpHandlers,
@@ -13,6 +14,7 @@ import {
   getDesktopSessionManager,
 } from "./desktop-session-manager.js";
 import { DesktopStreamBridge } from "./desktop-stream-bridge.js";
+import { isVirtualDesktopEnabled } from "./virtual-desktop-feature.js";
 
 const profileDir = mkdtempSync(join(tmpdir(), "desktop-bridge-test-"));
 afterAll(() => {
@@ -54,7 +56,7 @@ class FakeTcp implements DesktopTcpSocket {
 
 function newBridge(
   manager: DesktopSessionManager,
-  ensureInstalled: () => Promise<void> = async () => {},
+  assertReady: () => void = () => {},
   isEnabled: () => boolean = () => true,
 ) {
   const ws = new FakeWs();
@@ -65,7 +67,7 @@ function newBridge(
   });
   const bridge = new DesktopStreamBridge(ws, {
     manager,
-    ensureInstalled,
+    assertReady,
     isEnabled,
     connect: async (_port, handlers) => {
       tcp.handlers = handlers;
@@ -87,61 +89,94 @@ function slotIsFree(manager: DesktopSessionManager): boolean {
 }
 
 describe("DesktopStreamBridge", () => {
-  test("refuses a disabled desktop before installation or process startup", async () => {
+  test("streams without flag or filesystem checks after connecting", async () => {
+    const originalContainerized = process.env.IS_CONTAINERIZED;
+    const originalPlatform = process.env.IS_PLATFORM;
     const h = newFakeDesktop({ profileDir });
-    let installs = 0;
+    const isEnabled = mock(isVirtualDesktopEnabled);
+    const b = newBridge(h.manager, async () => {}, isEnabled);
+    process.env.IS_CONTAINERIZED = "true";
+    process.env.IS_PLATFORM = "true";
+    setOverridesForTesting({ "assistant-desktop": true });
+    try {
+      b.connectNow();
+      await b.bridge.start();
+      expect(isEnabled).toHaveBeenCalled();
+      isEnabled.mockClear();
+      const stat = spyOn(fs, "statSync");
+      const read = spyOn(fs, "readFileSync");
+      try {
+        const frame = new Uint8Array([1, 2, 3]);
+        for (let i = 0; i < 100; i++) {
+          b.bridge.handleClientFrame(frame);
+          b.tcp.handlers.onData(frame);
+          b.tcp.handlers.onDrain();
+        }
+        expect(b.tcp.writes).toHaveLength(100);
+        expect(b.ws.sent).toHaveLength(100);
+        setOverridesForTesting({ "assistant-desktop": false });
+        b.bridge.handleClientFrame(frame);
+        b.tcp.handlers.onData(frame);
+        b.tcp.handlers.onDrain();
+        expect(b.tcp.writes).toHaveLength(101);
+        expect(b.ws.sent).toHaveLength(101);
+        expect(b.ws.closeCode).toBeNull();
+        expect(b.tcp.ended).toBe(false);
+        expect(isEnabled).not.toHaveBeenCalled();
+        expect(stat).not.toHaveBeenCalled();
+        expect(read).not.toHaveBeenCalled();
+      } finally {
+        stat.mockRestore();
+        read.mockRestore();
+      }
+    } finally {
+      b.bridge.handleClose();
+      await h.manager.destroy();
+      setOverridesForTesting({});
+      if (originalContainerized === undefined) {
+        delete process.env.IS_CONTAINERIZED;
+      } else {
+        process.env.IS_CONTAINERIZED = originalContainerized;
+      }
+      if (originalPlatform === undefined) {
+        delete process.env.IS_PLATFORM;
+      } else {
+        process.env.IS_PLATFORM = originalPlatform;
+      }
+    }
+  });
+
+  test("refuses a disabled desktop before checking components or starting processes", async () => {
+    const h = newFakeDesktop({ profileDir });
+    let checks = 0;
     const b = newBridge(
       h.manager,
       async () => {
-        installs++;
+        checks++;
       },
       () => false,
     );
     await b.bridge.start();
     expect(b.ws.closeCode).toBe(4008);
-    expect(installs).toBe(0);
+    expect(checks).toBe(0);
     expect(h.spawned).toEqual([]);
     expect(slotIsFree(h.manager)).toBe(true);
   });
 
-  test("does not start the desktop when disabled during installation", async () => {
-    const h = newFakeDesktop({ profileDir });
-    let enabled = true;
-    const install = Promise.withResolvers<void>();
-    const b = newBridge(
-      h.manager,
-      () => install.promise,
-      () => enabled,
-    );
-    const started = b.bridge.start();
-    enabled = false;
-    install.resolve();
-    await started;
-    expect(b.ws.closeCode).toBe(4008);
-    expect(slotIsFree(h.manager)).toBe(true);
-    expect(b.tcp.handlers).toBeUndefined();
-    expect(h.spawned).toEqual([]);
-  });
-
   for (const direction of ["viewer", "desktop"] as const) {
-    test(`blocks ${direction} frames when the flag is disabled after connection`, async () => {
+    test(`ignores ${direction} frames after the stream closes`, async () => {
       const h = newFakeDesktop({ profileDir });
-      let enabled = true;
-      const b = newBridge(
-        h.manager,
-        async () => {},
-        () => enabled,
-      );
+      const b = newBridge(h.manager);
       b.connectNow();
       await b.bridge.start();
-      enabled = false;
+      b.bridge.handleClose();
       const frame = new Uint8Array([1, 2, 3]);
       if (direction === "viewer") {
         b.bridge.handleClientFrame(frame);
       } else {
         b.tcp.handlers.onData(frame);
       }
-      expect(b.ws.closeCode).toBe(4008);
+      expect(b.ws.closeCode).toBeNull();
       expect(b.ws.sent).toHaveLength(0);
       expect(b.tcp.writes).toHaveLength(0);
       expect(b.tcp.ended).toBe(true);
@@ -150,106 +185,15 @@ describe("DesktopStreamBridge", () => {
     });
   }
 
-  test("direct viewers share background setup across a timeout and reconnect", async () => {
-    const h = newFakeDesktop({ profileDir });
-    let ready = false;
-    let installs = 0;
-    const install = Promise.withResolvers<void>();
-    const installer = new DesktopDependencyInstaller({
-      supported: () => true,
-      ready: () => ready,
-      install: async () => {
-        installs++;
-        await install.promise;
-        ready = true;
-      },
-      notify: async () => {},
-    });
-    const ensureInstalled = () => installer.ensureReady();
-    const first = newBridge(h.manager, ensureInstalled);
-    const firstStart = first.bridge.start();
-    await settle();
-    expect(installs).toBe(1);
-    expect(h.spawned).toEqual([]);
-
-    const busy = newBridge(h.manager, async () => {
-      throw new Error("A rejected viewer must not start setup");
-    });
-    await busy.bridge.start();
-    expect(busy.ws.closeCode).toBe(4013);
-
-    first.bridge.handleClose();
-    expect(slotIsFree(h.manager)).toBe(true);
-    const retry = newBridge(h.manager, ensureInstalled);
-    const retryStart = retry.bridge.start();
-    await settle();
-    expect(installs).toBe(1);
-    expect(h.spawned).toEqual([]);
-
-    install.resolve();
-    retry.connectNow();
-    await Promise.all([firstStart, retryStart]);
-    expect(retry.ws.closeCode).toBeNull();
-    expect(h.spawned.length).toBeGreaterThan(0);
-    retry.tcp.handlers.onData(new Uint8Array([1, 2, 3]));
-    expect(retry.ws.sent).toEqual([new Uint8Array([1, 2, 3])]);
-    expect(first.ws.sent).toEqual([]);
-    expect(first.tcp.handlers).toBeUndefined();
-    retry.bridge.handleClose();
-  });
-
-  test("setup continues after the last viewer closes without starting a desktop", async () => {
+  test("missing image components release the viewer slot without starting processes", async () => {
     const h = newFakeDesktop({ profileDir });
-    const install = Promise.withResolvers<void>();
-    const b = newBridge(h.manager, () => install.promise);
-    const started = b.bridge.start();
-    b.bridge.handleClose();
-    install.resolve();
-    await started;
-    expect(h.spawned).toEqual([]);
-    expect(slotIsFree(h.manager)).toBe(true);
-  });
-
-  test("setup failure releases the slot and permits a successful retry", async () => {
-    const h = newFakeDesktop({ profileDir });
-    let ready = false;
-    let attempts = 0;
-    const installer = new DesktopDependencyInstaller({
-      supported: () => true,
-      ready: () => ready,
-      install: async () => {
-        if (++attempts === 1) {
-          throw new Error("Download failed");
-        }
-        ready = true;
-      },
-      notify: async () => {},
+    const b = newBridge(h.manager, () => {
+      throw new Error("Missing image components");
     });
-    const ensureInstalled = () => installer.ensureReady();
-    const first = newBridge(h.manager, ensureInstalled);
-    await first.bridge.start();
-    expect(first.ws.closeCode).toBe(4011);
+    await b.bridge.start();
+    expect(b.ws.closeCode).toBe(4011);
     expect(slotIsFree(h.manager)).toBe(true);
     expect(h.spawned).toEqual([]);
-
-    const retry = newBridge(h.manager, ensureInstalled);
-    retry.connectNow();
-    await retry.bridge.start();
-    expect(attempts).toBe(2);
-    expect(retry.ws.closeCode).toBeNull();
-    retry.bridge.handleClose();
-  });
-
-  test("shutdown during setup closes the viewer without starting a desktop", async () => {
-    const h = newFakeDesktop({ profileDir });
-    const install = Promise.withResolvers<void>();
-    const b = newBridge(h.manager, () => install.promise);
-    const started = b.bridge.start();
-    await h.manager.destroy();
-    expect(b.ws.closeCode).toBe(1001);
-    install.resolve();
-    await started;
-    expect(h.spawned).toEqual([]);
     expect(b.tcp.handlers).toBeUndefined();
   });
 

package/src/desktop/desktop-stream-bridge.ts

@@ -4,7 +4,7 @@
  * are signaled with close codes only (see `DESKTOP_CLOSE`).
  */
 
-import { desktopDependencyInstaller } from "./desktop-dependencies.js";
+import { desktopDependencies } from "./desktop-dependencies.js";
 import {
   connectLoopback,
   DESKTOP_CLOSE,
@@ -31,7 +31,7 @@ interface DesktopStreamClientSocket {
 interface DesktopStreamBridgeOptions {
   readonly isEnabled: () => boolean;
   readonly manager?: DesktopSessionManager;
-  readonly ensureInstalled?: () => Promise<void>;
+  readonly assertReady?: () => void;
   readonly connect?: (
     port: number,
     handlers: DesktopTcpHandlers,
@@ -42,7 +42,7 @@ export class DesktopStreamBridge {
   private readonly ws: DesktopStreamClientSocket;
   private readonly isEnabled: () => boolean;
   private readonly manager: DesktopSessionManager;
-  private readonly ensureInstalled: () => Promise<void>;
+  private readonly assertReady: () => void;
   private readonly connect: NonNullable<DesktopStreamBridgeOptions["connect"]>;
   private readonly viewer: DesktopViewer;
 
@@ -60,9 +60,8 @@ export class DesktopStreamBridge {
     this.ws = ws;
     this.isEnabled = options.isEnabled;
     this.manager = options.manager ?? getDesktopSessionManager();
-    this.ensureInstalled =
-      options.ensureInstalled ??
-      (() => desktopDependencyInstaller.ensureReady());
+    this.assertReady =
+      options.assertReady ?? (() => desktopDependencies.assertReady());
     this.connect = options.connect ?? connectLoopback;
     this.viewer = { onDesktopLost: (loss) => this.lose(loss) };
   }
@@ -80,8 +79,7 @@ export class DesktopStreamBridge {
     this.ownsSlot = true;
 
     try {
-      // Direct viewers share setup with the modal, including across reconnects.
-      await this.ensureInstalled();
+      this.assertReady();
       if (!this.checkEnabled()) {
         return;
       }
@@ -102,7 +100,7 @@ export class DesktopStreamBridge {
     try {
       tcp = await this.connect(DESKTOP_VNC_PORT, {
         onData: (data) => {
-          if (!this.checkEnabled()) {
+          if (this.closed) {
             return;
           }
           if (this.ws.send(data) === 0) {
@@ -128,7 +126,7 @@ export class DesktopStreamBridge {
   }
 
   handleClientFrame(message: string | Uint8Array | ArrayBuffer): void {
-    if (!this.checkEnabled() || typeof message === "string") {
+    if (this.closed || typeof message === "string") {
       return;
     }
     const bytes =
@@ -148,7 +146,7 @@ export class DesktopStreamBridge {
   }
 
   private flush(): void {
-    if (!this.checkEnabled()) {
+    if (this.closed) {
       return;
     }
     const tcp = this.tcp;

package/src/desktop/desktop-wallpaper-renderer.ts

@@ -0,0 +1,132 @@
+import { readAvatarState } from "../avatar/avatar-manifest.js";
+import { readContainedAvatarRaster } from "../avatar/ensure-raster.js";
+import {
+  renderNotificationAvatarPng,
+  resolveNotificationAccentHex,
+} from "../avatar/notification-avatar.js";
+import { renderCharacterPng } from "../avatar/png-renderer.js";
+import { getResvg, isResvgAvailable } from "../avatar/resvg-lazy.js";
+import { isTemplatePlaceholder } from "../daemon/handlers/identity.js";
+import { getAssistantName } from "../daemon/identity-helpers.js";
+import { getLogger } from "../util/logger.js";
+import { getAvatarImagePath } from "../util/platform.js";
+import { escapeXmlContent } from "../util/xml.js";
+
+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>`;
+}
+
+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());
+}
+
+export async function renderCurrentDesktopWallpaper(
+  width: number,
+  height: number,
+): Promise<Buffer | null> {
+  if (!isResvgAvailable()) {
+    return null;
+  }
+  const state = readAvatarState();
+  const name = getAssistantName();
+  let raster = readContainedAvatarRaster(getAvatarImagePath());
+  if (!raster && state.kind === "character" && state.traits) {
+    try {
+      raster = renderCharacterPng(
+        state.traits.bodyShape,
+        state.traits.eyeStyle,
+        state.traits.color,
+      );
+    } catch (err) {
+      getLogger("desktop-wallpaper").warn(
+        { err },
+        "Could not render wallpaper avatar",
+      );
+    }
+  }
+  return renderDesktopWallpaper(
+    width,
+    height,
+    raster ? await renderNotificationAvatarPng(state, raster) : null,
+    resolveNotificationAccentHex(state),
+    name,
+  );
+}

package/src/desktop/desktop-wallpaper-worker.ts

@@ -0,0 +1,17 @@
+import { writeFile } from "node:fs/promises";
+
+import { renderCurrentDesktopWallpaper } from "./desktop-wallpaper-renderer.js";
+
+const [width, height, output] = process.argv.slice(2);
+if (
+  !output ||
+  !Number.isFinite(Number(width)) ||
+  !Number.isFinite(Number(height))
+) {
+  throw new Error("Wallpaper dimensions and output path are required");
+}
+const png = await renderCurrentDesktopWallpaper(Number(width), Number(height));
+if (png) {
+  await writeFile(output, png);
+}
+process.exit(0);

package/src/desktop/desktop-wallpaper.test.ts

@@ -1,18 +1,36 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, expect, test } from "bun:test";
+import {
+  afterEach,
+  beforeEach,
+  expect,
+  mock,
+  setDefaultTimeout,
+  test,
+} from "bun:test";
 
 import sharp from "sharp";
 
 import {
   __resetResvgCacheForTests,
   __setResvgCacheForTests,
+  getResvg,
 } from "../avatar/resvg-lazy.js";
-import {
-  renderCurrentDesktopWallpaper,
-  renderDesktopWallpaper,
-} from "./desktop-wallpaper.js";
+import { renderCurrentDesktopWallpaper } from "./desktop-wallpaper.js";
+import { renderDesktopWallpaper } from "./desktop-wallpaper-renderer.js";
+
+// Native resvg renders scan the system font database per instance, and on a
+// loaded CI runner the file's first render runs past bun's 5s default. Each
+// test file runs in its own process, so this doesn't leak.
+setDefaultTimeout(15_000);
 
 let workspace: string;
 let previousWorkspace: string | undefined;
@@ -70,7 +88,7 @@ test("renders the current uploaded avatar into an opaque desktop wallpaper", asy
   expect((await sharp(result).stats()).isOpaque).toBe(true);
 });
 
-test("regenerates a character from current traits when its raster is missing", async () => {
+test("renders a missing character raster without changing persisted avatar files", async () => {
   manifest({
     kind: "character",
     source: "pool",
@@ -78,9 +96,18 @@ test("regenerates a character from current traits when its raster is missing", a
     image: null,
     accent: null,
   });
+  const avatarDir = join(workspace, "data/avatar");
+  writeFileSync(join(avatarDir, "character-traits.json"), "preserve traits");
+  writeFileSync(join(avatarDir, "character-ascii.txt"), "preserve ASCII");
+  const snapshot = () =>
+    readdirSync(avatarDir)
+      .sort()
+      .map((file) => [file, readFileSync(join(avatarDir, file))]);
+  const before = snapshot();
   const result = (await renderCurrentDesktopWallpaper(480, 300))!;
   const empty = renderDesktopWallpaper(480, 300, null, null);
   expect(await centerPixel(result)).not.toEqual(await centerPixel(empty));
+  expect(snapshot()).toEqual(before);
 });
 
 test("missing and unreadable avatars produce the same neutral background", async () => {
@@ -189,3 +216,17 @@ test("names containing XML are rendered as text without injecting SVG shapes", a
   );
   expect((await wordmarkPixels(png)).length).toBeGreaterThan(0);
 });
+
+test("renders in a child without invoking the assistant's native rasterizer", async () => {
+  const render = mock(() => {
+    throw new Error("Rendering must not run on the assistant event loop");
+  });
+  __setResvgCacheForTests({
+    available: true,
+    Resvg: render as unknown as ReturnType<typeof getResvg>,
+  });
+  const png = await renderCurrentDesktopWallpaper(1600, 900);
+  expect(render).not.toHaveBeenCalled();
+  const metadata = await sharp(png!).metadata();
+  expect([metadata.width, metadata.height]).toEqual([1600, 900]);
+});