@nativedesktop/cli 0.1.0

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@nativedesktop/cli",
+  "version": "0.1.0",
+  "description": "The nd CLI: dev-runs, builds, and packages NativeDesktop apps",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FormalSnake/NativeDesktop.git",
+    "directory": "packages/nd"
+  },
+  "homepage": "https://github.com/FormalSnake/NativeDesktop#readme",
+  "bugs": "https://github.com/FormalSnake/NativeDesktop/issues",
+  "publishConfig": {
+  "access": "public"
+},
+"files": ["src"],
+"bin": {
+"nd": "src/index.ts"
+},
+"exports": {
+  ".": "./src/index.ts",
+  "./config": "./src/config.ts"
+},
+"dependencies": {
+  "@nativedesktop/host": "0.1.0"
+}
+}

package/src/config.ts

@@ -0,0 +1,204 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+export interface NativeBuildCommand {
+  command: string[];
+  /** Files/directories whose mtimes invalidate the cached output. */
+  inputs?: string[];
+}
+
+export interface NativePluginConfig {
+  /** Shared library path, or a per-platform path. */
+  path?: string;
+  darwin?: string;
+  linux?: string;
+  build?: NativeBuildCommand | Partial<Record<"darwin" | "linux", NativeBuildCommand>>;
+}
+
+export interface FileAssociation {
+  /** Extension without the dot, e.g. "md". */
+  ext: string;
+  /** Human-readable document type name. */
+  name?: string;
+  /** e.g. "text/markdown" — drives the Linux .desktop MimeType entry. */
+  mimeType?: string;
+  /** macOS CFBundleTypeRole. Defaults to "editor". */
+  role?: "editor" | "viewer";
+}
+
+export interface UrlScheme {
+  scheme: string;
+  name?: string;
+}
+
+export interface AppIcon {
+  /** Shared icon source (.png/.svg/.icns path, app-relative). */
+  source?: string;
+  macos?: string;
+  linux?: string;
+}
+
+export interface AppIdentity {
+  /** Reverse-DNS bundle id. Required for icons, mime registration, and updates. */
+  id?: string;
+  /** Product name: <Name>.app, usr/bin/<slug>, AppImage basename. Default: package.json name. */
+  name?: string;
+  /** CFBundleDisplayName / .desktop Name. Default: name. */
+  displayName?: string;
+  /** Default: package.json version, then "0.0.0". ND_APP_VERSION and --version override. */
+  version?: string;
+  icon?: string | AppIcon;
+  /** .desktop Categories=. Default ["Utility"]. */
+  categories?: string[];
+  fileAssociations?: FileAssociation[];
+  urlSchemes?: UrlScheme[];
+}
+
+export interface UpdatesConfig {
+  baseUrl: string;
+  /** minisign secret key path. Falls back to ND_MINISIGN_SEC/ND_MINISIGN_PUB. */
+  secretKey?: string;
+  publicKey?: string;
+  /** Generate a throwaway keypair when no key is configured (CI/test path only). */
+  ephemeralKey?: boolean;
+  format?: "tar.gz" | "tar.zst";
+}
+
+export interface MacPackageConfig {
+  /** Info.plist override file path; the default template is generated in-code. */
+  infoPlist?: string;
+  entitlements?: string;
+  /** Default "26.0". */
+  minimumSystemVersion?: string;
+  /** LSApplicationCategoryType. */
+  category?: string;
+  /** Else APPLE_SIGN_IDENTITY, else ad-hoc "-". */
+  signIdentity?: string;
+  /** Default: auto (only with all three Apple creds). */
+  notarize?: boolean;
+  extraPlist?: Record<string, string | number | boolean>;
+  backend?: "appkit" | "gtk";
+}
+
+export interface LinuxPackageConfig {
+  /** AppDir seed tree copied before generated files land. */
+  appDirTemplate?: string;
+  format?: "appimage" | "appdir";
+  /** Extra/overriding .desktop entry lines. */
+  desktopEntry?: Record<string, string>;
+}
+
+export interface PackageConfig {
+  /** Source entry, app-relative. Default "src/main.tsx". */
+  entry?: string;
+  /** Default "auto": run the app's `compile` script when it declares one. */
+  compile?: "auto" | false | { script?: string; outDir?: string; entry?: string };
+  /** App-relative, e.g. "../..". The bundle app root mirrors this directory. Default: the app dir itself. */
+  workspaceRoot?: string;
+  /** Extra workspace-relative dirs/files copied into the bundle app root. */
+  include?: string[];
+  /** Extra roots for the runtime module-graph walk. */
+  runtimeDependencies?: string[];
+  /** Default "dist" (resolved against workspaceRoot). */
+  outDir?: string;
+  bunPath?: string;
+  mac?: MacPackageConfig;
+  linux?: LinuxPackageConfig;
+  updates?: UpdatesConfig;
+}
+
+export interface NativeDesktopConfig {
+  native?: { plugins?: NativePluginConfig[] };
+  app?: AppIdentity;
+  package?: PackageConfig;
+}
+
+export function defineConfig(config: NativeDesktopConfig): NativeDesktopConfig { return config; }
+
+export async function loadConfig(cwd = process.cwd()): Promise<NativeDesktopConfig> {
+  const path = resolve(cwd, "nativedesktop.config.ts");
+  if (!existsSync(path)) return {};
+  const mod = await import(pathToFileURL(path).href);
+  return (mod.default ?? {}) as NativeDesktopConfig;
+}
+
+export async function buildNativePlugins(config: NativeDesktopConfig, cwd = process.cwd()): Promise<string[]> {
+  const platform = process.platform;
+  if (platform !== "darwin" && platform !== "linux") return [];
+  const jobs: { output: string; build?: NativeBuildCommand }[] = [];
+  for (const plugin of config.native?.plugins ?? []) {
+    const declared = plugin[platform] ?? plugin.path;
+    if (!declared) {
+      if (!plugin.path && !plugin.darwin && !plugin.linux) throw new Error("nd: native plugin requires path, darwin, or linux output");
+      console.error(`nd: skipping native plugin (no ${platform} output)`);
+      continue;
+    }
+    const output = resolve(cwd, declared);
+    const configured = plugin.build;
+    const build = configured && "command" in configured
+      ? configured as NativeBuildCommand
+      : (configured as Partial<Record<"darwin" | "linux", NativeBuildCommand>> | undefined)?.[platform];
+    const stale = build && needsBuild(output, ["nativedesktop.config.ts", ...(build.inputs ?? [])], cwd);
+    jobs.push({ output, build: stale ? build : undefined });
+  }
+  const pending = jobs.filter((job) => job.build);
+  if (pending.length) {
+    const env = buildCommandEnv(cwd, platform);
+    await Promise.all(pending.map(async ({ build }) => {
+      const proc = Bun.spawn(build!.command, { cwd, env, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+      const [out, err, status] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+      if (out) process.stdout.write(out);
+      if (err) process.stderr.write(err);
+      if (status !== 0) throw new Error(`nd: native build failed (${build!.command.join(" ")})`);
+    }));
+  }
+  const outputs: string[] = [];
+  for (const { output } of jobs) {
+    if (!existsSync(output)) throw new Error(`nd: native plugin output not found: ${output}`);
+    outputs.push(output);
+  }
+  return outputs;
+}
+
+/** Env for plugin build commands: on darwin, scrub Nix/SDK overrides that break
+ * xcrun/swiftc and pin DEVELOPER_DIR to the selected Xcode; everywhere, expose
+ * the installed @nativedesktop/native package root as ND_NATIVE_PACKAGE. */
+function buildCommandEnv(cwd: string, platform: "darwin" | "linux"): Record<string, string | undefined> {
+  const env: Record<string, string | undefined> = { ...process.env };
+  if (platform === "darwin") {
+    delete env.SDKROOT;
+    delete env.DEVELOPER_SDK_DIR;
+    delete env.NIX_CFLAGS_COMPILE;
+    delete env.NIX_LDFLAGS;
+    // xcode-select -p echoes an inherited DEVELOPER_DIR back, so query with it
+    // cleared to read the machine's actual selection.
+    const xcode = Bun.spawnSync(["xcode-select", "-p"], { env: { ...env, DEVELOPER_DIR: undefined } });
+    if (xcode.exitCode === 0) env.DEVELOPER_DIR = xcode.stdout.toString().trim();
+  }
+  try {
+    env.ND_NATIVE_PACKAGE = dirname(Bun.resolveSync("@nativedesktop/native/package.json", cwd));
+  } catch {
+    // App has no @nativedesktop/native dependency — leave the variable unset.
+  }
+  return env;
+}
+
+function needsBuild(output: string, inputs: string[], cwd: string): boolean {
+  const resolved = inputs.map((input) => resolve(cwd, input));
+  for (const input of resolved) {
+    if (!existsSync(input)) throw new Error(`nd: native build input not found: ${input}`);
+  }
+  if (!existsSync(output)) return true;
+  const outputTime = statSync(output).mtimeMs;
+  return resolved.some((input) => newestMtime(input) > outputTime);
+}
+
+function newestMtime(path: string): number {
+  const stat = statSync(path);
+  if (!stat.isDirectory()) return stat.mtimeMs;
+  const glob = new Bun.Glob("**/*");
+  let newest = stat.mtimeMs;
+  for (const relative of glob.scanSync({ cwd: path, onlyFiles: true })) newest = Math.max(newest, statSync(resolve(path, relative)).mtimeMs);
+  return newest;
+}

package/src/index.ts

@@ -0,0 +1,184 @@
+#!/usr/bin/env bun
+// nd — the NativeDesktop CLI. Wraps the invocations documented in
+// docs/agents/README.md / template/AGENTS.md so there is one real command
+// instead of a hand-typed env-var incantation:
+//   `nd dev [entry]`  ==  ND_DEV=1 ND_SCRIPT=<entry> <host-binary-from-@nativedesktop/host>
+//   `nd build`        ==  bun run compile   (babel + react-compiler pre-pass, see template/README.md)
+//   `nd package`      ==  assemble + sign the platform bundle (packages/nd/src/package/)
+//   `nd doctor`       ==  packaging/toolchain readiness checks
+import { type Backend, resolveHostBinary } from "@nativedesktop/host";
+import { buildNativePlugins, loadConfig } from "./config.ts";
+import { packageApp, type PackageOptions } from "./package/index.ts";
+
+const DEFAULT_ENTRY = "src/main.tsx";
+
+async function nativeEnv(): Promise<Record<string, string>> {
+  const paths = await buildNativePlugins(await loadConfig());
+  return paths.length ? { ND_PLUGINS: "1", ND_PLUGIN_PATHS: paths.join(":") } : {};
+}
+
+async function runDev(entry: string, backend?: Backend): Promise<number> {
+  const hostBinary = await resolveHostBinary({ backend });
+  const proc = Bun.spawn([hostBinary], {
+    cwd: process.cwd(),
+    env: { ...process.env, ...(await nativeEnv()), ND_DEV: "1", ND_SCRIPT: entry },
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  return proc.exited;
+}
+
+async function runBuild(): Promise<number> {
+  // Production plugin wiring is the app's packaging responsibility; we only
+  // make sure the native artifacts are built and fresh.
+  await buildNativePlugins(await loadConfig());
+  const proc = Bun.spawn(["bun", "run", "compile"], {
+    cwd: process.cwd(),
+    env: process.env,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  return proc.exited;
+}
+
+function usage(): void {
+  console.error(
+    [
+      "Usage:",
+      "  nd dev [entry] [--backend gtk|appkit]",
+      "                   run the app in dev mode (ND_DEV=1, hot reload + crash overlay)",
+      `                   entry defaults to "${DEFAULT_ENTRY}"`,
+      "                   backend defaults to appkit on macOS, gtk elsewhere (also honors ND_BACKEND);",
+      "                   --backend gtk cross-checks the GTK host, --backend appkit forces the macOS shell",
+      "  nd build         compile the app for production (bun run compile)",
+      "  nd package [mac|linux] [--out <dir>] [--entry <file>] [--version <v>] [--cwd <dir>]",
+      "             [--no-compile] [--sign <identity>|--no-sign] [--notarize|--no-notarize]",
+      "             [--format appimage|appdir]",
+      "                   assemble + sign the platform bundle (platform defaults to the host;",
+      "                   Windows lands with M7)",
+      "  nd doctor [--json]",
+      "                   check packaging/toolchain readiness for the current directory",
+    ].join("\n"),
+  );
+}
+
+/** Parse `nd package` args. Exits 2 on an unsupported platform (Windows unchanged). */
+export function parsePackageArgs(args: string[], platform: string = process.platform): PackageOptions {
+  let target: PackageOptions["platform"] | undefined;
+  const opts: Omit<PackageOptions, "platform"> = {};
+  const takeValue = (flag: string, value: string | undefined): string => {
+    if (value === undefined) {
+      console.error(`nd: ${flag} expects a value\n`);
+      usage();
+      process.exit(1);
+    }
+    return value;
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === "--out") opts.outDir = takeValue(arg, args[++i]);
+    else if (arg === "--entry") opts.entry = takeValue(arg, args[++i]);
+    else if (arg === "--version") opts.version = takeValue(arg, args[++i]);
+    else if (arg === "--cwd") opts.cwd = takeValue(arg, args[++i]);
+    else if (arg === "--no-compile") opts.compile = false;
+    else if (arg === "--sign") opts.signIdentity = takeValue(arg, args[++i]);
+    else if (arg === "--no-sign") opts.signIdentity = null;
+    else if (arg === "--notarize") opts.notarize = true;
+    else if (arg === "--no-notarize") opts.notarize = false;
+    else if (arg === "--format") {
+      const format = takeValue(arg, args[++i]);
+      if (format !== "appimage" && format !== "appdir") {
+        console.error(`nd: --format expects "appimage" or "appdir" (got "${format}")\n`);
+        usage();
+        process.exit(1);
+      }
+      opts.format = format;
+    } else if (!arg.startsWith("-") && target === undefined) {
+      if (arg !== "mac" && arg !== "linux") {
+        console.error(`nd package: unsupported platform "${arg}" (Windows lands with M7)\n`);
+        usage();
+        process.exit(2);
+      }
+      target = arg;
+    } else {
+      console.error(`nd: unexpected argument "${arg}"\n`);
+      usage();
+      process.exit(1);
+    }
+  }
+  if (target === undefined) {
+    if (platform === "darwin") target = "mac";
+    else if (platform === "linux") target = "linux";
+    else {
+      console.error(`nd package: unsupported host platform "${platform}" (Windows lands with M7)\n`);
+      usage();
+      process.exit(2);
+    }
+  }
+  return { platform: target, ...opts };
+}
+
+/** Parse `[entry] [--backend gtk|appkit]` in any order. Returns undefined backend to defer to ND_BACKEND / platform default. */
+function parseDevArgs(args: string[]): { entry: string; backend?: Backend } {
+  let entry: string | undefined;
+  let backend: Backend | undefined;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === "--backend") backend = expectBackend(args[++i]);
+    else if (arg.startsWith("--backend=")) backend = expectBackend(arg.slice("--backend=".length));
+    else if (!arg.startsWith("-") && entry === undefined) entry = arg;
+    else {
+      console.error(`nd: unexpected argument "${arg}"\n`);
+      usage();
+      process.exit(1);
+    }
+  }
+  return { entry: entry ?? DEFAULT_ENTRY, backend };
+}
+
+function expectBackend(value: string | undefined): Backend {
+  if (value !== "gtk" && value !== "appkit") {
+    console.error(`nd: --backend expects "gtk" or "appkit" (got "${value ?? ""}")\n`);
+    usage();
+    process.exit(1);
+  }
+  return value;
+}
+
+async function main(): Promise<void> {
+  const [cmd, ...rest] = process.argv.slice(2);
+  switch (cmd) {
+    case "dev": {
+      const { entry, backend } = parseDevArgs(rest);
+      process.exit(await runDev(entry, backend));
+      break;
+    }
+    case "build":
+      process.exit(await runBuild());
+      break;
+    case "package":
+      await packageApp(parsePackageArgs(rest));
+      process.exit(0);
+      break;
+    case "doctor": {
+      const json = rest.includes("--json");
+      const extra = rest.filter((arg) => arg !== "--json");
+      if (extra.length) {
+        console.error(`nd: unexpected argument "${extra[0]}"\n`);
+        usage();
+        process.exit(1);
+      }
+      const { runDoctor } = await import("./package/doctor.ts");
+      process.exit(await runDoctor(process.cwd(), json));
+      break;
+    }
+    default:
+      if (cmd) console.error(`nd: unknown command "${cmd}"\n`);
+      usage();
+      process.exit(1);
+  }
+}
+
+if (import.meta.main) await main();

package/src/package/doctor.ts

@@ -0,0 +1,110 @@
+// `nd doctor`: checks the current directory's packaging readiness and the
+// host toolchain. Warnings are advisory; only real gaps (a config that names
+// missing files, an unresolvable host binary) exit non-zero.
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { hostBinaryCandidates, prebuiltHostBinary, resolveBackend } from "@nativedesktop/host";
+import { loadConfig, type NativeDesktopConfig } from "../config.ts";
+import { DEFAULT_ENTRY } from "./payload.ts";
+
+export type CheckStatus = "ok" | "warn" | "error";
+
+export interface Check {
+  name: string;
+  status: CheckStatus;
+  detail: string;
+}
+
+function which(tool: string): boolean {
+  return Bun.which(tool) !== null;
+}
+
+export async function collectChecks(cwd: string): Promise<Check[]> {
+  const checks: Check[] = [];
+  const configPath = resolve(cwd, "nativedesktop.config.ts");
+  let config: NativeDesktopConfig = {};
+  if (!existsSync(configPath)) {
+    checks.push({ name: "config", status: "warn", detail: "no nativedesktop.config.ts here (defaults apply)" });
+  } else {
+    try {
+      config = await loadConfig(cwd);
+      checks.push({ name: "config", status: "ok", detail: "nativedesktop.config.ts loads" });
+    } catch (err) {
+      checks.push({ name: "config", status: "error", detail: `nativedesktop.config.ts failed to load: ${err}` });
+      return checks;
+    }
+  }
+
+  const hasConfig = existsSync(configPath);
+  if (config.app?.id) {
+    checks.push({ name: "app.id", status: "ok", detail: config.app.id });
+  } else {
+    // Icons, mime registration, and update manifests all key off app.id; a
+    // configured app without one is an error, a bare directory just a warning.
+    const status: CheckStatus = hasConfig && (config.app || config.package) ? "error" : "warn";
+    checks.push({ name: "app.id", status, detail: "app.id not set (required for icons, file associations, and updates)" });
+  }
+
+  const entry = config.package?.entry ?? DEFAULT_ENTRY;
+  if (existsSync(resolve(cwd, entry))) {
+    checks.push({ name: "entry", status: "ok", detail: entry });
+  } else {
+    checks.push({
+      name: "entry",
+      status: hasConfig ? "error" : "warn",
+      detail: `entry ${entry} not found (set package.entry)`,
+    });
+  }
+
+  checks.push(which("bun")
+    ? { name: "bun", status: "ok", detail: Bun.which("bun")! }
+    : { name: "bun", status: "error", detail: "bun not found on PATH" });
+
+  try {
+    const backend = resolveBackend(process.platform === "darwin" ? { backend: config.package?.mac?.backend ?? "appkit" } : { backend: "gtk" });
+    const { fresh } = hostBinaryCandidates(backend);
+    const found = prebuiltHostBinary(backend) ?? fresh.find(existsSync);
+    checks.push(found
+      ? { name: "host", status: "ok", detail: found }
+      : { name: "host", status: "warn", detail: `no ${backend} host binary built yet (nd dev / nd package builds it on first run in a source checkout)` });
+  } catch (err) {
+    checks.push({ name: "host", status: "error", detail: String(err) });
+  }
+
+  if (process.platform === "darwin") {
+    checks.push(which("codesign")
+      ? { name: "codesign", status: "ok", detail: "codesign available" }
+      : { name: "codesign", status: "error", detail: "codesign not found (install the Xcode command line tools)" });
+    const icon = typeof config.app?.icon === "string" ? config.app.icon : config.app?.icon?.macos ?? config.app?.icon?.source;
+    if (icon && icon.endsWith(".png") && !(which("sips") && which("iconutil"))) {
+      checks.push({ name: "icon-tools", status: "error", detail: "PNG icon configured but sips/iconutil are missing" });
+    }
+  } else if (process.platform === "linux") {
+    checks.push(which("appimagetool") || which("mksquashfs")
+      ? { name: "appimage", status: "ok", detail: which("appimagetool") ? "appimagetool available" : "mksquashfs fallback available" }
+      : { name: "appimage", status: "warn", detail: "neither appimagetool nor mksquashfs on PATH (only the raw AppDir can be produced)" });
+  }
+
+  if (config.package?.updates) {
+    checks.push(which("minisign")
+      ? { name: "updates", status: "ok", detail: "updates configured, minisign available" }
+      : { name: "updates", status: "error", detail: "updates configured but minisign is not on PATH" });
+  } else {
+    checks.push({ name: "updates", status: "warn", detail: "package.updates not configured: the shipped app has no updater" });
+  }
+
+  return checks;
+}
+
+const GLYPH: Record<CheckStatus, string> = { ok: "ok  ", warn: "warn", error: "FAIL" };
+
+/** Runs the check table against `cwd`, prints it (or JSON), returns the exit code. */
+export async function runDoctor(cwd: string, json: boolean): Promise<number> {
+  const checks = await collectChecks(cwd);
+  if (json) {
+    console.log(JSON.stringify(checks, null, 2));
+  } else {
+    for (const check of checks) console.log(`${GLYPH[check.status]}  ${check.name.padEnd(12)} ${check.detail}`);
+  }
+  return checks.some((check) => check.status === "error") ? 1 : 0;
+}

package/src/package/icons.test.ts

@@ -0,0 +1,61 @@
+// Linux icon degrade paths: resizers are probed, never hard-required, and a
+// broken resizer must not abort packaging. Each scenario runs in a subprocess
+// whose PATH holds only the fixture's fake tools, because Bun.which and spawn
+// resolve against the process's startup PATH.
+import { describe, expect, test } from "bun:test";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const ICONS_MODULE = join(import.meta.dir, "icons.ts");
+
+function fixture(tools: (root: string) => Record<string, string>): { root: string; appDir: string; appdir: string; bin: string } {
+  const root = mkdtempSync(join(tmpdir(), "nd-icons-"));
+  const appDir = join(root, "app");
+  const appdir = join(root, "AppDir");
+  mkdirSync(appDir, { recursive: true });
+  mkdirSync(appdir, { recursive: true });
+  writeFileSync(join(appDir, "icon.png"), "png bytes");
+  const bin = join(root, "bin");
+  mkdirSync(bin, { recursive: true });
+  for (const [name, script] of Object.entries(tools(root))) {
+    const file = join(bin, name);
+    writeFileSync(file, `#!/bin/sh\n${script}\n`);
+    chmodSync(file, 0o755);
+  }
+  return { root, appDir, appdir, bin };
+}
+
+function runInstall(appDir: string, appdir: string, path: string): { exitCode: number; stderr: string } {
+  const script = `
+    import { installLinuxIcon } from ${JSON.stringify(ICONS_MODULE)};
+    await installLinuxIcon(
+      { name: "Fixture", displayName: "Fixture", slug: "fixture", version: "1.0.0", categories: ["Utility"], icon: { source: "icon.png" } },
+      ${JSON.stringify(appDir)},
+      ${JSON.stringify(appdir)},
+    );
+  `;
+  const proc = Bun.spawnSync([process.execPath, "-e", script], { env: { PATH: path } });
+  return { exitCode: proc.exitCode, stderr: proc.stderr.toString() };
+}
+
+describe("installLinuxIcon", () => {
+  test("a failing resizer degrades to the root icon instead of aborting", () => {
+    const { appDir, appdir, bin } = fixture(() => ({ sips: "exit 1" }));
+    const { exitCode, stderr } = runInstall(appDir, appdir, bin);
+    expect(exitCode).toBe(0);
+    expect(stderr).toContain("ND_PACKAGE_ICON_SKIPPED reason=resize-failed");
+    expect(existsSync(join(appdir, "fixture.png"))).toBe(true);
+    expect(existsSync(join(appdir, "usr/share/icons/hicolor"))).toBe(false);
+  });
+
+  test("rsvg-convert is never probed for a PNG source", () => {
+    const { root, appDir, appdir, bin } = fixture((r) => ({ "rsvg-convert": `touch "${r}/invoked"; exit 1` }));
+    const { exitCode, stderr } = runInstall(appDir, appdir, bin);
+    expect(exitCode).toBe(0);
+    expect(stderr).toContain("ND_PACKAGE_ICON_SKIPPED reason=no-resizer");
+    expect(existsSync(join(root, "invoked"))).toBe(false);
+    expect(existsSync(join(appdir, "fixture.png"))).toBe(true);
+    expect(existsSync(join(appdir, "usr/share/icons/hicolor"))).toBe(false);
+  });
+});