@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/util/host-process.ts

@@ -0,0 +1,75 @@
+import { spawn } from "node:child_process";
+
+export {
+  buildShellInvocation,
+  pathListDelimiter,
+  prependUniquePathEntries,
+} from "@vellumai/environments/shell";
+
+export interface KillableProcess {
+  pid?: number;
+  kill: unknown;
+}
+
+type WindowsTreeTerminator = (pid: number, onFailure: () => void) => void;
+
+export function terminateProcessTree(
+  child: KillableProcess,
+  hostPlatform: NodeJS.Platform = process.platform,
+  terminateWindowsTree: WindowsTreeTerminator = runTaskkill,
+): void {
+  if (child.pid == null) {
+    killDirectChild(child, hostPlatform);
+    return;
+  }
+
+  if (hostPlatform === "win32") {
+    let fellBack = false;
+    const fallback = () => {
+      if (!fellBack) {
+        fellBack = true;
+        killDirectChild(child, hostPlatform);
+      }
+    };
+    terminateWindowsTree(child.pid, fallback);
+    return;
+  }
+
+  try {
+    process.kill(-child.pid, "SIGKILL");
+  } catch {
+    killDirectChild(child, hostPlatform);
+  }
+}
+
+function runTaskkill(pid: number, onFailure: () => void): void {
+  const killer = spawn("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  killer.once("error", onFailure);
+  killer.once("close", (code) => {
+    if (code !== 0) {
+      onFailure();
+    }
+  });
+}
+
+function killDirectChild(
+  child: KillableProcess,
+  hostPlatform: NodeJS.Platform,
+): void {
+  if (typeof child.kill !== "function") {
+    return;
+  }
+  try {
+    const kill = child.kill as (signal?: NodeJS.Signals | number) => unknown;
+    if (hostPlatform === "win32") {
+      kill.call(child);
+    } else {
+      kill.call(child, "SIGKILL");
+    }
+  } catch {
+    // The process may have already exited.
+  }
+}

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;
+  }
+}