@vellumai/assistant 0.11.6 → 0.11.7-staging.1

package/src/util/image-conversion.ts

@@ -1,5 +1,5 @@
 /**
- * JPEG conversion for images, backed by macOS `sips`.
+ * JPEG conversion for images, backed by sharp with a macOS `sips` fallback.
  *
  * Two consumers share this converter:
  *   - transport optimization (`agent/image-optimize.ts`) downscales large
@@ -7,10 +7,8 @@
  *   - storage normalization (attachment ingress + history hydration) converts
  *     HEIF/HEIC — which Chromium-based clients cannot decode — to JPEG.
  *
- * Conversion runs `sips` (a macOS builtin); on other platforms or on any
- * failure it returns null and callers keep the original bytes. Results are
- * cached on disk keyed by content hash + conversion options, so repeated
- * conversions of the same image (or daemon restarts) skip the sips call.
+ * Results are cached on disk keyed by content hash + conversion options, so
+ * repeated conversions of the same image skip the encoder call.
  */
 
 import { createHash } from "node:crypto";
@@ -291,9 +289,41 @@ async function runSips(
   }
 }
 
+async function runSharp(
+  inputBytes: Uint8Array,
+  options: ConvertToJpegOptions,
+): Promise<Buffer | null> {
+  try {
+    const { default: sharp } = await import("sharp");
+    let pipeline = sharp(inputBytes, { failOn: "error" }).autoOrient();
+    if (options.resizeToPx != null) {
+      pipeline = pipeline.resize(
+        options.resizeToPx.width,
+        options.resizeToPx.height,
+        { fit: "fill" },
+      );
+    } else if (options.maxDimensionPx != null) {
+      pipeline = pipeline.resize(
+        options.maxDimensionPx,
+        options.maxDimensionPx,
+        {
+          fit: "inside",
+          withoutEnlargement: true,
+        },
+      );
+    }
+    const out = await pipeline
+      .jpeg({ quality: options.quality ?? DEFAULT_JPEG_QUALITY })
+      .toBuffer();
+    return isCompleteJpeg(out) ? out : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Convert an image to JPEG, optionally downscaling. Returns null when
- * conversion is unavailable (non-macOS) or fails; callers keep the original.
+ * conversion is unavailable or fails; callers keep the original.
  */
 export async function convertImageToJpeg(
   bytes: Uint8Array,
@@ -313,7 +343,9 @@ export async function convertImageToJpeg(
     return cached;
   }
 
-  const converted = await runSips(bytes, options);
+  const converted =
+    (await runSharp(bytes, options)) ??
+    (process.platform === "darwin" ? await runSips(bytes, options) : null);
   if (!converted) {
     return null;
   }

package/src/util/platform.ts

@@ -1,7 +1,12 @@
 import { chmodSync, existsSync, mkdirSync, realpathSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, join, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
 
+import {
+  AVATAR_IMAGE_FILENAME,
+  AVATAR_MANIFEST_FILENAME,
+  resolveAvatarDir,
+} from "@vellumai/avatar-manifest";
 import { SEEDS } from "@vellumai/environments";
 
 import { getWorkspaceDirOverride } from "../config/env-registry.js";
@@ -160,20 +165,14 @@ export function getSoundsDir(): string {
 
 /** Returns the avatar directory ($VELLUM_WORKSPACE_DIR/data/avatar). */
 export function getAvatarDir(): string {
-  return join(getWorkspaceDir(), "data", "avatar");
+  return resolveAvatarDir(getWorkspaceDir());
 }
 
-/** Canonical filename for the custom avatar PNG. */
-export const AVATAR_IMAGE_FILENAME = "avatar-image.png";
-
 /** Returns the canonical avatar image path ($VELLUM_WORKSPACE_DIR/data/avatar/avatar-image.png). */
 export function getAvatarImagePath(): string {
   return join(getAvatarDir(), AVATAR_IMAGE_FILENAME);
 }
 
-/** Canonical filename for the avatar state manifest. */
-export const AVATAR_MANIFEST_FILENAME = "avatar.json";
-
 /** Returns the canonical avatar manifest path ($VELLUM_WORKSPACE_DIR/data/avatar/avatar.json). */
 export function getAvatarManifestPath(): string {
   return join(getAvatarDir(), AVATAR_MANIFEST_FILENAME);
@@ -442,12 +441,32 @@ export function getWorkspaceDir(): string {
  *   /data/.vellum/workspace        → /data/.vellum/workspace
  */
 export function getWorkspaceDirDisplay(): string {
-  const abs = getWorkspaceDir();
-  const home = homedir();
-  if (abs.startsWith(home + "/") || abs === home) {
-    return "~" + abs.slice(home.length);
+  return formatHomeRelativePath(getWorkspaceDir(), homedir());
+}
+
+interface PathOperations {
+  isAbsolute(path: string): boolean;
+  relative(from: string, to: string): string;
+  sep: string;
+}
+
+export function formatHomeRelativePath(
+  absolutePath: string,
+  homePath: string,
+  pathOperations: PathOperations = { isAbsolute, relative, sep },
+): string {
+  const relativeToHome = pathOperations.relative(homePath, absolutePath);
+  if (relativeToHome === "") {
+    return "~";
+  }
+  if (
+    relativeToHome !== ".." &&
+    !relativeToHome.startsWith(`..${pathOperations.sep}`) &&
+    !pathOperations.isAbsolute(relativeToHome)
+  ) {
+    return `~${pathOperations.sep}${relativeToHome}`;
   }
-  return abs;
+  return absolutePath;
 }
 
 /** Returns $VELLUM_WORKSPACE_DIR/config.json */

package/src/util/process-table.ts

@@ -0,0 +1,249 @@
+import { execFile } from "node:child_process";
+import { readdirSync, readFileSync } from "node:fs";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+const PS_PROCESS_TABLE_COMMAND = [
+  "ps",
+  "-A",
+  "-ww",
+  "-o",
+  "pid=,ppid=,command=",
+];
+const WINDOWS_PROCESS_TABLE_COMMAND = [
+  "powershell.exe",
+  "-NoProfile",
+  "-NonInteractive",
+  "-Command",
+  "$OutputEncoding = [Console]::OutputEncoding = [Text.UTF8Encoding]::new(); Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine,Name,WorkingSetSize,HandleCount | ConvertTo-Json -Compress",
+];
+
+export interface ProcessTableRow {
+  pid: number;
+  ppid: number;
+  /** Raw command line. Callers must redact it before logging or persistence. */
+  command: string;
+  rssBytes?: number;
+  handleCount?: number;
+}
+
+export interface ProcessTableOptions {
+  platform?: NodeJS.Platform;
+  processTable?: readonly ProcessTableRow[] | null;
+}
+
+export function getProcessTableRows(
+  options: ProcessTableOptions = {},
+): readonly ProcessTableRow[] {
+  if (options.processTable !== undefined) {
+    return options.processTable ?? [];
+  }
+  return listProcessTable(options.platform);
+}
+
+interface WindowsProcessRow {
+  ProcessId?: unknown;
+  ParentProcessId?: unknown;
+  CommandLine?: unknown;
+  Name?: unknown;
+  WorkingSetSize?: unknown;
+  HandleCount?: unknown;
+}
+
+function nonNegativeNumber(value: unknown): number | null {
+  if (typeof value !== "number" && typeof value !== "string") {
+    return null;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+
+function parseProcStat(
+  content: string,
+): { command: string; ppid: number } | null {
+  const lparen = content.indexOf("(");
+  const rparen = content.lastIndexOf(")");
+  if (lparen === -1 || rparen === -1 || rparen < lparen) {
+    return null;
+  }
+  const ppid = Number(content.slice(rparen + 2).split(" ")[1]);
+  if (!Number.isInteger(ppid)) {
+    return null;
+  }
+  return { command: content.slice(lparen + 1, rparen), ppid };
+}
+
+function listProcessesFromProc(): ProcessTableRow[] {
+  const rows: ProcessTableRow[] = [];
+  for (const entry of readdirSync("/proc")) {
+    const pid = Number(entry);
+    if (!Number.isInteger(pid) || pid <= 0) {
+      continue;
+    }
+
+    try {
+      const stat = parseProcStat(readFileSync(`/proc/${pid}/stat`, "utf8"));
+      if (!stat) {
+        continue;
+      }
+      const commandLine = readFileSync(`/proc/${pid}/cmdline`, "utf8")
+        .split("\0")
+        .filter(Boolean)
+        .join(" ");
+      rows.push({
+        pid,
+        ppid: stat.ppid,
+        command: commandLine || stat.command,
+      });
+    } catch {
+      // Processes can exit between reading the directory and their files.
+    }
+  }
+  return rows;
+}
+
+export function parsePsProcessTable(output: string): ProcessTableRow[] {
+  const rows: ProcessTableRow[] = [];
+  for (const line of output.split("\n")) {
+    const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+    if (!match) {
+      continue;
+    }
+    rows.push({
+      pid: Number(match[1]),
+      ppid: Number(match[2]),
+      command: match[3].trim(),
+    });
+  }
+  return rows;
+}
+
+export function parseWindowsProcessTable(output: string): ProcessTableRow[] {
+  const decoded: unknown = JSON.parse(output.trim().replace(/^\uFEFF/, ""));
+  const values = Array.isArray(decoded) ? decoded : [decoded];
+  const rows: ProcessTableRow[] = [];
+  for (const value of values) {
+    if (!value || typeof value !== "object") {
+      continue;
+    }
+    const processRow = value as WindowsProcessRow;
+    const pid = Number(processRow.ProcessId);
+    const ppid = Number(processRow.ParentProcessId);
+    if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(ppid)) {
+      continue;
+    }
+    const commandLine =
+      typeof processRow.CommandLine === "string" ? processRow.CommandLine : "";
+    const name = typeof processRow.Name === "string" ? processRow.Name : "";
+    const rssBytes = nonNegativeNumber(processRow.WorkingSetSize);
+    const handleCount = nonNegativeNumber(processRow.HandleCount);
+    rows.push({
+      pid,
+      ppid,
+      command: commandLine || name,
+      ...(rssBytes == null ? {} : { rssBytes }),
+      ...(handleCount == null ? {} : { handleCount }),
+    });
+  }
+  return rows;
+}
+
+function runProcessTableCommand(
+  command: string[],
+  parser: (output: string) => ProcessTableRow[],
+): ProcessTableRow[] {
+  const result = Bun.spawnSync({
+    cmd: command,
+    stdout: "pipe",
+    stderr: "ignore",
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Process enumeration failed with exit code ${result.exitCode}`,
+    );
+  }
+  return parser(new TextDecoder().decode(result.stdout));
+}
+
+async function runProcessTableCommandAsync(
+  command: string[],
+  parser: (output: string) => ProcessTableRow[],
+): Promise<ProcessTableRow[]> {
+  const { stdout } = await execFileAsync(command[0], command.slice(1), {
+    encoding: "utf8",
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  return parser(stdout);
+}
+
+function listProcessesFromPs(): ProcessTableRow[] {
+  return runProcessTableCommand(PS_PROCESS_TABLE_COMMAND, parsePsProcessTable);
+}
+
+function listProcessesFromPowerShell(): ProcessTableRow[] {
+  return runProcessTableCommand(
+    WINDOWS_PROCESS_TABLE_COMMAND,
+    parseWindowsProcessTable,
+  );
+}
+
+export function listProcessTable(
+  platform: NodeJS.Platform = process.platform,
+): ProcessTableRow[] {
+  if (platform === "win32") {
+    return listProcessesFromPowerShell();
+  }
+  if (platform === "linux") {
+    try {
+      return listProcessesFromProc();
+    } catch {
+      return listProcessesFromPs();
+    }
+  }
+  return listProcessesFromPs();
+}
+
+export async function listProcessTableAsync(
+  platform: NodeJS.Platform = process.platform,
+): Promise<ProcessTableRow[]> {
+  if (platform === "win32") {
+    return runProcessTableCommandAsync(
+      WINDOWS_PROCESS_TABLE_COMMAND,
+      parseWindowsProcessTable,
+    );
+  }
+  if (platform === "linux") {
+    try {
+      return listProcessesFromProc();
+    } catch {
+      return runProcessTableCommandAsync(
+        PS_PROCESS_TABLE_COMMAND,
+        parsePsProcessTable,
+      );
+    }
+  }
+  return runProcessTableCommandAsync(
+    PS_PROCESS_TABLE_COMMAND,
+    parsePsProcessTable,
+  );
+}
+
+export function readRawProcessCommand(pid: number): string | null {
+  if (process.platform === "linux") {
+    try {
+      return readFileSync(`/proc/${pid}/cmdline`, "utf8")
+        .split("\0")
+        .filter(Boolean)
+        .join(" ");
+    } catch {
+      return null;
+    }
+  }
+
+  try {
+    return listProcessTable().find((row) => row.pid === pid)?.command ?? null;
+  } catch {
+    return null;
+  }
+}

package/src/util/process-tree.ts

@@ -9,11 +9,11 @@
  * process that is actually parented to it.
  */
 
-import { execFile } from "node:child_process";
-import { readdirSync, readFileSync } from "node:fs";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
+import {
+  listProcessTableAsync,
+  type ProcessTableRow,
+  readRawProcessCommand,
+} from "./process-table.js";
 
 /**
  * Whether a process runs plugin-owned code or is the daemon itself / one of its
@@ -52,6 +52,12 @@ export interface ProcTreeNode {
   children: ProcTreeNode[];
 }
 
+interface ProcessTreeBuilder {
+  build: (pid: number) => ProcTreeNode;
+  byPid: Map<number, ProcInfo>;
+  visited: Set<number>;
+}
+
 /** Interpreters whose script argument is more descriptive than argv[0]. */
 const RUNTIMES = new Set([
   "bun",
@@ -64,7 +70,14 @@ const RUNTIMES = new Set([
   "env",
 ]);
 
-const basename = (p: string): string => p.split("/").pop() || p;
+const basename = (p: string): string => p.split(/[\\/]/).pop() || p;
+
+function splitCommand(command: string): string[] {
+  return Array.from(
+    command.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g),
+    (match) => match[1] ?? match[2] ?? match[3],
+  );
+}
 
 /** Script extensions whose path we summarize as `<parent>-<file>`. */
 const SCRIPT_EXT_RE = /\.(ts|js|mjs|cjs|py)$/;
@@ -76,7 +89,7 @@ const SCRIPT_EXT_RE = /\.(ts|js|mjs|cjs|py)$/;
  * filename when the script sits at the filesystem root.
  */
 function scriptName(scriptPath: string): string {
-  const parts = scriptPath.split("/").filter(Boolean);
+  const parts = scriptPath.split(/[\\/]/).filter(Boolean);
   const file = parts[parts.length - 1].replace(SCRIPT_EXT_RE, "");
   const parent = parts.length >= 2 ? parts[parts.length - 2] : "";
   return parent ? `${parent}-${file}` : file;
@@ -93,13 +106,14 @@ function scriptName(scriptPath: string): string {
  * (`/…/vellum-qdrant`) keep their bare executable name.
  */
 export function deriveName(command: string): string {
-  const tokens = command.trim().split(/\s+/).filter(Boolean);
+  const tokens = splitCommand(command.trim());
   if (tokens.length === 0) {
     return "(unknown)";
   }
 
   const argv0 = basename(tokens[0]);
-  if (RUNTIMES.has(argv0)) {
+  const runtimeName = argv0.replace(/\.exe$/i, "").toLowerCase();
+  if (RUNTIMES.has(runtimeName)) {
     const args = tokens.slice(1);
     const script = args.find((t) => SCRIPT_EXT_RE.test(t));
     if (script) {
@@ -109,7 +123,7 @@ export function deriveName(command: string): string {
     // "what was run" rather than an opaque `bun`. Flags are dropped as noise.
     const meaningful = args.filter((t) => !t.startsWith("-"));
     if (meaningful.length > 0) {
-      return `${argv0} ${meaningful.join(" ")}`;
+      return `${runtimeName} ${meaningful.join(" ")}`;
     }
   }
   return argv0;
@@ -126,12 +140,8 @@ export function deriveName(command: string): string {
  * {@link deriveName} descriptor.
  */
 export function readProcessCommand(pid: number): string | null {
-  try {
-    const raw = readFileSync(`/proc/${pid}/cmdline`, "utf8");
-    return deriveName(raw.split("\0").filter(Boolean).join(" "));
-  } catch {
-    return null;
-  }
+  const command = readRawProcessCommand(pid);
+  return command == null ? null : deriveName(command);
 }
 
 /**
@@ -143,7 +153,8 @@ export function readProcessCommand(pid: number): string | null {
  * (`.../plugins/defaults/<name>/`). The `plugins-data/` state directory is
  * deliberately not matched — the slash after `plugins` excludes it.
  */
-const PLUGIN_PATH_RE = /(?:^|\/)plugins\/([^/\s]+)(?:\/([^/\s]+))?/;
+const PLUGIN_PATH_RE =
+  /(?:^|[\\/])plugins[\\/]([^\\/\s]+)(?:[\\/]([^\\/\s]+))?/;
 
 /**
  * Classify whether a raw command line belongs to plugin-owned code, and if so
@@ -169,122 +180,23 @@ export function deriveOrigin(command: string): ProcessOrigin {
   return `plugin:${name}`;
 }
 
-/**
- * Parse a `/proc/<pid>/stat` line into its leading fields. `comm` (the
- * executable name) may itself contain spaces and parentheses, so the fixed
- * fields are read relative to the final `)` rather than by naive splitting.
- * Returns null if the line is malformed.
- */
-function parseProcStat(content: string): { comm: string; ppid: number } | null {
-  const lparen = content.indexOf("(");
-  const rparen = content.lastIndexOf(")");
-  if (lparen === -1 || rparen === -1 || rparen < lparen) {
-    return null;
-  }
-  const comm = content.slice(lparen + 1, rparen);
-  // After ")" come: " <state> <ppid> …" — split the remainder on spaces.
-  const rest = content.slice(rparen + 2).split(" ");
-  const ppid = Number(rest[1]);
-  if (!Number.isInteger(ppid)) {
-    return null;
-  }
-  return { comm, ppid };
-}
-
-/** Read the live process table from Linux `/proc`. Throws if `/proc` is absent. */
-function listProcessesFromProc(): ProcInfo[] {
-  const entries = readdirSync("/proc");
-  const procs: ProcInfo[] = [];
-  for (const entry of entries) {
-    const pid = Number(entry);
-    if (!Number.isInteger(pid) || pid <= 0) {
-      continue;
-    }
-
-    let ppid: number;
-    let comm: string;
-    try {
-      const parsed = parseProcStat(readFileSync(`/proc/${pid}/stat`, "utf8"));
-      if (!parsed) {
-        continue;
-      }
-      ({ ppid, comm } = parsed);
-    } catch {
-      // Process exited between readdir and read — skip.
-      continue;
-    }
-
-    // `/proc/<pid>/cmdline` is NUL-delimited and empty for kernel threads.
-    // Redact the raw command line via deriveName to strip secrets (tokens,
-    // API keys, database URLs) that are commonly passed as process arguments.
-    // The raw command line is read here but never stored — only the derived
-    // safe descriptor is kept.
-    let command = comm;
-    // Origin is derived from the raw command path (which carries the plugin
-    // directory), so it is classified before deriveName redacts the path away.
-    let origin: ProcessOrigin = "workspace";
-    try {
-      const raw = readFileSync(`/proc/${pid}/cmdline`, "utf8");
-      const joined = raw.split("\0").filter(Boolean).join(" ");
-      if (joined) {
-        command = deriveName(joined);
-        origin = deriveOrigin(joined);
-      }
-    } catch {
-      // Fall back to comm.
-    }
-
-    procs.push({ pid, ppid, command, origin });
-  }
-  return procs;
-}
-
-/** Read the live process table via the `ps` command (macOS / no `/proc`). */
-async function listProcessesFromPs(): Promise<ProcInfo[]> {
-  const { stdout } = await execFileAsync(
-    "ps",
-    ["-A", "-o", "pid=,ppid=,command="],
-    { maxBuffer: 8 * 1024 * 1024 },
-  );
-
-  const procs: ProcInfo[] = [];
-  for (const line of stdout.split("\n")) {
-    const m = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
-    if (!m) {
-      continue;
-    }
-    const raw = m[3].trim();
-    procs.push({
-      pid: Number(m[1]),
-      ppid: Number(m[2]),
-      command: deriveName(raw),
-      origin: deriveOrigin(raw),
-    });
-  }
-  return procs;
-}
-
 /**
  * Enumerate the live process table as `(pid, ppid, command)` rows. Prefers
- * Linux `/proc`; falls back to `ps` when `/proc` is unavailable (e.g. macOS).
+ * Linux `/proc`, uses `ps` on macOS, and queries Win32_Process on Windows.
  */
-export async function listProcesses(): Promise<ProcInfo[]> {
-  try {
-    return listProcessesFromProc();
-  } catch {
-    return listProcessesFromPs();
-  }
+export async function listProcesses(
+  rows?: ProcessTableRow[],
+): Promise<ProcInfo[]> {
+  const processRows = rows ?? (await listProcessTableAsync());
+  return processRows.map(({ pid, ppid, command }) => ({
+    pid,
+    ppid,
+    command: deriveName(command),
+    origin: deriveOrigin(command),
+  }));
 }
 
-/**
- * Build the process subtree rooted at `rootPid` from a flat process list.
- * Children are ordered by PID. Self-references and already-visited PIDs are
- * skipped so a malformed table cannot produce an infinite tree.
- */
-export function buildProcessTree(
-  procs: ProcInfo[],
-  rootPid: number,
-): ProcTreeNode {
+function createProcessTreeBuilder(procs: ProcInfo[]): ProcessTreeBuilder {
   const byPid = new Map<number, ProcInfo>();
   const childrenOf = new Map<number, number[]>();
   for (const p of procs) {
@@ -316,5 +228,49 @@ export function buildProcessTree(
     };
   };
 
-  return build(rootPid);
+  return { build, byPid, visited };
+}
+
+/**
+ * Build the process subtree rooted at `rootPid` from a flat process list.
+ * Children are ordered by PID. Self-references and already-visited PIDs are
+ * skipped so a malformed table cannot produce an infinite tree.
+ */
+export function buildProcessTree(
+  procs: ProcInfo[],
+  rootPid: number,
+): ProcTreeNode {
+  return createProcessTreeBuilder(procs).build(rootPid);
+}
+
+/** Build a synthetic system root containing every enumerated process once. */
+export function buildSystemProcessTree(procs: ProcInfo[]): ProcTreeNode {
+  const { build, byPid, visited } = createProcessTreeBuilder(procs);
+  const children: ProcTreeNode[] = [];
+  const orderedProcesses = [...byPid.values()].sort((a, b) => a.pid - b.pid);
+
+  for (const processInfo of orderedProcesses) {
+    if (
+      processInfo.ppid !== processInfo.pid &&
+      !byPid.has(processInfo.ppid) &&
+      !visited.has(processInfo.pid)
+    ) {
+      children.push(build(processInfo.pid));
+    }
+  }
+
+  // Malformed process tables can contain parent cycles with no natural root.
+  for (const processInfo of orderedProcesses) {
+    if (!visited.has(processInfo.pid)) {
+      children.push(build(processInfo.pid));
+    }
+  }
+
+  return {
+    pid: 0,
+    name: "system",
+    command: "",
+    origin: "workspace",
+    children,
+  };
 }