akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/packages/cli/src/platforms/desktop-update.ts

@@ -0,0 +1,78 @@
+
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { createDelta } from "../../../desktop/src/delta.ts";
+import { runtimeVersion } from "../lib/boot.ts";
+import { execOrThrow } from "../lib/exec.ts";
+import { dim, log } from "../lib/log.ts";
+import type { BuildContext } from "../lib/prepare.ts";
+import { hostArch, sha256, type UpdateManifest } from "../lib/updates.ts";
+import { type DesktopOs, resourcesOf } from "./desktop.ts";
+
+const TAR: Record<DesktopOs, string[]> = {
+  macos: ["/usr/bin/tar", "--no-mac-metadata"],
+  windows: ["tar.exe"],
+  linux: ["tar"],
+};
+
+export async function publishAppUpdate(
+  ctx: BuildContext,
+  os: DesktopOs,
+  app: string,
+  out: string,
+  channel: string,
+  sequence: number,
+): Promise<UpdateManifest> {
+  const { config } = ctx.project;
+  const dir = join(out, "app");
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.build-${sequence}.tar`);
+  await execOrThrow([...TAR[os], "-cf", tmp, "-C", dirname(app), basename(app)], { echo: false });
+  const tar = readFileSync(tmp);
+  const tarSha = sha256(tar);
+  renameSync(tmp, join(dir, `${tarSha}.tar`));
+  const gz = Bun.gzipSync(tar, { level: 9 });
+  writeFileSync(join(dir, `${tarSha}.tar.gz`), gz);
+
+  const patches: NonNullable<UpdateManifest["patches"]> = [];
+  const previousPath = join(out, `${channel}.json`);
+  if (existsSync(previousPath)) {
+    const previous = JSON.parse(readFileSync(previousPath, "utf8")) as UpdateManifest;
+    const from = previous.archive?.sha256;
+    const base = from ? join(dir, `${from}.tar`) : "";
+    if (from && from !== tarSha && existsSync(base)) {
+      const started = performance.now();
+      const delta = Bun.gzipSync(createDelta(readFileSync(base), tar), { level: 9 });
+      const name = `${from}-${tarSha}.delta.gz`;
+      writeFileSync(join(dir, name), delta);
+      patches.push({ from, url: `app/${name}`, sha256: sha256(delta), size: delta.length });
+      log.info(
+        dim(
+          `delta from ${previous.bundle}: ${(delta.length / 1024).toFixed(0)} KiB instead of ${(gz.length / 1024 / 1024).toFixed(1)} MiB (${Math.round(performance.now() - started)} ms)`,
+        ),
+      );
+    }
+    
+    if (from && from !== tarSha) rmSync(base, { force: true });
+  }
+
+  return {
+    schema: 1,
+    kind: "app",
+    app: config.app.id,
+    platform: os,
+    channel,
+    sequence,
+    bundle: `${config.app.version}-${sequence}`,
+    runtimeVersion: runtimeVersion(),
+    version: config.app.version,
+    build: (
+      JSON.parse(readFileSync(join(resourcesOf(os, app), "updates.json"), "utf8")) as { embeddedSequence: number }
+    ).embeddedSequence,
+    arch: hostArch(),
+    files: [{ path: basename(app), sha256: tarSha, size: statSync(join(dir, `${tarSha}.tar`)).size }],
+    archive: { sha256: tarSha, url: `app/${tarSha}.tar.gz`, size: gz.length, gzSha256: sha256(gz) },
+    patches,
+  };
+}

package/vendor/@akanjs/native/packages/cli/src/platforms/desktop.ts

@@ -0,0 +1,279 @@
+
+
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import type { ParsedArgs } from "../lib/args.ts";
+import { makeNativeBoot } from "../lib/boot.ts";
+import { exec, execOrThrow } from "../lib/exec.ts";
+import { envFromProcess, follow, type Launched, type LaunchOptions, pipeLines, printLine } from "../lib/launch.ts";
+import { CliError, dim, log } from "../lib/log.ts";
+import { desktopModuleProblems, pluginFile } from "../lib/native-plugins.ts";
+import type { BuildContext } from "../lib/prepare.ts";
+import { PACKAGE_ROOT } from "../lib/root.ts";
+import { akanNativeHome } from "../lib/toolchains.ts";
+import { updatesResource } from "../lib/updates.ts";
+
+export const NATIVE_DIR = join(PACKAGE_ROOT, "native", "desktop");
+const DESKTOP_PKG = join(PACKAGE_ROOT, "packages", "desktop", "src");
+
+export type DesktopOs = "macos" | "windows" | "linux";
+
+const LABEL: Record<DesktopOs, string> = { macos: "macOS", windows: "Windows", linux: "Linux" };
+/** The cdylib cargo builds, per OS. */
+export const NATIVE_LIB: Record<DesktopOs, string> = {
+  macos: "libakan_native_desktop.dylib",
+  windows: "akan_native_desktop.dll",
+  linux: "libakan_native_desktop.so",
+};
+
+export function hostDesktopOs(platform = process.platform): DesktopOs | null {
+  return platform === "darwin" ? "macos" : platform === "win32" ? "windows" : platform === "linux" ? "linux" : null;
+}
+
+/** Desktop apps are built on their own OS: the webview SDKs and native toolchains live there. */
+export function requireHost(os: DesktopOs): void {
+  if (hostDesktopOs() === os) return;
+  const hint =
+    os === "linux"
+      ? "; from a Mac, run the build in the Linux container: bun scripts/vm/linux.ts bun run akan-native build linux"
+      : os === "windows"
+        ? "; from a Mac, use a Windows VM (docs/testing-windows-linux.md)"
+        : "";
+  throw new CliError(`${LABEL[os]} apps can only be built on ${LABEL[os]}${hint}`);
+}
+
+/** The resources folder inside a built desktop app (what the build returned). */
+export function resourcesOf(os: DesktopOs, artifact: string): string {
+  return os === "macos" ? join(artifact, "Contents", "Resources") : join(artifact, "resources");
+}
+
+function cargoEnv(): Record<string, string> {
+  return { PATH: `${join(homedir(), ".cargo", "bin")}${delimiter}${process.env.PATH ?? ""}` };
+}
+
+/** RUSTFLAGS per OS. Changing them rebuilds everything, so they stay fixed per OS. */
+const RUSTFLAGS: Record<DesktopOs, string> = {
+  
+  macos: "-C link-arg=-Wl,-install_name,@rpath/libakan_native_desktop.dylib",
+
+  windows: "-C target-feature=+crt-static",
+  linux: "",
+};
+
+const ARCH: Record<string, string> = { arm64: "aarch64", x64: "x86_64" };
+const TRIPLE_OS: Record<DesktopOs, string> = {
+  macos: "apple-darwin",
+  windows: "pc-windows-msvc",
+  linux: "unknown-linux-gnu",
+};
+
+/**
+ * The target the library must be built for: the architecture of the Bun that compiles (and so
+ * runs) the app, which can differ from rustc's host (x64 Bun on an ARM64 PC, under emulation).
+ * Null when it is rustc's host, so the usual target/<profile> folder is used.
+ */
+async function libraryTarget(os: DesktopOs): Promise<string | null> {
+  const wanted = `${ARCH[process.arch] ?? process.arch}-${TRIPLE_OS[os]}`;
+  const verbose = await exec(["rustc", "-vV"], { cwd: NATIVE_DIR, env: cargoEnv(), echo: false });
+  const host = /^host: (\S+)/m.exec(verbose.stdout)?.[1];
+  return host && host !== wanted ? wanted : null;
+}
+
+/**
+ * Cargo's output folder: CARGO_TARGET_DIR, else a cache under the akan-native home keyed by the
+ * source folder. Never inside native/desktop (gigabytes that a vendored or copied package would
+ * carry along, and a read-only install could not hold).
+ */
+export function cargoTargetDir(): string {
+  if (process.env.CARGO_TARGET_DIR) return process.env.CARGO_TARGET_DIR;
+  const key = createHash("sha256").update(NATIVE_DIR).digest("hex").slice(0, 12);
+  return join(akanNativeHome(), "cache", "desktop-target", key);
+}
+
+/** Builds (incrementally) the Rust cdylib and returns its path. */
+export async function buildNativeLibrary(os: DesktopOs, release: boolean): Promise<string> {
+  log.step("native: cargo build (TAO + WRY)");
+  const target = await libraryTarget(os);
+  
+  const args = ["cargo", "build", "--locked", "--manifest-path", join(NATIVE_DIR, "Cargo.toml"), "--quiet"];
+  if (release) args.push("--release");
+  if (target) {
+    log.info(
+      dim(`for ${target} (Bun is ${process.arch}); if the standard library is missing: rustup target add ${target}`),
+    );
+    args.push("--target", target);
+  }
+  await execOrThrow(args, {
+    
+    cwd: NATIVE_DIR,
+    env: { ...cargoEnv(), RUSTFLAGS: RUSTFLAGS[os], CARGO_TARGET_DIR: cargoTargetDir() },
+    inherit: true,
+  });
+  const lib = join(cargoTargetDir(), ...(target ? [target] : []), release ? "release" : "debug", NATIVE_LIB[os]);
+  if (!existsSync(lib)) throw new CliError(`cargo finished but ${lib} is missing`);
+  return lib;
+}
+
+/** Writes the generated entry points that `bun build --compile` bundles into one executable. */
+function writeEntries(ctx: BuildContext, genDir: string): { main: string; host: string } {
+  mkdirSync(genDir, { recursive: true });
+  const modules = ctx.project.plugins.flatMap((plugin) => {
+    const desktop = plugin.manifest.desktop;
+    if (!desktop || desktop === "web") return [];
+    return [pluginFile(plugin, typeof desktop === "string" ? desktop : desktop.module, "desktop module")];
+  });
+  const host = join(genDir, "host-entry.ts");
+  writeFileSync(
+    host,
+    `// Generated by akan-native build. Do not edit.
+import { startHost } from ${JSON.stringify(join(DESKTOP_PKG, "host.ts"))};
+${modules.map((m, i) => `import plugin${i} from ${JSON.stringify(m)};`).join("\n")}
+
+startHost([${modules.map((_, i) => `plugin${i}`).join(", ")}]);
+`,
+  );
+  const main = join(genDir, "main-entry.ts");
+  writeFileSync(
+    main,
+    `// Generated by akan-native build. Do not edit.
+import { startMain } from ${JSON.stringify(join(DESKTOP_PKG, "main.ts"))};
+
+startMain(new URL("./host-entry.ts", import.meta.url).href);
+`,
+  );
+  return { main, host };
+}
+
+/**
+ * The app never reads a .env or bunfig.toml from the folder it is started in: Bun's standalone
+ * executables do by default, which would let a file next to the app set its environment and
+ * runtime options.
+ */
+export const COMPILE_FLAGS = ["--no-compile-autoload-dotenv", "--no-compile-autoload-bunfig"];
+
+/** bun build --compile of the main thread entry and the plugin host Worker into `outfile`. */
+export async function compileExecutable(ctx: BuildContext, outfile: string, extra: string[] = []): Promise<void> {
+  const problems = (await Promise.all(ctx.project.plugins.map(desktopModuleProblems))).flat();
+  if (problems.length)
+    throw new CliError(`desktop plugin modules do not match their manifests:\n  - ${problems.join("\n  - ")}`);
+  log.step("bundle: bun build --compile");
+  const entries = writeEntries(ctx, join(ctx.outDir, "gen"));
+  await execOrThrow(
+    [
+      process.execPath,
+      "build",
+      "--compile",
+      ...COMPILE_FLAGS,
+      entries.main,
+      entries.host,
+      "--outfile",
+      outfile,
+      ...(ctx.dev ? [] : ["--minify"]),
+      ...extra,
+    ],
+    {
+      cwd: ctx.outDir,
+    },
+  );
+}
+
+/** The resources folder every desktop app reads (see the top of this file). */
+export function writeDesktopResources(
+  ctx: BuildContext,
+  resources: string,
+  os: DesktopOs,
+  shellExtra: Record<string, unknown> = {},
+): void {
+  const { config } = ctx.project;
+
+  if (
+    os !== "macos" &&
+    config.deepLinks.schemes.length &&
+    !ctx.project.plugins.some((p) => p.manifest.id === "single-instance")
+  ) {
+    log.warn(
+      `deepLinks.schemes on ${LABEL[os]} need the single-instance plugin: without it every link starts another copy of the app`,
+    );
+  }
+  mkdirSync(resources, { recursive: true });
+  cpSync(ctx.webDir, join(resources, "app"), { recursive: true });
+  writeFileSync(join(resources, "app", "index.html"), ctx.html);
+  const boot = makeNativeBoot(ctx, os);
+  writeFileSync(join(resources, "boot.json"), JSON.stringify(boot));
+  if (config.updates)
+    writeFileSync(
+      join(resources, "updates.json"),
+      updatesResource(config.updates, config.app, os, boot.nativeApi, ctx.dev),
+    );
+  writeFileSync(join(resources, "env.runtime.json"), JSON.stringify(ctx.env, null, 2));
+  writeFileSync(
+    join(resources, "shell.json"),
+    JSON.stringify({
+      title: config.app.name,
+      backgroundColor: config.shell.backgroundColor,
+      backgroundColorDark: config.shell.backgroundColorDark,
+      devtools: ctx.dev,
+      quitOnLastWindowClosed: config.desktop.quitOnLastWindowClosed,
+      
+      deepLinks: config.deepLinks.schemes,
+      
+      externalSchemes: config.security?.shell?.externalSchemes ?? [],
+      
+      ...(ctx.dev && ctx.devServer ? { devServer: ctx.devServer } : {}),
+      ...(ctx.dev && ctx.devServer && ctx.startPath ? { startPath: ctx.startPath } : {}),
+      ...shellExtra,
+    }),
+  );
+}
+
+/**
+ * Starts a desktop executable directly, so native logs and the page console reach the CLI (WV-3).
+ * stop() asks the app to quit through its lifecycle (the onQuit hooks run): SIGTERM on macOS and
+ * Linux; on Windows, which has no such signal, a "quit" line on the app's stdin (lib.rs
+ * stdin_quit), then TerminateProcess if it is still running after 6 s.
+ */
+export function launchExecutable(exe: string, opts: LaunchOptions): Launched {
+  const windows = process.platform === "win32";
+  const proc = Bun.spawn([exe], {
+    env: {
+      ...process.env,
+      ...opts.env,
+      ...(opts.headless ? { AKAN_NATIVE_ACTIVATION: "prohibited" } : {}),
+      ...(windows ? { AKAN_NATIVE_QUIT_ON_STDIN: "1" } : {}),
+    },
+    stdin: windows ? "pipe" : "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const onLine = opts.onLine ?? printLine;
+  const logs = Promise.all([pipeLines(proc.stdout, onLine), pipeLines(proc.stderr, onLine)]);
+  return {
+    exited: proc.exited.then(async (code) => {
+      await logs;
+      return code;
+    }),
+    stop: () => {
+      if (!windows) return proc.kill("SIGTERM");
+      try {
+        const stdin = proc.stdin as import("bun").FileSink;
+        stdin.write("quit\n");
+        stdin.flush();
+      } catch {}
+      setTimeout(() => proc.kill(), 6000).unref();
+    },
+  };
+}
+
+export async function runExecutable(exe: string, artifact: string, args: ParsedArgs): Promise<number> {
+  log.ok(`launching ${artifact}`);
+  return follow(launchExecutable(exe, { env: envFromProcess(), headless: args.flags.headless === true }));
+}
+
+/** Folder size for the build summary. */
+export async function folderSize(path: string): Promise<string | null> {
+  if (process.platform === "win32") return null;
+  const size = await exec(["du", "-sh", path], { echo: false });
+  return size.code === 0 ? size.stdout.split("\t")[0]! : null;
+}

package/vendor/@akanjs/native/packages/cli/src/platforms/index.ts

@@ -0,0 +1,31 @@
+import type { ParsedArgs } from "../lib/args.ts";
+import type { Launched, LaunchOptions } from "../lib/launch.ts";
+import type { BuildContext } from "../lib/prepare.ts";
+import { buildAndroid, launchAndroid, runAndroid } from "./android.ts";
+import { buildIos, launchIos, runIos } from "./ios.ts";
+import { buildLinux, launchLinux, runLinux } from "./linux.ts";
+import { buildMacos, launchMacos, runMacos } from "./macos.ts";
+import type { TargetPlatform } from "./targets.ts";
+import { buildWeb } from "./web.ts";
+import { launchWeb, runWeb } from "./web-run.ts";
+import { buildWindows, launchWindows, runWindows } from "./windows.ts";
+
+export { hostTargets, TARGETS, type TargetPlatform } from "./targets.ts";
+
+export interface PlatformTarget {
+  /** Builds into ctx.outDir and returns the main artifact path. */
+  build(ctx: BuildContext): Promise<string>;
+  /** Launches a built artifact and follows its logs. Resolves when the app (or server) exits. */
+  run(ctx: BuildContext, artifact: string, args: ParsedArgs): Promise<number>;
+  /** Launches a built artifact with env overrides and a log line callback (akan-native test). */
+  launch(ctx: BuildContext, artifact: string, opts: LaunchOptions): Promise<Launched>;
+}
+
+export const PLATFORM_TARGETS: Record<TargetPlatform, PlatformTarget> = {
+  web: { build: buildWeb, run: runWeb, launch: launchWeb },
+  macos: { build: buildMacos, run: runMacos, launch: launchMacos },
+  windows: { build: buildWindows, run: runWindows, launch: launchWindows },
+  linux: { build: buildLinux, run: runLinux, launch: launchLinux },
+  ios: { build: buildIos, run: runIos, launch: launchIos },
+  android: { build: buildAndroid, run: runAndroid, launch: launchAndroid },
+};