@vellumai/assistant 0.12.1 → 0.12.2-staging.2

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

@@ -0,0 +1,191 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, expect, test } from "bun:test";
+
+import sharp from "sharp";
+
+import {
+  __resetResvgCacheForTests,
+  __setResvgCacheForTests,
+} from "../avatar/resvg-lazy.js";
+import {
+  renderCurrentDesktopWallpaper,
+  renderDesktopWallpaper,
+} from "./desktop-wallpaper.js";
+
+let workspace: string;
+let previousWorkspace: string | undefined;
+beforeEach(() => {
+  workspace = mkdtempSync(join(tmpdir(), "desktop-wallpaper-test-"));
+  previousWorkspace = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = workspace;
+  mkdirSync(join(workspace, "data/avatar"), { recursive: true });
+});
+afterEach(() => {
+  __resetResvgCacheForTests();
+  if (previousWorkspace === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = previousWorkspace;
+  }
+  rmSync(workspace, { recursive: true, force: true });
+});
+
+function manifest(state: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspace, "data/avatar/avatar.json"),
+    JSON.stringify(state),
+  );
+}
+
+async function centerPixel(png: Buffer): Promise<number[]> {
+  const { data, info } = await sharp(png)
+    .ensureAlpha()
+    .raw()
+    .toBuffer({ resolveWithObject: true });
+  const offset =
+    (Math.round(info.height * 0.46) * info.width + info.width / 2) * 4;
+  return [...data.subarray(offset, offset + 4)];
+}
+
+test("renders the current uploaded avatar into an opaque desktop wallpaper", async () => {
+  const png = await sharp({
+    create: { width: 32, height: 32, channels: 4, background: "#ff0000" },
+  })
+    .png()
+    .toBuffer();
+  writeFileSync(join(workspace, "data/avatar/avatar-image.png"), png);
+  manifest({
+    kind: "image",
+    source: "upload",
+    traits: null,
+    image: { updatedAt: "2026-01-01T00:00:00Z", etag: "test" },
+    accent: null,
+  });
+  const result = (await renderCurrentDesktopWallpaper(480, 300))!;
+  expect(await centerPixel(result)).toEqual([255, 0, 0, 255]);
+  const metadata = await sharp(result).metadata();
+  expect([metadata.width, metadata.height]).toEqual([480, 300]);
+  expect((await sharp(result).stats()).isOpaque).toBe(true);
+});
+
+test("regenerates a character from current traits when its raster is missing", async () => {
+  manifest({
+    kind: "character",
+    source: "pool",
+    traits: { bodyShape: "blob", eyeStyle: "curious", color: "green" },
+    image: null,
+    accent: null,
+  });
+  const result = (await renderCurrentDesktopWallpaper(480, 300))!;
+  const empty = renderDesktopWallpaper(480, 300, null, null);
+  expect(await centerPixel(result)).not.toEqual(await centerPixel(empty));
+});
+
+test("missing and unreadable avatars produce the same neutral background", async () => {
+  const missing = await renderCurrentDesktopWallpaper(480, 300);
+  manifest({
+    kind: "image",
+    source: "upload",
+    traits: null,
+    image: { updatedAt: "2026-01-01T00:00:00Z", etag: "test" },
+    accent: null,
+  });
+  writeFileSync(
+    join(workspace, "data/avatar/avatar-image.png"),
+    "not an image",
+  );
+  expect(await renderCurrentDesktopWallpaper(480, 300)).toEqual(missing);
+  expect((await sharp(missing!).stats()).isOpaque).toBe(true);
+});
+
+test("accent changes tint the background and malformed accents fall back safely", async () => {
+  const neutral = renderDesktopWallpaper(480, 300, null, null);
+  expect(
+    renderDesktopWallpaper(480, 300, null, '\"/><image href="file:///test"/>'),
+  ).toEqual(neutral);
+  const red = await centerPixel(
+    renderDesktopWallpaper(480, 300, null, "#ff0000"),
+  );
+  const blue = await centerPixel(
+    renderDesktopWallpaper(480, 300, null, "#0000ff"),
+  );
+  expect(red[0]!).toBeGreaterThan(blue[0]!);
+  expect(blue[2]!).toBeGreaterThan(red[2]!);
+});
+
+test("a missing native renderer leaves the existing desktop background alone", async () => {
+  __setResvgCacheForTests({
+    available: false,
+    error: new Error("unavailable"),
+  });
+  expect(await renderCurrentDesktopWallpaper(480, 300)).toBeNull();
+});
+
+async function wordmarkPixels(
+  png: Buffer,
+): Promise<{ x: number; y: number }[]> {
+  const { data, info } = await sharp(png)
+    .removeAlpha()
+    .raw()
+    .toBuffer({ resolveWithObject: true });
+  const pixels: { x: number; y: number }[] = [];
+  for (let y = 0; y < info.height; y++) {
+    for (let x = 0; x < info.width; x++) {
+      const offset = (y * info.width + x) * info.channels;
+      if (
+        data[offset]! > 150 &&
+        data[offset + 1]! > 150 &&
+        data[offset + 2]! > 150
+      ) {
+        pixels.push({ x, y });
+      }
+    }
+  }
+  return pixels;
+}
+
+test("renders the current identity name and picks up a rename on the next refresh", async () => {
+  const identity = join(workspace, "IDENTITY.md");
+  writeFileSync(identity, "- **Name:** Alice\n");
+  const first = (await renderCurrentDesktopWallpaper(480, 300))!;
+  expect(first).toEqual(renderDesktopWallpaper(480, 300, null, null, "Alice"));
+  const pixels = await wordmarkPixels(first);
+  expect(pixels.length).toBeGreaterThan(100);
+  expect(pixels.every(({ y }) => y > 300 * 0.6 && y < 300 * 0.72)).toBe(true);
+
+  writeFileSync(identity, "- **Name:** Bob\n");
+  const renamed = await renderCurrentDesktopWallpaper(480, 300);
+  expect(renamed).not.toEqual(first);
+  expect(renamed).toEqual(renderDesktopWallpaper(480, 300, null, null, "Bob"));
+});
+
+test("an unset or template identity displays Vellum OS", async () => {
+  const fallback = renderDesktopWallpaper(480, 300, null, null, "Vellum");
+  expect(await renderCurrentDesktopWallpaper(480, 300)).toEqual(fallback);
+  writeFileSync(
+    join(workspace, "IDENTITY.md"),
+    "- **Name:** _(not yet chosen)_\n",
+  );
+  expect(await renderCurrentDesktopWallpaper(480, 300)).toEqual(fallback);
+});
+
+test("long names fit inside the wallpaper without losing the wordmark", async () => {
+  const png = renderDesktopWallpaper(480, 300, null, null, "W".repeat(32));
+  const pixels = await wordmarkPixels(png);
+  expect(pixels.length).toBeGreaterThan(100);
+  expect(pixels.every(({ x }) => x > 480 * 0.13 && x < 480 * 0.87)).toBe(true);
+});
+
+test("names containing XML are rendered as text without injecting SVG shapes", async () => {
+  const name =
+    'Alice & </text><rect width="480" height="300" fill="red"/><text>';
+  const png = renderDesktopWallpaper(480, 300, null, null, name);
+  const fallback = renderDesktopWallpaper(480, 300, null, null);
+  const top = { left: 0, top: 0, width: 480, height: 150 };
+  expect(await sharp(png).extract(top).raw().toBuffer()).toEqual(
+    await sharp(fallback).extract(top).raw().toBuffer(),
+  );
+  expect((await wordmarkPixels(png)).length).toBeGreaterThan(0);
+});

package/src/desktop/desktop-wallpaper.ts

@@ -0,0 +1,113 @@
+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";
+
+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();
+  return renderDesktopWallpaper(
+    width,
+    height,
+    await renderNotificationAvatarPng(state),
+    resolveNotificationAccentHex(state),
+    name,
+  );
+}

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

@@ -0,0 +1,177 @@
+/** Restore maximized windows when clients request a title-bar drag. */
+export const DESKTOP_WINDOW_DRAG_SCRIPT = String.raw`import ctypes as C
+import select
+import signal
+import subprocess
+import sys
+import time
+
+
+class MessageData(C.Union):
+    _fields_ = [('bytes', C.c_char * 20), ('shorts', C.c_short * 10), ('longs', C.c_long * 5)]
+
+
+class ClientMessage(C.Structure):
+    _fields_ = [('type', C.c_int), ('serial', C.c_ulong), ('sent', C.c_int),
+                ('display', C.c_void_p), ('window', C.c_ulong), ('atom', C.c_ulong),
+                ('format', C.c_int), ('data', MessageData)]
+
+
+class Event(C.Union):
+    _fields_ = [('message', ClientMessage), ('padding', C.c_long * 24)]
+
+
+X = C.CDLL('libX11.so.6')
+P = C.POINTER
+U = C.c_ulong
+I = C.c_int
+D = C.c_void_p
+
+
+def bind(name, result, *args):
+    function = getattr(X, name)
+    function.restype = result
+    function.argtypes = args
+    return function
+
+
+open_display = bind('XOpenDisplay', D, C.c_char_p)
+close_display = bind('XCloseDisplay', I, D)
+root_window = bind('XDefaultRootWindow', U, D)
+intern = bind('XInternAtom', U, D, C.c_char_p, I)
+select_input = bind('XSelectInput', I, D, U, C.c_long)
+flush = bind('XFlush', I, D)
+pending = bind('XPending', I, D)
+next_event = bind('XNextEvent', I, D, P(Event))
+connection = bind('XConnectionNumber', I, D)
+send_event = bind('XSendEvent', I, D, U, I, C.c_long, P(Event))
+get_property = bind('XGetWindowProperty', I, D, U, U, C.c_long, C.c_long, I, U,
+                    P(U), P(I), P(U), P(U), P(P(C.c_ubyte)))
+free = bind('XFree', I, D)
+get_geometry = bind('XGetGeometry', I, D, U, P(U), P(I), P(I), P(C.c_uint),
+                    P(C.c_uint), P(C.c_uint), P(C.c_uint))
+translate = bind('XTranslateCoordinates', I, D, U, U, I, I, P(I), P(I), P(U))
+query_pointer = bind('XQueryPointer', I, D, U, P(U), P(U), P(I), P(I), P(I), P(I), P(C.c_uint))
+
+# Windows can close between receiving a move request and reading their state.
+error_handler_type = C.CFUNCTYPE(I, D, D)
+error_handler = error_handler_type(lambda display, error: 0)
+bind('XSetErrorHandler', D, error_handler_type)(error_handler)
+display = open_display(None)
+if not display:
+    raise RuntimeError('Cannot connect to the desktop display')
+root = root_window(display)
+move_atom = intern(display, b'_NET_WM_MOVERESIZE', 0)
+position_atom = intern(display, b'_NET_MOVERESIZE_WINDOW', 0)
+state_atom = intern(display, b'_NET_WM_STATE', 0)
+max_h = intern(display, b'_NET_WM_STATE_MAXIMIZED_HORZ', 0)
+max_v = intern(display, b'_NET_WM_STATE_MAXIMIZED_VERT', 0)
+notify_mask = 1 << 19
+redirect_mask = 1 << 20
+
+
+def maximized(window):
+    actual, count, remaining = U(), U(), U()
+    format = I()
+    data = P(C.c_ubyte)()
+    status = get_property(display, window, state_atom, 0, 64, 0, 0,
+                          C.byref(actual), C.byref(format), C.byref(count),
+                          C.byref(remaining), C.byref(data))
+    try:
+        if status or format.value != 32 or not data:
+            return False
+        values = C.cast(data, P(U))
+        return any(values[i] in (max_h, max_v) for i in range(count.value))
+    finally:
+        if data:
+            free(data)
+
+
+def geometry(window):
+    parent, child = U(), U()
+    x, y = I(), I()
+    width, height, border, depth = (C.c_uint() for _ in range(4))
+    if not get_geometry(display, window, C.byref(parent), C.byref(x), C.byref(y),
+                        C.byref(width), C.byref(height), C.byref(border), C.byref(depth)):
+        return None
+    if not translate(display, window, root, 0, 0, C.byref(x), C.byref(y), C.byref(child)):
+        return None
+    return x.value, y.value, width.value, height.value
+
+
+def send(window, atom, values):
+    event = Event()
+    event.message.type = 33
+    event.message.display = display
+    event.message.window = window
+    event.message.atom = atom
+    event.message.format = 32
+    event.message.data.longs[:] = values
+    send_event(display, root, 0, notify_mask | redirect_mask, C.byref(event))
+    flush(display)
+
+
+def restore_drag(message):
+    values = message.data.longs
+    # Chrome leaves the button unspecified; source 2 marks our continuation.
+    if message.format != 32 or values[2] != 8 or values[3] not in (0, 1) or values[4] == 2:
+        return
+    window = message.window
+    if not maximized(window):
+        return
+    before = geometry(window)
+    if not before or not before[2]:
+        return
+    fraction = max(0, min(1, (values[0] - before[0]) / before[2]))
+    offset_y = values[1] - before[1]
+    send(window, move_atom, [values[0], values[1], 11, 0, 2])
+    send(window, state_atom, [0, max_h, max_v, 2, 0])
+    deadline = time.monotonic() + 0.25
+    while maximized(window):
+        if time.monotonic() >= deadline:
+            return
+        time.sleep(0.005)
+    after = geometry(window)
+    if not after:
+        return
+    parent, child = U(), U()
+    x, y, local_x, local_y = (I() for _ in range(4))
+    buttons = C.c_uint()
+    if not query_pointer(display, root, C.byref(parent), C.byref(child), C.byref(x),
+                         C.byref(y), C.byref(local_x), C.byref(local_y), C.byref(buttons)):
+        return
+    send(window, position_atom, [(2 << 12) | (1 << 8) | (1 << 9) | 1,
+                                round(x.value - fraction * after[2]), y.value - offset_y, 0, 0])
+    if buttons.value & (1 << 8):
+        send(window, move_atom, [x.value, y.value, 8, 1, 2])
+
+
+select_input(display, root, notify_mask)
+flush(display)
+manager = subprocess.Popen(sys.argv[1:])
+running = True
+
+
+def stop(signum, frame):
+    global running
+    running = False
+
+
+signal.signal(signal.SIGTERM, stop)
+signal.signal(signal.SIGINT, stop)
+try:
+    while running and manager.poll() is None:
+        if not pending(display):
+            select.select([connection(display)], [], [], 0.1)
+            continue
+        event = Event()
+        next_event(display, C.byref(event))
+        if event.message.type == 33 and event.message.atom == move_atom:
+            restore_drag(event.message)
+finally:
+    close_display(display)
+    if manager.poll() is None:
+        manager.terminate()
+    manager.wait()
+sys.exit(manager.returncode)
+`;