@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/avatar/avatar-manifest.ts

@@ -17,66 +17,26 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 
-import { getLogger } from "../util/logger.js";
 import {
   AVATAR_IMAGE_FILENAME,
   AVATAR_MANIFEST_FILENAME,
-  getAvatarDir,
-} from "../util/platform.js";
-import { type CharacterTraits, TRAITS_FILENAME } from "./traits-png-sync.js";
-
-const log = getLogger("avatar-manifest");
-
-export type AvatarKind = "character" | "image" | "none";
-export type AvatarSource = "builder" | "upload" | "ai";
-
-export interface AvatarImageMeta {
-  updatedAt: string;
-  etag: string;
-}
+  AVATAR_TRAITS_FILENAME,
+  type AvatarImageMeta,
+  type AvatarKind,
+  type AvatarSource,
+  type AvatarState,
+  type CharacterTraits,
+  deriveAvatarFromLegacyFiles,
+  parseAvatarManifest,
+} from "@vellumai/avatar-manifest";
 
-export interface AvatarState {
-  kind: AvatarKind;
-  traits: CharacterTraits | null;
-  source: AvatarSource | null;
-  image: AvatarImageMeta | null;
-}
+import { getLogger } from "../util/logger.js";
+import { getAvatarDir } from "../util/platform.js";
 
-const AVATAR_KINDS: ReadonlySet<string> = new Set<AvatarKind>([
-  "character",
-  "image",
-  "none",
-]);
+const log = getLogger("avatar-manifest");
 
-/** Narrows an unknown value to valid CharacterTraits (presence check only). */
-function isValidTraits(value: unknown): value is CharacterTraits {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const t = value as Record<string, unknown>;
-  return (
-    typeof t.bodyShape === "string" &&
-    !!t.bodyShape &&
-    typeof t.eyeStyle === "string" &&
-    !!t.eyeStyle &&
-    typeof t.color === "string" &&
-    !!t.color
-  );
-}
-
-/** Narrows an unknown value to valid AvatarImageMeta (presence check only). */
-function isValidImageMeta(value: unknown): value is AvatarImageMeta {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const m = value as Record<string, unknown>;
-  return (
-    typeof m.updatedAt === "string" &&
-    !!m.updatedAt &&
-    typeof m.etag === "string" &&
-    !!m.etag
-  );
-}
+export type { AvatarImageMeta, AvatarKind, AvatarSource, AvatarState };
+export type { CharacterTraits };
 
 /**
  * Reads and validates the avatar manifest. Returns `null` when the manifest is
@@ -93,32 +53,9 @@ export function readManifest(
   }
 
   try {
-    const parsed = JSON.parse(readFileSync(manifestPath, "utf-8")) as unknown;
-    if (!parsed || typeof parsed !== "object") {
-      return null;
-    }
-    const obj = parsed as Record<string, unknown>;
-    if (typeof obj.kind !== "string" || !AVATAR_KINDS.has(obj.kind)) {
-      return null;
-    }
-    const kind = obj.kind as AvatarKind;
-
-    // Reject partial manifests: a valid `kind` with a missing/malformed payload
-    // would otherwise short-circuit the legacy fallback and surface an avatar
-    // with null traits/image.
-    if (kind === "character" && !isValidTraits(obj.traits)) {
-      return null;
-    }
-    if (kind === "image" && !isValidImageMeta(obj.image)) {
-      return null;
-    }
-
-    return {
-      kind,
-      traits: (obj.traits as CharacterTraits | null) ?? null,
-      source: (obj.source as AvatarSource | null) ?? null,
-      image: (obj.image as AvatarImageMeta | null) ?? null,
-    };
+    return parseAvatarManifest(
+      JSON.parse(readFileSync(manifestPath, "utf-8")) as unknown,
+    );
   } catch (err) {
     log.warn({ err }, "Failed to read avatar manifest — treating as absent");
     return null;
@@ -167,24 +104,16 @@ export function computeImageMeta(imagePath: string): AvatarImageMeta {
  * Used by the read handlers to self-heal once on a manifest-miss: the derived
  * state is persisted via `writeManifest` so subsequent reads are manifest-only.
  *
- * Inference is **traits-first**: whenever a valid `character-traits.json`
- * exists, the result is `character` regardless of whether a PNG is also
- * present. We deliberately do NOT compare mtimes to break the both-present
- * tie, because the builder writes the rendered PNG *after* the traits file
- * (see traits-png-sync.ts), so the PNG is always newer even when the
- * character is the source of truth. Comparing mtimes would misclassify a
- * builder-generated character as an uploaded image.
+ * Inference is traits-first (see `deriveAvatarFromLegacyFiles`).
  */
 export function deriveStateFromLegacyFiles(
   avatarDir: string = getAvatarDir(),
 ): AvatarState {
-  const traitsPath = join(avatarDir, TRAITS_FILENAME);
+  const traitsPath = join(avatarDir, AVATAR_TRAITS_FILENAME);
+  let traitsJson: unknown;
   if (existsSync(traitsPath)) {
     try {
-      const traits = JSON.parse(readFileSync(traitsPath, "utf-8")) as unknown;
-      if (isValidTraits(traits)) {
-        return { kind: "character", traits, source: null, image: null };
-      }
+      traitsJson = JSON.parse(readFileSync(traitsPath, "utf-8")) as unknown;
     } catch (err) {
       log.warn(
         { err },
@@ -194,14 +123,33 @@ export function deriveStateFromLegacyFiles(
   }
 
   const imagePath = join(avatarDir, AVATAR_IMAGE_FILENAME);
-  if (existsSync(imagePath)) {
-    return {
-      kind: "image",
-      traits: null,
-      source: null,
-      image: computeImageMeta(imagePath),
-    };
+  const derived = deriveAvatarFromLegacyFiles({
+    traitsJson,
+    hasImage: existsSync(imagePath),
+  });
+  switch (derived.kind) {
+    case "character":
+      return {
+        kind: "character",
+        traits: derived.traits,
+        source: null,
+        image: null,
+      };
+    case "image":
+      return {
+        kind: "image",
+        traits: null,
+        source: null,
+        image: computeImageMeta(imagePath),
+      };
+    case "none":
+      return { kind: "none", traits: null, source: null, image: null };
   }
+}
 
-  return { kind: "none", traits: null, source: null, image: null };
+/** Manifest first, legacy sidecars as fallback. Never persists. */
+export function readAvatarState(
+  avatarDir: string = getAvatarDir(),
+): AvatarState {
+  return readManifest(avatarDir) ?? deriveStateFromLegacyFiles(avatarDir);
 }

package/src/avatar/avatar-store.ts

@@ -15,13 +15,14 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { getLogger } from "../util/logger.js";
 import {
   AVATAR_IMAGE_FILENAME,
   AVATAR_MANIFEST_FILENAME,
-  getAvatarDir,
-  getAvatarImagePath,
-} from "../util/platform.js";
+  AVATAR_TRAITS_FILENAME,
+} from "@vellumai/avatar-manifest";
+
+import { getLogger } from "../util/logger.js";
+import { getAvatarDir, getAvatarImagePath } from "../util/platform.js";
 import {
   type AvatarSource,
   computeImageMeta,
@@ -30,7 +31,6 @@ import {
 import {
   ASCII_FILENAME,
   type CharacterTraits,
-  TRAITS_FILENAME,
   type TraitsSyncResult,
   writeTraitsAndRenderAvatar,
 } from "./traits-png-sync.js";
@@ -77,7 +77,7 @@ export function setImage(pngBuffer: Buffer, source: AvatarSource): void {
   writeFileSync(pngTmp, pngBuffer);
   renameSync(pngTmp, pngPath);
 
-  rmSync(join(avatarDir, TRAITS_FILENAME), { force: true });
+  rmSync(join(avatarDir, AVATAR_TRAITS_FILENAME), { force: true });
   rmSync(join(avatarDir, ASCII_FILENAME), { force: true });
 
   writeManifest({
@@ -105,7 +105,7 @@ export function clearAvatar(): void {
   mkdirSync(avatarDir, { recursive: true });
 
   rmSync(join(avatarDir, AVATAR_IMAGE_FILENAME), { force: true });
-  rmSync(join(avatarDir, TRAITS_FILENAME), { force: true });
+  rmSync(join(avatarDir, AVATAR_TRAITS_FILENAME), { force: true });
   rmSync(join(avatarDir, ASCII_FILENAME), { force: true });
   rmSync(join(avatarDir, AVATAR_MANIFEST_FILENAME), { force: true });
 

package/src/avatar/ensure-raster.ts

@@ -0,0 +1,146 @@
+import {
+  closeSync,
+  constants,
+  existsSync,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+} from "node:fs";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
+
+import { getLogger } from "../util/logger.js";
+import { getAvatarImagePath, getWorkspaceDir } from "../util/platform.js";
+import { type AvatarState, readAvatarState } from "./avatar-manifest.js";
+import { writeTraitsAndRenderAvatar } from "./traits-png-sync.js";
+
+const log = getLogger("ensure-raster");
+
+/** Largest raster any reader serves; a bigger file is treated as unreadable. */
+export const AVATAR_RASTER_MAX_BYTES = 5 * 1024 * 1024;
+
+function isWithin(dir: string, filePath: string): boolean {
+  const rel = relative(dir, filePath);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+/**
+ * Reads the raster only when it is a regular file that truly lives under the
+ * avatar dir: a symlinked PNG (or a symlinked ancestor) would let the
+ * workspace hand a reader an arbitrary host file. Validation and the read
+ * share one descriptor so a concurrent swap of the path cannot slip a
+ * different file past the checks, and the descriptor's location is
+ * revalidated after the open. Returns null when the file is missing,
+ * symlinked, outside the avatar dir, not a regular file, or over the cap.
+ */
+export function readContainedAvatarRaster(rasterPath: string): Buffer | null {
+  let fd: number | undefined;
+  try {
+    // Anchored on the real workspace root: a data/avatar symlink pointing at
+    // another workspace resolves outside it and is rejected.
+    // The root is resolved once and reused after the open so a workspace
+    // pathname swapped for a symlink mid-read cannot re-anchor the check.
+    const realRoot = realpathSync(getWorkspaceDir());
+    const realDir = realpathSync(dirname(rasterPath));
+    if (!isWithin(realRoot, realDir)) {
+      return null;
+    }
+    const realPath = join(realDir, basename(rasterPath));
+    const linkStats = lstatSync(realPath);
+    if (!linkStats.isFile()) {
+      return null;
+    }
+    fd = openSync(realPath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const stats = fstatSync(fd);
+    if (
+      !stats.isFile() ||
+      stats.dev !== linkStats.dev ||
+      stats.ino !== linkStats.ino ||
+      stats.size > AVATAR_RASTER_MAX_BYTES
+    ) {
+      return null;
+    }
+    // O_NOFOLLOW guards only the last component; an ancestor swapped for an
+    // outside symlink between the check and the open either stays swapped
+    // (fresh realpath resolves outside) or is swapped back (the inside file
+    // is a different inode than the opened fd). Node has no openat.
+    const reopenedPath = realpathSync(rasterPath);
+    if (!isWithin(realRoot, reopenedPath)) {
+      return null;
+    }
+    const reopenedStats = lstatSync(reopenedPath);
+    if (
+      !reopenedStats.isFile() ||
+      reopenedStats.dev !== stats.dev ||
+      reopenedStats.ino !== stats.ino
+    ) {
+      return null;
+    }
+    const bytes = readFileSync(fd);
+    return bytes.length > AVATAR_RASTER_MAX_BYTES ? null : bytes;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      closeSync(fd);
+    }
+  }
+}
+
+/**
+ * Returns the on-disk path of the current avatar PNG, or null when there is
+ * none. Never reads the raster bytes.
+ *
+ * Side-effect-free when the PNG already exists. A character whose PNG is
+ * missing is re-rendered from its persisted traits (best-effort; null when
+ * the native rasterizer is unavailable or the render fails). An image-kind
+ * avatar with a missing PNG cannot be recovered and yields null.
+ *
+ * Callers that already hold the avatar state can pass it to skip the re-read.
+ */
+export async function ensureAvatarRasterPath(
+  state: AvatarState = readAvatarState(),
+): Promise<string | null> {
+  if (state.kind === "none") {
+    return null;
+  }
+
+  const avatarPath = getAvatarImagePath();
+  if (existsSync(avatarPath)) {
+    return avatarPath;
+  }
+  if (state.kind !== "character" || !state.traits) {
+    return null;
+  }
+
+  try {
+    const result = writeTraitsAndRenderAvatar(state.traits);
+    if (result.ok) {
+      return avatarPath;
+    }
+    log.warn({ reason: result.reason }, "Avatar raster re-render failed");
+  } catch (err) {
+    log.warn({ err }, "Avatar raster re-render threw");
+  }
+  return null;
+}
+
+/**
+ * Returns the PNG raster for the current avatar, or null when there is none
+ * or it cannot be read (see `readContainedAvatarRaster`). Same regeneration
+ * semantics as `ensureAvatarRasterPath`.
+ */
+export async function ensureAvatarRaster(
+  state: AvatarState = readAvatarState(),
+): Promise<Buffer | null> {
+  const avatarPath = await ensureAvatarRasterPath(state);
+  if (!avatarPath) {
+    return null;
+  }
+  const bytes = readContainedAvatarRaster(avatarPath);
+  if (!bytes) {
+    log.warn({ path: avatarPath }, "Avatar raster unreadable or not contained");
+  }
+  return bytes;
+}

package/src/avatar/resvg-lazy.test.ts

@@ -33,7 +33,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  AVATAR_IMAGE_FILENAME: "avatar-image.png",
   getAvatarDir: () => "/tmp/vellum-test-avatar-never-written",
 }));
 

package/src/avatar/traits-png-sync.ts

@@ -2,8 +2,14 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
+import {
+  AVATAR_IMAGE_FILENAME,
+  AVATAR_TRAITS_FILENAME,
+  type CharacterTraits,
+} from "@vellumai/avatar-manifest";
+
 import { getLogger } from "../util/logger.js";
-import { AVATAR_IMAGE_FILENAME, getAvatarDir } from "../util/platform.js";
+import { getAvatarDir } from "../util/platform.js";
 import { renderCharacterAscii } from "./ascii-renderer.js";
 import { getCharacterComponents } from "./character-components.js";
 import { renderCharacterPng } from "./png-renderer.js";
@@ -11,17 +17,10 @@ import { isResvgAvailable } from "./resvg-lazy.js";
 
 const log = getLogger("traits-png-sync");
 
-/** Sidecar filename for the persisted character traits JSON. */
-export const TRAITS_FILENAME = "character-traits.json";
-
 /** Sidecar filename for the rendered ASCII art. */
 export const ASCII_FILENAME = "character-ascii.txt";
 
-export interface CharacterTraits {
-  bodyShape: string;
-  eyeStyle: string;
-  color: string;
-}
+export type { CharacterTraits } from "@vellumai/avatar-manifest";
 
 export type TraitsSyncResult =
   | { ok: true; asciiWritten: boolean }
@@ -171,7 +170,7 @@ export function writeTraitsAndRenderAvatar(
   }
 
   const avatarDir = getAvatarDir();
-  const traitsPath = join(avatarDir, TRAITS_FILENAME);
+  const traitsPath = join(avatarDir, AVATAR_TRAITS_FILENAME);
 
   try {
     mkdirSync(avatarDir, { recursive: true });

package/src/background-wake/wake-intent-hooks.test.ts

@@ -82,7 +82,6 @@ mock.module("../util/platform.js", () => ({
   getSandboxWorkingDir: () => testWorkspaceDir,
   getSoundsDir: () => workspacePath("data", "sounds"),
   getAvatarDir: () => workspacePath("data", "avatar"),
-  AVATAR_IMAGE_FILENAME: "avatar-image.png",
   getAvatarImagePath: () => workspacePath("data", "avatar", "avatar-image.png"),
   getXdgVellumConfigDirName: () => ".vellum",
   getProfilerRootDir: () => workspacePath("data", "profiler"),

package/src/backup/__tests__/paths.test.ts

@@ -134,7 +134,7 @@ describe("getDefaultOffsiteBackupsDir", () => {
 
 describe("resolveOffsiteDestinations", () => {
   test("returns iCloud default with encrypt=true when override is null", () => {
-    const result = resolveOffsiteDestinations(null);
+    const result = resolveOffsiteDestinations(null, "darwin");
     expect(result).toHaveLength(1);
     expect(result[0].encrypt).toBe(true);
     expect(result[0].path).toContain(
@@ -143,11 +143,15 @@ describe("resolveOffsiteDestinations", () => {
   });
 
   test("returns iCloud default when override is undefined", () => {
-    const result = resolveOffsiteDestinations(undefined);
+    const result = resolveOffsiteDestinations(undefined, "darwin");
     expect(result).toHaveLength(1);
     expect(result[0].encrypt).toBe(true);
   });
 
+  test("returns no implicit destination on Windows", () => {
+    expect(resolveOffsiteDestinations(null, "win32")).toEqual([]);
+  });
+
   test("returns an empty array unchanged", () => {
     expect(resolveOffsiteDestinations([])).toEqual([]);
   });

package/src/backup/paths.ts

@@ -115,15 +115,17 @@ export function deriveSafeAncestor(destinationPath: string): string {
 
 /**
  * Resolves the list of offsite backup destinations from an optional config
- * override. When `override` is `null` (the "not configured" sentinel), returns
- * a single-element array pointing at the iCloud default with encryption
- * enabled. When `override` is an array (including the empty array), returns it
- * unchanged so callers never need to null-check.
+ * override. A null override uses encrypted iCloud Drive on macOS and no
+ * implicit destination on other platforms. Explicit arrays are unchanged.
  */
 export function resolveOffsiteDestinations(
   override?: BackupDestination[] | null,
+  platform: NodeJS.Platform = process.platform,
 ): BackupDestination[] {
   if (override == null) {
+    if (platform !== "darwin") {
+      return [];
+    }
     return [{ path: getDefaultOffsiteBackupsDir(), encrypt: true }];
   }
   return override;

package/src/bundler/app-compiler.ts

@@ -11,7 +11,7 @@
 
 import { existsSync, rmSync } from "node:fs";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { delimiter, dirname, join, resolve } from "node:path";
 
 import { getLogger } from "../util/logger.js";
 import { ensureCompilerTools } from "./compiler-tools.js";
@@ -469,7 +469,7 @@ export async function runCompile(
   const cacheNodeModules = join(getCacheDir(), "node_modules");
   const nodePath = [preactParent, cacheNodeModules]
     .filter((p) => existsSync(p))
-    .join(":");
+    .join(delimiter);
 
   // Shell out to esbuild CLI
   const args = [

package/src/bundler/compiler-tools.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+
+import { resolveEsbuildPlatform } from "./compiler-tools.js";
+
+describe("resolveEsbuildPlatform", () => {
+  test("selects Windows executables", () => {
+    expect(resolveEsbuildPlatform("win32", "x64")).toEqual({
+      packageName: "win32-x64",
+      binaryPathParts: ["esbuild.exe"],
+    });
+    expect(resolveEsbuildPlatform("win32", "arm64")).toEqual({
+      packageName: "win32-arm64",
+      binaryPathParts: ["esbuild.exe"],
+    });
+  });
+
+  test("keeps POSIX binaries under bin", () => {
+    expect(resolveEsbuildPlatform("darwin", "arm64")).toEqual({
+      packageName: "darwin-arm64",
+      binaryPathParts: ["bin", "esbuild"],
+    });
+    expect(resolveEsbuildPlatform("linux", "x64")).toEqual({
+      packageName: "linux-x64",
+      binaryPathParts: ["bin", "esbuild"],
+    });
+  });
+
+  test("rejects unsupported targets", () => {
+    expect(() => resolveEsbuildPlatform("freebsd", "x64")).toThrow(
+      "Unsupported esbuild platform: freebsd",
+    );
+    expect(() => resolveEsbuildPlatform("win32", "ia32")).toThrow(
+      "Unsupported esbuild architecture: ia32",
+    );
+  });
+});

package/src/bundler/compiler-tools.ts

@@ -16,7 +16,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { arch, platform } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
@@ -44,6 +44,37 @@ interface VersionManifest {
   installedAt: string;
 }
 
+interface EsbuildPlatform {
+  packageName: string;
+  binaryPathParts: string[];
+}
+
+export function resolveEsbuildPlatform(
+  os: NodeJS.Platform,
+  cpu: string,
+): EsbuildPlatform {
+  if (cpu !== "arm64" && cpu !== "x64") {
+    throw new Error(`Unsupported esbuild architecture: ${cpu}`);
+  }
+  if (os === "darwin" || os === "linux") {
+    return {
+      packageName: `${os}-${cpu}`,
+      binaryPathParts: ["bin", "esbuild"],
+    };
+  }
+  if (os === "win32") {
+    return {
+      packageName: `win32-${cpu}`,
+      binaryPathParts: ["esbuild.exe"],
+    };
+  }
+  throw new Error(`Unsupported esbuild platform: ${os}`);
+}
+
+function installedEsbuildName(os: NodeJS.Platform): string {
+  return os === "win32" ? "esbuild.exe" : "esbuild";
+}
+
 function getToolsDir(): string {
   return join(getWorkspaceDir(), "compiler-tools");
 }
@@ -171,8 +202,11 @@ function isReady(baseDir: string): boolean {
   if (!manifest || manifest.toolsVersion !== TOOLS_VERSION) {
     return false;
   }
+  if (manifest.platform !== platform() || manifest.arch !== arch()) {
+    return false;
+  }
   return (
-    existsSync(join(baseDir, "bin", "esbuild")) &&
+    existsSync(join(baseDir, "bin", installedEsbuildName(platform()))) &&
     existsSync(join(baseDir, "node_modules", "preact"))
   );
 }
@@ -193,7 +227,7 @@ export async function ensureCompilerTools(): Promise<CompilerTools> {
   }
 
   return {
-    esbuildBin: join(baseDir, "bin", "esbuild"),
+    esbuildBin: join(baseDir, "bin", installedEsbuildName(platform())),
     preactDir: join(baseDir, "node_modules", "preact"),
   };
 }
@@ -247,22 +281,17 @@ async function install(baseDir: string): Promise<void> {
   mkdirSync(tmpDir, { recursive: true });
 
   try {
-    // Determine esbuild platform package name
-    const esbuildPlatform =
-      os === "darwin"
-        ? cpu === "arm64"
-          ? "darwin-arm64"
-          : "darwin-x64"
-        : cpu === "arm64"
-          ? "linux-arm64"
-          : "linux-x64";
+    const esbuildPlatform = resolveEsbuildPlatform(os, cpu);
 
     // Download esbuild binary + preact in parallel
     await Promise.all([
       downloadAndExtract(
-        `@esbuild/${esbuildPlatform}`,
+        `@esbuild/${esbuildPlatform.packageName}`,
         ESBUILD_VERSION,
-        npmTarballUrl(`@esbuild/${esbuildPlatform}`, ESBUILD_VERSION),
+        npmTarballUrl(
+          `@esbuild/${esbuildPlatform.packageName}`,
+          ESBUILD_VERSION,
+        ),
         join(tmpDir, "esbuild-pkg"),
       ),
       downloadAndExtract(
@@ -274,12 +303,19 @@ async function install(baseDir: string): Promise<void> {
     ]);
 
     // Move esbuild binary to bin/
-    const esbuildBinSrc = join(tmpDir, "esbuild-pkg", "bin", "esbuild");
+    const esbuildBinSrc = join(
+      tmpDir,
+      "esbuild-pkg",
+      ...esbuildPlatform.binaryPathParts,
+    );
     const binDir = join(tmpDir, "bin");
     mkdirSync(binDir, { recursive: true });
     const { renameSync } = await import("node:fs");
-    renameSync(esbuildBinSrc, join(binDir, "esbuild"));
-    chmodSync(join(binDir, "esbuild"), 0o755);
+    const esbuildBin = join(binDir, installedEsbuildName(os));
+    renameSync(esbuildBinSrc, esbuildBin);
+    if (os !== "win32") {
+      chmodSync(esbuildBin, 0o755);
+    }
     rmSync(join(tmpDir, "esbuild-pkg"), { recursive: true, force: true });
 
     // Write version manifest
@@ -299,7 +335,7 @@ async function install(baseDir: string): Promise<void> {
     // Atomic swap: clear old install, move new files in
     const { readdirSync } = await import("node:fs");
     for (const entry of readdirSync(baseDir)) {
-      if (entry.startsWith(".") || entry === tmpDir.split("/").pop()) {
+      if (entry.startsWith(".") || entry === basename(tmpDir)) {
         continue;
       }
       rmSync(join(baseDir, entry), { recursive: true, force: true });