akanjs 3.0.0-beta.26 → 3.0.0-beta.28

package/vendor/@akanjs/native/packages/cli/src/lib/project.ts

@@ -7,6 +7,7 @@ import type { AkanNativeConfig } from "../config.ts";
 import { manifestPermissionProblems, type PermissionSet, resolveAcl } from "./acl.ts";
 import { unknownConfigKeys } from "./configkeys.ts";
 import { validateCsp, validateExternalSchemes } from "./csp.ts";
+import { type DesktopServerConfig, validateDesktopServer } from "./desktop-server.ts";
 import { type EnvConfig, validateEnvConfig } from "./env.ts";
 import { CliError } from "./log.ts";
 import { type PermissionsConfig, validatePermissions } from "./permissions.ts";
@@ -26,7 +27,15 @@ export interface ResolvedConfig extends Omit<AkanNativeConfig, "icon" | "splash"
   usageDescriptions: Record<string, string>;
   permissions: PermissionsConfig;
   deepLinks: { schemes: string[]; domains: { host: string; pathPrefixes: string[] }[] };
-  desktop: { quitOnLastWindowClosed: boolean };
+  desktop: {
+    quitOnLastWindowClosed: boolean;
+    recovery: "errorPage" | "reload";
+    window: { fullscreen: boolean; skipTaskbar: boolean };
+    screenCapture: "picker" | "auto";
+    server?: DesktopServerConfig;
+    /** Absolute. */
+    bin?: string;
+  };
   updates: UpdatesConfig | null;
   /** Absolute image path. */
   icon: { image: string; backgroundColor?: string } | null;
@@ -186,6 +195,23 @@ export function projectFromConfig(raw: AkanNativeConfig, appDir: string, options
   if (raw.desktop?.quitOnLastWindowClosed !== undefined && typeof raw.desktop.quitOnLastWindowClosed !== "boolean") {
     problems.push("desktop.quitOnLastWindowClosed must be a boolean");
   }
+  const recovery = raw.desktop?.recovery;
+  if (recovery !== undefined && recovery !== "errorPage" && recovery !== "reload")
+    problems.push(`desktop.recovery must be "errorPage" or "reload" (got ${JSON.stringify(recovery)})`);
+  for (const key of ["fullscreen", "skipTaskbar"] as const) {
+    const value = raw.desktop?.window?.[key];
+    if (value !== undefined && typeof value !== "boolean") problems.push(`desktop.window.${key} must be a boolean`);
+  }
+  const screenCapture = raw.desktop?.screenCapture;
+  if (screenCapture !== undefined && screenCapture !== "picker" && screenCapture !== "auto")
+    problems.push(`desktop.screenCapture must be "picker" or "auto" (got ${JSON.stringify(screenCapture)})`);
+  if (raw.android?.autoplay !== undefined && typeof raw.android.autoplay !== "boolean")
+    problems.push("android.autoplay must be a boolean");
+  const bin = raw.desktop?.bin;
+  const binDir = typeof bin === "string" && bin ? resolve(appDir, bin) : null;
+  if (bin !== undefined && !(binDir && existsSync(binDir) && statSync(binDir).isDirectory()))
+    problems.push(`desktop.bin must be a folder (got ${JSON.stringify(bin)})`);
+  const desktopServer = validateDesktopServer(raw.desktop, appDir, problems);
   if (raw.keyboard?.resize !== undefined && raw.keyboard.resize !== "resize" && raw.keyboard.resize !== "none") {
     problems.push(`keyboard.resize must be "resize" or "none" (got ${JSON.stringify(raw.keyboard.resize)})`);
   }
@@ -245,7 +271,17 @@ export function projectFromConfig(raw: AkanNativeConfig, appDir: string, options
         typeof d === "string" ? { host: d, pathPrefixes: [] } : { host: d.host, pathPrefixes: d.pathPrefixes ?? [] },
       ),
     },
-    desktop: { quitOnLastWindowClosed: raw.desktop?.quitOnLastWindowClosed ?? true },
+    desktop: {
+      quitOnLastWindowClosed: raw.desktop?.quitOnLastWindowClosed ?? true,
+      recovery: raw.desktop?.recovery === "reload" ? "reload" : "errorPage",
+      screenCapture: raw.desktop?.screenCapture === "auto" ? "auto" : "picker",
+      window: {
+        fullscreen: raw.desktop?.window?.fullscreen === true,
+        skipTaskbar: raw.desktop?.window?.skipTaskbar === true,
+      },
+      ...(desktopServer ? { server: desktopServer } : {}),
+      ...(binDir ? { bin: binDir } : {}),
+    },
     updates,
     icon: icon ? { ...icon, image: resolve(appDir, icon.image) } : null,
     splash: {

package/vendor/@akanjs/native/packages/cli/src/lib/publish.ts

@@ -0,0 +1,104 @@
+
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { publishAppUpdate } from "../platforms/desktop-update.ts";
+import { BUNDLE_FILE, readBundleInfo } from "./compat.ts";
+import { CliError, log } from "./log.ts";
+import type { BuildContext } from "./prepare.ts";
+import {
+  assertChannel,
+  hostArch,
+  signingKey,
+  signManifest,
+  type UpdateManifest,
+  updateKeyPath,
+  webManifest,
+  writeWebBundle,
+} from "./updates.ts";
+
+export type ReleasePlatform = "macos" | "windows" | "linux" | "ios" | "android";
+
+export interface PublishedRelease {
+  /** `<out>/<os>-<arch>` for a desktop app, `<out>/<platform>` for a phone's web bundle. */
+  dir: string;
+  manifest: UpdateManifest;
+}
+
+/**
+ * The publish time in seconds, and past the release `<channel>.json` in `dir` already names: apps take only a larger
+ * sequence, so a clock behind the last publisher's would make this release look older to every one of them.
+ */
+export function nextSequence(dir: string, channel: string, now = Math.floor(Date.now() / 1000)): number {
+  const path = join(dir, `${channel}.json`);
+  if (!existsSync(path)) return now;
+  const previous = (JSON.parse(readFileSync(path, "utf8")) as Partial<UpdateManifest>).sequence;
+  if (typeof previous !== "number" || previous < now) return now;
+  if (previous > now)
+    log.warn(
+      `the ${channel} release already here has sequence ${previous}, later than this computer's clock (${now}): publishing as ${previous + 1}. Check the clock of the computer that publishes.`,
+    );
+  return previous + 1;
+}
+
+/** Refuses before the build a release that could not be signed: no key on this machine, or another app's. */
+export function assertSigningKey(config: { app: { id: string }; updates?: { publicKey: string } | null }): void {
+  if (!config.updates)
+    throw new CliError("akan-native.config.ts has no updates: { url, publicKey } (run `akan-native update keygen`)");
+  signingKey(updateKeyPath(config.app.id), config.updates.publicKey);
+}
+
+/**
+ * `<channel>.json` and its `.sig` land together, the signature first: an app that reads a manifest beside another
+ * one's signature refuses every release until the next publish.
+ */
+function writeSigned(dir: string, channel: string, bytes: Uint8Array, signature: string): void {
+  const json = join(dir, `${channel}.json`);
+  writeFileSync(`${json}.tmp`, bytes);
+  writeFileSync(`${json}.sig.tmp`, signature);
+  renameSync(`${json}.sig.tmp`, `${json}.sig`);
+  renameSync(`${json}.tmp`, json);
+}
+
+/** Writes the release of `artifact` (the app a release build made) and its signed `<channel>.json` under `out`. */
+export async function publishRelease(
+  ctx: BuildContext,
+  platform: ReleasePlatform,
+  artifact: string,
+  out: string,
+  channel: string,
+): Promise<PublishedRelease> {
+  const { config } = ctx.project;
+  if (!config.updates)
+    throw new CliError("akan-native.config.ts has no updates: { url, publicKey } (run `akan-native update keygen`)");
+  const desktop = platform === "macos" || platform === "windows" || platform === "linux" ? platform : null;
+  
+  const dir = join(out, desktop ? `${desktop}-${hostArch()}` : platform);
+  assertChannel(channel);
+  assertSigningKey(config);
+  const keyPath = updateKeyPath(config.app.id);
+  const sequence = nextSequence(dir, channel);
+
+  let manifest: UpdateManifest;
+  let superseded: string | null = null;
+  if (desktop) {
+    ({ manifest, superseded } = await publishAppUpdate(ctx, desktop, artifact, dir, channel, sequence));
+  } else {
+    const info = readBundleInfo(join(ctx.outDir, BUNDLE_FILE));
+    manifest = webManifest({
+      app: config.app,
+      platform,
+      channel,
+      nativeApi: info.nativeApi.hash,
+      sequence,
+      bundle: `${sequence}-${info.web.hash.slice(0, 8)}`,
+      files: writeWebBundle(dir, ctx.webDir, ctx.html, ctx.env),
+    });
+  }
+  const bytes = new TextEncoder().encode(`${JSON.stringify(manifest, null, 2)}\n`);
+  const signature = `${signManifest(bytes, keyPath, config.updates.publicKey)}\n`;
+  mkdirSync(dir, { recursive: true });
+  writeSigned(dir, channel, bytes, signature);
+  if (superseded) rmSync(superseded, { force: true });
+  return { dir, manifest };
+}

package/vendor/@akanjs/native/packages/cli/src/lib/updates.ts

@@ -1,9 +1,10 @@
 
 
 import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
 import type { Platform } from "../../../core/src/index.ts";
+import { runtimeVersion } from "./boot.ts";
 import { CliError } from "./log.ts";
 import { akanNativeHome } from "./toolchains.ts";
 
@@ -59,6 +60,77 @@ export interface UpdateManifest {
   patches?: { from: string; url: string; sha256: string; size: number }[];
 }
 
+/** Every file of a web bundle as the app serves it: index.html with the init script and CSP, public/, env.runtime.json. */
+export function webFiles(
+  webDir: string,
+  html: string,
+  env: Record<string, string>,
+): { path: string; data: Uint8Array }[] {
+  const files: { path: string; data: Uint8Array }[] = [];
+  const walk = (dir: string) => {
+    for (const name of readdirSync(dir).sort()) {
+      const path = join(dir, name);
+      if (statSync(path).isDirectory()) walk(path);
+      else {
+        const rel = relative(webDir, path);
+        files.push({ path: rel, data: rel === "index.html" ? new TextEncoder().encode(html) : readFileSync(path) });
+      }
+    }
+  };
+  walk(webDir);
+  files.push({ path: "env.runtime.json", data: new TextEncoder().encode(JSON.stringify(env, null, 2)) });
+  return files;
+}
+
+/** Writes a web bundle's files under `<out>/files/<sha256>` (content-addressed, so releases share them) and lists them. */
+export function writeWebBundle(out: string, webDir: string, html: string, env: Record<string, string>): UpdateFile[] {
+  mkdirSync(join(out, "files"), { recursive: true });
+  return webFiles(webDir, html, env).map(({ path, data }) => {
+    const hash = sha256(data);
+    const target = join(out, "files", hash);
+    if (!existsSync(target)) writeFileSync(target, data);
+    return { path, sha256: hash, size: data.length };
+  });
+}
+
+/** A web bundle's manifest (UP-2), keys in the order `update publish` has always written them. */
+export function webManifest(release: {
+  app: { id: string; version: string };
+  platform: Platform;
+  channel: string;
+  nativeApi: string;
+  sequence: number;
+  bundle: string;
+  files: UpdateFile[];
+}): UpdateManifest {
+  return {
+    schema: 1,
+    kind: "web",
+    app: release.app.id,
+    platform: release.platform,
+    channel: release.channel,
+    nativeApi: release.nativeApi,
+    sequence: release.sequence,
+    bundle: release.bundle,
+    runtimeVersion: runtimeVersion(),
+    version: release.app.version,
+    files: release.files,
+  };
+}
+
+/** A channel is a file name in the release folder and a string an app's config compares: lowercase, no separators. */
+const CHANNEL_NAME = /^[a-z0-9][a-z0-9._-]{0,40}$/;
+/** `<channel>.json` of these would overwrite what an unsigned phone update (packUpdate) writes to the same folder. */
+const RESERVED_CHANNELS = ["bundle", "manifest.template", "compat"];
+
+/** Refuses a channel no app could be configured for: it would be written but never taken. */
+export function assertChannel(channel: string): void {
+  if (!CHANNEL_NAME.test(channel))
+    throw new CliError(`channel "${channel}" is not a short lowercase name like "production" or "pilot"`);
+  if (RESERVED_CHANNELS.includes(channel))
+    throw new CliError(`channel "${channel}" would overwrite ${channel}.json of an unsigned update: name another`);
+}
+
 export function validateUpdates(raw: unknown, problems: string[]): UpdatesConfig | null {
   if (raw === undefined) return null;
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
@@ -70,7 +142,10 @@ export function validateUpdates(raw: unknown, problems: string[]): UpdatesConfig
     problems.push("updates.url must be an http(s) URL");
   if (typeof r.publicKey !== "string" || Buffer.from(r.publicKey, "base64").length !== 32)
     problems.push("updates.publicKey must be a base64 Ed25519 public key (akan-native update keygen)");
-  if (r.channel !== undefined && (typeof r.channel !== "string" || !/^[a-z0-9][a-z0-9._-]{0,40}$/.test(r.channel)))
+  if (
+    r.channel !== undefined &&
+    (typeof r.channel !== "string" || !CHANNEL_NAME.test(r.channel) || RESERVED_CHANNELS.includes(r.channel))
+  )
     problems.push('updates.channel must be a short name like "production"');
   if (r.readyTimeout !== undefined && (typeof r.readyTimeout !== "number" || r.readyTimeout < 1000))
     problems.push("updates.readyTimeout must be a number of milliseconds >= 1000");
@@ -112,11 +187,16 @@ function publicKeyOf(privateKey: ReturnType<typeof createPrivateKey>): string {
   return der.subarray(der.length - 32).toString("base64");
 }
 
-export function signManifest(bytes: Uint8Array, keyPath: string, expectedPublicKey: string): string {
+/** The key at `keyPath`, refused unless it is the one whose public half the apps were built with. */
+export function signingKey(keyPath: string, expectedPublicKey: string) {
   const key = readPrivateKey(keyPath);
   if (publicKeyOf(key) !== expectedPublicKey)
     throw new CliError(`the key at ${keyPath} does not match updates.publicKey in akan-native.config.ts`);
-  return sign(null, bytes, key).toString("base64");
+  return key;
+}
+
+export function signManifest(bytes: Uint8Array, keyPath: string, expectedPublicKey: string): string {
+  return sign(null, bytes, signingKey(keyPath, expectedPublicKey)).toString("base64");
 }
 
 /** Verifies like the apps do: raw public key, base64 signature over the exact manifest bytes. */

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

@@ -503,6 +503,7 @@ export async function buildAndroid(ctx: BuildContext): Promise<string> {
       
       externalSchemes: config.security?.shell?.externalSchemes ?? [],
       minWebViewVersion: config.android?.minWebViewVersion ?? MIN_WEBVIEW,
+      autoplay: config.android?.autoplay === true,
       
       keyboardResize: config.keyboard?.resize ?? "resize",
       

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

@@ -1,6 +1,6 @@
 
 
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, 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";
@@ -23,7 +23,7 @@ export async function publishAppUpdate(
   out: string,
   channel: string,
   sequence: number,
-): Promise<UpdateManifest> {
+): Promise<{ manifest: UpdateManifest; superseded: string | null }> {
   const { config } = ctx.project;
   const dir = join(out, "app");
   mkdirSync(dir, { recursive: true });
@@ -36,6 +36,7 @@ export async function publishAppUpdate(
   writeFileSync(join(dir, `${tarSha}.tar.gz`), gz);
 
   const patches: NonNullable<UpdateManifest["patches"]> = [];
+  let superseded: string | null = null;
   const previousPath = join(out, `${channel}.json`);
   if (existsSync(previousPath)) {
     const previous = JSON.parse(readFileSync(previousPath, "utf8")) as UpdateManifest;
@@ -54,10 +55,10 @@ export async function publishAppUpdate(
       );
     }
     
-    if (from && from !== tarSha) rmSync(base, { force: true });
+    if (from && from !== tarSha) superseded = base;
   }
 
-  return {
+  const manifest: UpdateManifest = {
     schema: 1,
     kind: "app",
     app: config.app.id,
@@ -75,4 +76,5 @@ export async function publishAppUpdate(
     archive: { sha256: tarSha, url: `app/${tarSha}.tar.gz`, size: gz.length, gzSha256: sha256(gz) },
     patches,
   };
+  return { manifest, superseded };
 }

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

@@ -208,6 +208,18 @@ export function writeDesktopResources(
       updatesResource(config.updates, config.app, os, boot.nativeApi, ctx.dev),
     );
   writeFileSync(join(resources, "env.runtime.json"), JSON.stringify(ctx.env, null, 2));
+  const server = config.desktop.server;
+  if (server) {
+    if (!ctx.project.plugins.some((p) => p.manifest.id === "single-instance"))
+      log.warn(
+        "desktop.server without the single-instance plugin: every launch starts another server on the same data",
+      );
+    cpSync(server.dir, join(resources, "server"), { recursive: true, verbatimSymlinks: true });
+    writeFileSync(join(resources, "server.json"), JSON.stringify({ entry: server.entry, env: server.env }));
+    writeFileSync(join(resources, "server.bunfig.toml"), "");
+  }
+  if (config.desktop.bin)
+    cpSync(config.desktop.bin, join(resources, "bin"), { recursive: true, verbatimSymlinks: true });
   writeFileSync(
     join(resources, "shell.json"),
     JSON.stringify({
@@ -216,6 +228,10 @@ export function writeDesktopResources(
       backgroundColorDark: config.shell.backgroundColorDark,
       devtools: ctx.dev,
       quitOnLastWindowClosed: config.desktop.quitOnLastWindowClosed,
+      recovery: config.desktop.recovery,
+      screenCapture: config.desktop.screenCapture,
+      fullscreen: config.desktop.window.fullscreen,
+      skipTaskbar: config.desktop.window.skipTaskbar,
       
       deepLinks: config.deepLinks.schemes,
       

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

@@ -1,6 +1,17 @@
 
 
-import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import {
+  closeSync,
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
 import type { ParsedArgs } from "../lib/args.ts";
 import { execOrThrow } from "../lib/exec.ts";
@@ -78,6 +89,8 @@ export async function buildMacos(ctx: BuildContext): Promise<string> {
   log.step(`sign: ${identity ? identity.name : "ad-hoc"}`);
   
   await execOrThrow(["xattr", "-cr", appPath], { echo: false });
+  for (const addon of carriedNativeCode(resources))
+    await execOrThrow(["codesign", "--force", "--sign", sign, addon], { echo: false });
   await execOrThrow(["codesign", "--force", "--sign", sign, join(contents, "Frameworks", NATIVE_LIB.macos)], {
     echo: false,
   });
@@ -87,6 +100,36 @@ export async function buildMacos(ctx: BuildContext): Promise<string> {
   return appPath;
 }
 
+/**
+ * Mach-O files the app carries in its server and its `bin`, whatever their names (native addons, executables, a
+ * package's own executable): nested code the bundle's signature does not sign.
+ */
+export function carriedNativeCode(resources: string): string[] {
+  return ["server", "bin"].flatMap((folder) => {
+    const dir = join(resources, folder);
+    if (!existsSync(dir)) return [];
+    return (readdirSync(dir, { recursive: true }) as string[])
+      .filter((file) => !/\.(c?js|mjs|ts|json|map|md|txt|html|css)$/i.test(file))
+      .map((file) => join(dir, file))
+      .filter(isMachO);
+  });
+}
+
+function isMachO(file: string): boolean {
+  if (!lstatSync(file).isFile()) return false;
+  const head = Buffer.alloc(8);
+  const fd = openSync(file, "r");
+  try {
+    if (readSync(fd, head, 0, 8, 0) < 8) return false;
+  } finally {
+    closeSync(fd);
+  }
+  const magic = head.readUInt32BE(0);
+  if (magic === 0xfeedface || magic === 0xfeedfacf || magic === 0xcefaedfe || magic === 0xcffaedfe) return true;
+  
+  return (magic === 0xcafebabe || magic === 0xcafebabf) && head.readUInt32BE(4) < 45;
+}
+
 export async function launchMacos(ctx: BuildContext, appPath: string, opts: LaunchOptions): Promise<Launched> {
   
   return launchExecutable(join(appPath, "Contents", "MacOS", ctx.project.config.app.fileName), opts);