@nativedesktop/cli 0.1.2 → 0.3.0

package/src/package/linux.ts

@@ -6,7 +6,9 @@ import { $ } from "bun";
 import { chmodSync, cpSync, mkdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { resolveHostBinary } from "@nativedesktop/host";
-import type { NativeDesktopConfig } from "../config.ts";
+import { cefPlatformKey } from "@nativedesktop/host/cef";
+import { type NativeDesktopConfig, resolveCefSchemes, resolveWebViewEngine } from "../config.ts";
+import { applyCefLinuxPlan, cefVersionFor, ensureCefDist, planCefLinux } from "./cef.ts";
 import { installLinuxIcon } from "./icons.ts";
 import { buildAppRun, buildDesktopEntry, buildMimeInfoXml, type ResolvedIdentity } from "./identity.ts";
 import { assemblePayload } from "./payload.ts";
@@ -28,11 +30,15 @@ export async function packageLinuxApp(
   }
   mkdirSync(join(appdir, "usr", "bin"), { recursive: true });
 
+  const engine = resolveWebViewEngine(config, "linux");
+  const schemes = resolveCefSchemes(config);
   const payload = await assemblePayload({
     appDir,
     config,
     identity,
     appRoot: join(appdir, "app"),
+    engine,
+    schemes,
     entry: options.entry,
     compile: options.compile,
   });
@@ -43,6 +49,8 @@ export async function packageLinuxApp(
     slug: identity.slug,
     appId: identity.id,
     pluginPaths: payload.pluginPaths,
+    engine,
+    schemes,
   }));
   chmodSync(join(appdir, "AppRun"), 0o755);
   writeFileSync(join(appdir, `${identity.slug}.desktop`), buildDesktopEntry(identity, linux));
@@ -64,6 +72,14 @@ export async function packageLinuxApp(
   cpSync(bunPath, join(appdir, "usr", "bin", "bun"), { dereference: true });
   chmodSync(join(appdir, "usr", "bin", "bun"), 0o755);
 
+  if (engine === "chromium") {
+    const version = cefVersionFor(config.webview?.cef);
+    const distRoot = await ensureCefDist({ cefPlatform: cefPlatformKey("linux", process.arch), version });
+    const plan = planCefLinux({ distRoot, appDir: appdir, locales: config.webview?.cef?.locales });
+    await applyCefLinuxPlan(plan);
+    console.error(`ND_PACKAGE_CEF ${plan.root} version=${version} locales=${plan.locales.length}`);
+  }
+
   let bundlePath = appdir;
   const format = options.format ?? linux?.format ?? "appimage";
   if (format === "appimage") {

package/src/package/mac.ts

@@ -6,7 +6,18 @@ import { $ } from "bun";
 import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { resolveHostBinary } from "@nativedesktop/host";
-import type { NativeDesktopConfig } from "../config.ts";
+import { cefPlatformKey } from "@nativedesktop/host/cef";
+import { type NativeDesktopConfig, resolveCefSchemes, resolveWebViewEngine } from "../config.ts";
+import {
+  applyCefMacPlan,
+  type CefMacPlan,
+  cefMacSignTargets,
+  cefVersionFor,
+  ensureCefDist,
+  ensureCefHelperBinary,
+  planCefMac,
+  writeCefHelperEntitlements,
+} from "./cef.ts";
 import { installMacIcon } from "./icons.ts";
 import { buildInfoPlist, type ResolvedIdentity } from "./identity.ts";
 import { assemblePayload } from "./payload.ts";
@@ -14,6 +25,33 @@ import { ENTITLEMENTS_PLIST } from "./templates.ts";
 import { maybePublishUpdate } from "./updates.ts";
 import type { PackageOptions, PackageResult } from "./index.ts";
 
+/** Downloads (or reuses) the pinned CEF dist and stages the framework plus the
+ * five helper .apps into Contents/Frameworks. Returns the plan so the signing
+ * pass below can walk the same targets. */
+async function stageCefMac(
+  config: NativeDesktopConfig,
+  identity: ResolvedIdentity,
+  contents: string,
+  hostBinary: string,
+  minimumSystemVersion: string,
+): Promise<CefMacPlan> {
+  if (!identity.id) throw new Error('nd: webview engine "chromium" needs app.id (the CEF helper bundle ids derive from it)');
+  const version = cefVersionFor(config.webview?.cef);
+  const distRoot = await ensureCefDist({ cefPlatform: cefPlatformKey("darwin", process.arch), version });
+  const plan = planCefMac({
+    distRoot,
+    contents,
+    appName: identity.name,
+    appId: identity.id,
+    version: identity.version,
+    minimumSystemVersion,
+    helperBinary: await ensureCefHelperBinary(hostBinary),
+  });
+  applyCefMacPlan(plan);
+  console.error(`ND_PACKAGE_CEF ${plan.framework.to} version=${version}`);
+  return plan;
+}
+
 /** Notarization decision: an explicit flag/config wins; the auto default needs credentials AND a signed bundle. */
 export function resolveNotarize(explicit: boolean | undefined, creds: boolean, signed: boolean): boolean {
   return explicit ?? (creds && signed);
@@ -34,11 +72,14 @@ export async function packageMacApp(
   mkdirSync(join(c, "Resources"), { recursive: true });
   mkdirSync(join(c, "Frameworks"), { recursive: true });
 
+  const engine = resolveWebViewEngine(config, "mac");
   await assemblePayload({
     appDir,
     config,
     identity,
     appRoot: join(c, "Resources", "app"),
+    engine,
+    schemes: resolveCefSchemes(config),
     entry: options.entry,
     compile: options.compile,
   });
@@ -55,7 +96,12 @@ export async function packageMacApp(
   cpSync(bunPath, join(c, "MacOS", "bun"), { dereference: true });
   chmodSync(join(c, "MacOS", "bun"), 0o755);
 
-  const iconFile = await installMacIcon(identity, appDir, join(c, "Resources"), mac?.minimumSystemVersion ?? "26.0");
+  const minimumSystemVersion = mac?.minimumSystemVersion ?? "26.0";
+  const cefPlan = engine === "chromium"
+    ? await stageCefMac(config, identity, c, hostBinary, minimumSystemVersion)
+    : undefined;
+
+  const iconFile = await installMacIcon(identity, appDir, join(c, "Resources"), minimumSystemVersion);
   const customXml = mac?.infoPlist ? readFileSync(resolve(appDir, mac.infoPlist), "utf8") : undefined;
   writeFileSync(join(c, "Info.plist"), buildInfoPlist(identity, mac, customXml, iconFile));
 
@@ -73,10 +119,22 @@ export async function packageMacApp(
     const plugins = existsSync(nativeDir)
       ? [...new Bun.Glob("*.dylib").scanSync({ cwd: nativeDir, absolute: true })].sort()
       : [];
+    if (cefPlan) {
+      // The renderer and GPU helpers carry entitlements the app's own do not,
+      // and `--deep` re-signs nested code with whatever it was handed, which
+      // would drop them. So the CEF payload is enumerated and signed
+      // inside-out here, and the outer sign below drops --deep.
+      const helperEnt = writeCefHelperEntitlements(dist);
+      for (const target of cefMacSignTargets(cefPlan)) {
+        if (target.jit) await $`codesign --force --options runtime --entitlements ${helperEnt} --sign ${sign} ${target.path}`;
+        else await $`codesign --force --options runtime --sign ${sign} ${target.path}`;
+      }
+    }
     for (const nested of [join(c, "MacOS", "bun"), exe, ...plugins]) {
       await $`codesign --force --options runtime --entitlements ${ent} --sign ${sign} ${nested}`;
     }
-    await $`codesign --force --deep --options runtime --entitlements ${ent} --sign ${sign} ${app}`;
+    if (cefPlan) await $`codesign --force --options runtime --entitlements ${ent} --sign ${sign} ${app}`;
+    else await $`codesign --force --deep --options runtime --entitlements ${ent} --sign ${sign} ${app}`;
     await $`codesign --verify --strict ${app}`;
     console.error(`ND_PACKAGE_APP_SIGNED ${app} identity=${sign === "-" ? "adhoc" : "developer-id"}`);
   }

package/src/package/modules.test.ts

@@ -142,4 +142,26 @@ describe("assertResolvableEntries", () => {
     writeFileSync(join(carrier, "package.json"), JSON.stringify({ name: "host-binary", files: ["bin"] }));
     expect(() => assertResolvableEntries(root, ["host-binary"])).not.toThrow();
   });
+
+  test("tolerates subpath-only exports (@nativedesktop/native's shape)", () => {
+    const root = mkdtempSync(join(tmpdir(), "nd-modules-"));
+    const headers = join(root, "node_modules", "header-carrier");
+    mkdirSync(headers, { recursive: true });
+    writeFileSync(
+      join(headers, "package.json"),
+      JSON.stringify({ name: "header-carrier", exports: { "./include/nd.h": "./include/nd.h" } }),
+    );
+    expect(() => assertResolvableEntries(root, ["header-carrier"])).not.toThrow();
+  });
+
+  test("still throws when exports declares a root entry that is missing", () => {
+    const root = mkdtempSync(join(tmpdir(), "nd-modules-"));
+    const broken = join(root, "node_modules", "needs-build-exports");
+    mkdirSync(broken, { recursive: true });
+    writeFileSync(
+      join(broken, "package.json"),
+      JSON.stringify({ name: "needs-build-exports", exports: { ".": "./dist/index.js" } }),
+    );
+    expect(() => assertResolvableEntries(root, ["needs-build-exports"])).toThrow("bun run build");
+  });
 });

package/src/package/modules.ts

@@ -10,9 +10,14 @@ interface QueueEntry {
   spec: string;
   /** Directory the spec resolves from (the requiring package's real root). */
   anchor: string;
+  /** Second anchor to try, used for peers whose consumer does not supply one. */
+  fallbackAnchor?: string;
   /** Dest-relative dir of the requiring package, for version-conflict nesting. */
   requirer?: string;
   optional: boolean;
+  /** A peerDependency: the CONSUMER's copy is the correct one, so an existing
+   * flat claim wins outright instead of nesting a second copy. */
+  peer?: boolean;
 }
 
 const skipNodeModules = (src: string) => basename(src) !== "node_modules";
@@ -63,12 +68,24 @@ export function flattenRuntimeModules({ appDir, extraRoots = [], dest }: Flatten
 
   while (queue.length) {
     const entry = queue.shift()!;
+    // A peer the app already provides is settled: taking the dependency's own
+    // copy instead is what puts two reacts in one bundle.
+    if (entry.peer && claimed.has(entry.spec)) continue;
     let root: string;
     try {
       root = packageRoot(entry.spec, entry.anchor);
     } catch (err) {
-      if (entry.optional) continue;
-      throw new Error(`nd: cannot resolve runtime dependency "${entry.spec}" from ${entry.anchor}: ${err}`);
+      if (entry.fallbackAnchor) {
+        try {
+          root = packageRoot(entry.spec, entry.fallbackAnchor);
+        } catch {
+          if (entry.optional) continue;
+          throw new Error(`nd: cannot resolve runtime dependency "${entry.spec}" from ${entry.anchor}: ${err}`);
+        }
+      } else {
+        if (entry.optional) continue;
+        throw new Error(`nd: cannot resolve runtime dependency "${entry.spec}" from ${entry.anchor}: ${err}`);
+      }
     }
 
     const existing = claimed.get(entry.spec);
@@ -94,14 +111,35 @@ export function flattenRuntimeModules({ appDir, extraRoots = [], dest }: Flatten
     for (const spec of Object.keys(pkg.dependencies ?? {})) {
       queue.push({ spec, anchor: root, requirer: destDir, optional: false });
     }
-    for (const spec of [...Object.keys(pkg.optionalDependencies ?? {}), ...Object.keys(pkg.peerDependencies ?? {})]) {
+    for (const spec of Object.keys(pkg.optionalDependencies ?? {})) {
       queue.push({ spec, anchor: root, requirer: destDir, optional: true });
     }
+    // Peers resolve from the APP, not from the package that declares them. A
+    // `file:` linked dependency living outside the app tree resolves its own
+    // peer to its own copy, and a second react in the bundle is the classic
+    // "Invalid hook call" at launch. The package's root is only the fallback,
+    // for a peer the app does not provide at all.
+    for (const spec of Object.keys(pkg.peerDependencies ?? {})) {
+      queue.push({ spec, anchor, fallbackAnchor: root, requirer: destDir, optional: true, peer: true });
+    }
   }
 
   return [...claimed.keys()];
 }
 
+/**
+ * Whether `exports` offers the package's ROOT specifier. A string is one; an
+ * object is one only through a `"."` key or the conditions shorthand (keys that
+ * are not subpaths). A subpath-only map (`{"./include/nd.h": …}`, which is what
+ * `@nativedesktop/native` publishes) declares no root entry, so failing to
+ * resolve the bare name is correct rather than a missing build.
+ */
+function declaresRootEntry(exports: unknown): boolean {
+  if (typeof exports === "string") return true;
+  if (exports === null || typeof exports !== "object") return false;
+  return Object.keys(exports).some((key) => key === "." || !key.startsWith("."));
+}
+
 /**
  * Asserts each flat package's main/exports entry resolves inside the bundle.
  * Catches a copied-but-unbuilt package (e.g. @nativedesktop/react without its
@@ -119,7 +157,7 @@ export function assertResolvableEntries(appRoot: string, names: string[]): void
         module?: string;
         exports?: unknown;
       };
-      if (pkg.main === undefined && pkg.module === undefined && pkg.exports === undefined) continue;
+      if (pkg.main === undefined && pkg.module === undefined && !declaresRootEntry(pkg.exports)) continue;
       throw new Error(
         `nd: bundled package "${name}" has no resolvable entry (its build output is missing). ` +
         `Run \`bun run build\` in ${name} and package again.`,

package/src/package/payload.test.ts

@@ -82,6 +82,8 @@ describe("assemblePayload", () => {
       config: { package: { workspaceRoot: "../..", include: ["shared"], compile: false } },
       identity,
       appRoot,
+      engine: "chromium",
+      schemes: ["nbext"],
     });
 
     expect(result).toEqual({ entry: "apps/fixture/src/main.tsx", cwd: "apps/fixture", pluginPaths: [] });
@@ -96,6 +98,8 @@ describe("assemblePayload", () => {
       entry: "apps/fixture/src/main.tsx",
       cwd: "apps/fixture",
       pluginPaths: [],
+      engine: "chromium",
+      schemes: ["nbext"],
     });
   });
 
@@ -117,7 +121,7 @@ describe("assemblePayload", () => {
     for (const dir of ["MacOS", "Resources", "Frameworks"]) mkdirSync(join(contents, dir), { recursive: true });
     const appRoot = join(contents, "Resources", "app");
 
-    const result = await assemblePayload({ appDir, config: {}, identity, appRoot });
+    const result = await assemblePayload({ appDir, config: {}, identity, appRoot, engine: "system", schemes: [] });
 
     expect(result).toEqual({ entry: "dist/main.tsx", cwd: ".", pluginPaths: [] });
     expect(existsSync(join(appRoot, "dist/main.tsx"))).toBe(true);
@@ -125,6 +129,31 @@ describe("assemblePayload", () => {
     expect(existsSync(join(appRoot, "dist", "mac"))).toBe(false);
   });
 
+  test("--out elsewhere: a previous run's bundle is left out of the payload", async () => {
+    const appDir = mkdtempSync(join(tmpdir(), "nd-payload-out-"));
+    mkdirSync(join(appDir, "src"), { recursive: true });
+    writeFileSync(join(appDir, "package.json"), JSON.stringify({ name: "fixture", version: "1.0.0" }));
+    writeFileSync(join(appDir, "src", "main.tsx"), "export {};\n");
+    mkdirSync(join(appDir, "dist"), { recursive: true });
+    writeFileSync(join(appDir, "dist", "main.tsx"), "export {};\n");
+    // What `nd package mac` wrote last time, in the default output dir.
+    mkdirSync(join(appDir, "dist", "mac", "Fixture.app", "Contents", "Frameworks"), { recursive: true });
+    writeFileSync(join(appDir, "dist", "mac", "Fixture.app", "Contents", "Frameworks", "big.bin"), "x");
+
+    const appRoot = join(mkdtempSync(join(tmpdir(), "nd-payload-out2-")), "mac", "Fixture.app", "Contents", "Resources", "app");
+    await assemblePayload({
+      appDir,
+      config: { package: { compile: false, entry: "dist/main.tsx" } },
+      identity,
+      appRoot,
+      engine: "system",
+      schemes: [],
+    });
+
+    expect(existsSync(join(appRoot, "dist/main.tsx"))).toBe(true);
+    expect(existsSync(join(appRoot, "dist", "mac"))).toBe(false);
+  });
+
   test("root-level entry ships the whole app dir minus node_modules", async () => {
     const root = mkdtempSync(join(tmpdir(), "nd-payload-"));
     const appDir = join(root, "app");
@@ -140,6 +169,8 @@ describe("assemblePayload", () => {
       config: { package: { entry: "main.tsx", compile: false } },
       identity,
       appRoot,
+      engine: "system",
+      schemes: [],
     });
 
     expect(result).toEqual({ entry: "main.tsx", cwd: ".", pluginPaths: [] });

package/src/package/payload.ts

@@ -4,7 +4,7 @@
 // workspace-relative path and relative imports keep resolving packaged.
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, join, relative, resolve, sep } from "node:path";
-import { buildNativePlugins, type NativeDesktopConfig, type PackageConfig } from "../config.ts";
+import { buildNativePlugins, type NativeDesktopConfig, type PackageConfig, type WebViewEngine } from "../config.ts";
 import type { ResolvedIdentity } from "./identity.ts";
 import { assertResolvableEntries, flattenRuntimeModules } from "./modules.ts";
 
@@ -40,6 +40,12 @@ export interface PayloadOptions {
   identity: ResolvedIdentity;
   /** The bundle's app root (Resources/app or AppDir/app). */
   appRoot: string;
+  /** Engine this bundle was staged for. Recorded in the manifest so the
+   * packaged launch path hands the host what `nd dev` hands it, with no shell
+   * in between. */
+  engine: WebViewEngine;
+  /** Launch-declared CEF schemes, recorded for the same reason. */
+  schemes: string[];
   /** CLI --entry override (app-relative source entry). */
   entry?: string;
   /** false forces raw source (--no-compile). */
@@ -108,14 +114,22 @@ export async function assemblePayload(o: PayloadOptions): Promise<PayloadResult>
     }
   }
 
+  // Bundles a previous run left in the output dir. Under the default config
+  // they sit inside the compile outDir ("dist/mac", "dist/linux" beside
+  // "dist/main.tsx"), so without this a run whose own output lands elsewhere
+  // (`--out`) ships the last .app inside the new one, CEF payload and all.
+  const bundleOut = resolve(workspaceRoot, pkg.outDir ?? "dist");
+  const platformOutputs = new Set([join(bundleOut, "mac"), join(bundleOut, "linux")]);
+  const skipBuiltBundles = (src: string) => !platformOutputs.has(resolve(src));
+
   mkdirSync(destAppDir, { recursive: true });
   const entryDir = entry.includes("/") ? entry.split("/")[0]! : null;
   if (entryDir) {
-    copyPayloadTree(join(appDir, entryDir), join(destAppDir, entryDir), o.appRoot, skipNodeModules);
+    const skip = (src: string) => skipNodeModules(src) && skipBuiltBundles(src);
+    copyPayloadTree(join(appDir, entryDir), join(destAppDir, entryDir), o.appRoot, skip);
   } else {
     // Root-level entry: ship the whole app dir (minus node_modules and any
     // build output nested inside it, which would recurse into the copy).
-    const bundleOut = resolve(workspaceRoot, pkg.outDir ?? "dist");
     const skip = (src: string) => skipNodeModules(src) && resolve(src) !== bundleOut;
     copyPayloadTree(appDir, destAppDir, o.appRoot, skip);
   }
@@ -154,6 +168,8 @@ export async function assemblePayload(o: PayloadOptions): Promise<PayloadResult>
     entry: appEntry,
     cwd,
     pluginPaths,
+    engine: o.engine,
+    schemes: o.schemes,
   }, null, 2)}\n`);
 
   return { entry: appEntry, cwd, pluginPaths };

package/src/package/templates.ts

@@ -47,6 +47,44 @@ export const ENTITLEMENTS_PLIST =
   "    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>\n    <true/>\n" +
   "</dict>\n</plist>\n";
 
+export interface CefHelperPlistFields {
+  /** "<App> Helper (Renderer)" and friends. Also the executable name. */
+  name: string;
+  id: string;
+  version: string;
+  minimumSystemVersion: string;
+}
+
+/** Info.plist for one CEF helper .app. LSUIElement keeps the five subprocesses
+ * out of the Dock and the app switcher; without it every renderer launch would
+ * flash a second icon. */
+export function cefHelperPlist(f: CefHelperPlistFields): string {
+  return infoPlistSkeleton({
+    name: f.name,
+    displayName: f.name,
+    id: f.id,
+    executable: f.name,
+    version: f.version,
+    minimumSystemVersion: f.minimumSystemVersion,
+  }).replace("</dict>\n</plist>", "    <key>LSUIElement</key><string>1</string>\n</dict>\n</plist>");
+}
+
+/** Entitlements for the renderer and GPU helpers. V8 and ANGLE map executable
+ * pages the hardened runtime refuses without these, and the renderer loads the
+ * CEF framework from the outer app's signature, which library validation would
+ * reject. CEF's own sample app ships this exact set. */
+export function cefHelperEntitlements(): string {
+  return (
+    '<?xml version="1.0" encoding="UTF-8"?>\n' +
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n' +
+    '<plist version="1.0">\n<dict>\n' +
+    "    <key>com.apple.security.cs.allow-jit</key>\n    <true/>\n" +
+    "    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>\n    <true/>\n" +
+    "    <key>com.apple.security.cs.disable-library-validation</key>\n    <true/>\n" +
+    "</dict>\n</plist>\n"
+  );
+}
+
 export interface AppRunSpec {
   /** App-root-relative script the host boots. */
   entry: string;
@@ -57,6 +95,10 @@ export interface AppRunSpec {
   appId?: string;
   /** App-root-relative native plugin paths. */
   pluginPaths: string[];
+  /** Engine the AppDir was staged for. */
+  engine?: string;
+  /** Launch-declared CEF schemes. */
+  schemes?: string[];
 }
 
 export function appRunTemplate(s: AppRunSpec): string {
@@ -66,6 +108,11 @@ export function appRunTemplate(s: AppRunSpec): string {
     `export ND_SCRIPT="$HERE/app/${s.entry}"\n` +
     'export PATH="$HERE/usr/bin:$PATH"\n';
   if (s.appId) script += `export ND_APP_ID="${s.appId}"\n`;
+  // Every CEF process reads both of these, and both have to be settled before
+  // cef_initialize. The :- form keeps an explicit override ahead of the bundle,
+  // matching how the mac bootstrap defers to an already-set variable.
+  if (s.engine) script += `export ND_WEBVIEW_ENGINE="\${ND_WEBVIEW_ENGINE:-${s.engine}}"\n`;
+  if (s.schemes?.length) script += `export ND_CEF_SCHEMES="\${ND_CEF_SCHEMES:-${s.schemes.join(",")}}"\n`;
   if (s.pluginPaths.length) {
     script += 'export ND_PLUGINS="1"\n';
     script += `export ND_PLUGIN_PATHS="${s.pluginPaths.map((p) => `$HERE/app/${p}`).join(":")}"\n`;