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

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

@@ -0,0 +1,203 @@
+
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { deflateRawSync } from "node:zlib";
+
+interface Entry {
+  name: string;
+  method: 0 | 8;
+  crc: number;
+  compressedSize: number;
+  size: number;
+  data: Uint8Array;
+}
+
+const STORE_EXT = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "heic",
+  "mp4",
+  "webm",
+  "mov",
+  "mp3",
+  "m4a",
+  "ogg",
+  "woff",
+  "woff2",
+  "zip",
+  "gz",
+  "br",
+]);
+const DOS_DATE = (0 << 9) | (1 << 5) | 1; 
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+export function readZip(buf: Uint8Array): Entry[] {
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let eocd = buf.length - 22;
+  while (eocd >= 0 && view.getUint32(eocd, true) !== 0x06054b50) eocd--;
+  if (eocd < 0) throw new Error("not a zip file (no end of central directory)");
+  const count = view.getUint16(eocd + 10, true);
+  let p = view.getUint32(eocd + 16, true);
+  const entries: Entry[] = [];
+  for (let i = 0; i < count; i++) {
+    if (view.getUint32(p, true) !== 0x02014b50) throw new Error("bad central directory header");
+    const method = view.getUint16(p + 10, true);
+    if (method !== 0 && method !== 8) throw new Error(`unsupported compression method ${method}`);
+    const nameLength = view.getUint16(p + 28, true);
+    const extraLength = view.getUint16(p + 30, true);
+    const commentLength = view.getUint16(p + 32, true);
+    const localOffset = view.getUint32(p + 42, true);
+    const compressedSize = view.getUint32(p + 20, true);
+    const dataStart =
+      localOffset + 30 + view.getUint16(localOffset + 26, true) + view.getUint16(localOffset + 28, true);
+    entries.push({
+      name: decoder.decode(buf.subarray(p + 46, p + 46 + nameLength)),
+      method,
+      crc: view.getUint32(p + 16, true),
+      compressedSize,
+      size: view.getUint32(p + 24, true),
+      data: buf.subarray(dataStart, dataStart + compressedSize),
+    });
+    p += 46 + nameLength + extraLength + commentLength;
+  }
+  return entries;
+}
+
+export function fileEntry(name: string, bytes: Uint8Array, store: boolean): Entry {
+  const crc = Bun.hash.crc32(bytes) >>> 0;
+  if (!store) {
+    const deflated = deflateRawSync(bytes, { level: 9 });
+    if (deflated.length < bytes.length)
+      return { name, method: 8, crc, compressedSize: deflated.length, size: bytes.length, data: deflated };
+  }
+  return { name, method: 0, crc, compressedSize: bytes.length, size: bytes.length, data: bytes };
+}
+
+export function writeZip(entries: Entry[]): Uint8Array {
+  const chunks: Uint8Array[] = [];
+  const central: Uint8Array[] = [];
+  let offset = 0;
+  for (const e of entries) {
+    const name = encoder.encode(e.name);
+    let extra: Uint8Array = new Uint8Array(0);
+    if (e.method === 0) {
+      
+      const base = offset + 30 + name.length;
+      const pad = (4 - ((base + 6) % 4)) % 4;
+      extra = new Uint8Array(6 + pad);
+      const xv = new DataView(extra.buffer);
+      xv.setUint16(0, 0xd935, true);
+      xv.setUint16(2, 2 + pad, true);
+      xv.setUint16(4, 4, true);
+    }
+    const local = new Uint8Array(30);
+    const lv = new DataView(local.buffer);
+    lv.setUint32(0, 0x04034b50, true);
+    lv.setUint16(4, 20, true);
+    lv.setUint16(6, 0x0800, true); 
+    lv.setUint16(8, e.method, true);
+    lv.setUint16(12, DOS_DATE, true);
+    lv.setUint32(14, e.crc, true);
+    lv.setUint32(18, e.compressedSize, true);
+    lv.setUint32(22, e.size, true);
+    lv.setUint16(26, name.length, true);
+    lv.setUint16(28, extra.length, true);
+
+    const header = new Uint8Array(46);
+    const cv = new DataView(header.buffer);
+    cv.setUint32(0, 0x02014b50, true);
+    cv.setUint16(4, 20, true);
+    cv.setUint16(6, 20, true);
+    cv.setUint16(8, 0x0800, true);
+    cv.setUint16(10, e.method, true);
+    cv.setUint16(14, DOS_DATE, true);
+    cv.setUint32(16, e.crc, true);
+    cv.setUint32(20, e.compressedSize, true);
+    cv.setUint32(24, e.size, true);
+    cv.setUint16(28, name.length, true);
+    cv.setUint32(42, offset, true);
+
+    central.push(header, name);
+    chunks.push(local, name, extra, e.data);
+    offset += 30 + name.length + extra.length + e.data.length;
+  }
+  const centralSize = central.reduce((n, c) => n + c.length, 0);
+  const end = new Uint8Array(22);
+  const ev = new DataView(end.buffer);
+  ev.setUint32(0, 0x06054b50, true);
+  ev.setUint16(8, entries.length, true);
+  ev.setUint16(10, entries.length, true);
+  ev.setUint32(12, centralSize, true);
+  ev.setUint32(16, offset, true);
+
+  const all = [...chunks, ...central, end];
+  const out = new Uint8Array(all.reduce((n, c) => n + c.length, 0));
+  let p = 0;
+  for (const c of all) {
+    out.set(c, p);
+    p += c.length;
+  }
+  return out;
+}
+
+function walk(dir: string): string[] {
+  return readdirSync(dir).flatMap((name) => {
+    const path = join(dir, name);
+    return statSync(path).isDirectory() ? walk(path) : [path];
+  });
+}
+
+export interface ApkInput {
+  /** aapt2 link output (manifest + resources, no assets). */
+  base: Uint8Array;
+  /** classes.dex, classes2.dex, ... in order. */
+  dex: Uint8Array[];
+  /** Folder whose content goes under assets/. */
+  assetsDir: string;
+  /**
+   * More files by their path in the APK (O8): lib/<abi>/*.so of pinned libraries (compressed: the
+   * installer extracts them, extractNativeLibs is not set) and META-INF/services/* for ServiceLoader.
+   */
+  extra?: { name: string; bytes: Uint8Array }[];
+}
+
+export function assembleApk({ base, dex, assetsDir, extra = [] }: ApkInput): Uint8Array {
+  const entries = readZip(base);
+  for (const [i, bytes] of dex.entries())
+    entries.push(fileEntry(i === 0 ? "classes.dex" : `classes${i + 1}.dex`, bytes, true));
+  for (const e of extra) entries.push(fileEntry(e.name, e.bytes, false));
+  for (const file of walk(assetsDir).sort()) {
+    const rel = relative(assetsDir, file).split("\\").join("/");
+    const ext = rel.split(".").pop()!.toLowerCase();
+    entries.push(fileEntry(`assets/${rel}`, new Uint8Array(readFileSync(file)), STORE_EXT.has(ext)));
+  }
+  return writeZip(entries);
+}
+
+/**
+ * The base module of an Android App Bundle (akanjs readiness O1-5), for `bundletool build-bundle
+ * --modules`: aapt2's --proto-format output with its manifest under manifest/ (resources.pb and res/
+ * stay at the root), the dex files under dex/ and the assets under assets/. bundletool decides the
+ * APKs' compression and alignment itself.
+ */
+export function assembleBundleModule({ base, dex, assetsDir, extra = [] }: ApkInput): Uint8Array {
+  const entries = readZip(base).map((e) =>
+    e.name === "AndroidManifest.xml" ? { ...e, name: "manifest/AndroidManifest.xml" } : e,
+  );
+  for (const [i, bytes] of dex.entries())
+    entries.push(fileEntry(`dex/${i === 0 ? "classes.dex" : `classes${i + 1}.dex`}`, bytes, false));
+  
+  for (const e of extra) entries.push(fileEntry(e.name.startsWith("lib/") ? e.name : `root/${e.name}`, e.bytes, false));
+  for (const file of walk(assetsDir).sort()) {
+    const rel = relative(assetsDir, file).split("\\").join("/");
+    const ext = rel.split(".").pop()!.toLowerCase();
+    entries.push(fileEntry(`assets/${rel}`, new Uint8Array(readFileSync(file)), STORE_EXT.has(ext)));
+  }
+  return writeZip(entries);
+}

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

@@ -0,0 +1,44 @@
+import { CliError } from "./log.ts";
+
+export interface ParsedArgs {
+  positional: string[];
+  flags: Record<string, string | true>;
+}
+
+/** Parses `a b --flag value --bool --key=value`. A flag followed by another flag or nothing is boolean. */
+export function parseArgs(argv: string[], booleanFlags: readonly string[] = []): ParsedArgs {
+  const positional: string[] = [];
+  const flags: Record<string, string | true> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const body = arg.slice(2);
+    const eq = body.indexOf("=");
+    if (eq >= 0) {
+      flags[body.slice(0, eq)] = body.slice(eq + 1);
+    } else if (booleanFlags.includes(body) || i + 1 >= argv.length || argv[i + 1]!.startsWith("--")) {
+      flags[body] = true;
+    } else {
+      flags[body] = argv[++i]!;
+    }
+  }
+  return { positional, flags };
+}
+
+/** Rejects flags a command does not know (a typo would otherwise be ignored, e.g. --relase). */
+export function checkFlags(args: ParsedArgs, known: readonly string[], usage: string): void {
+  const unknown = Object.keys(args.flags).filter((f) => !known.includes(f));
+  if (unknown.length)
+    throw new CliError(
+      `unknown flag${unknown.length > 1 ? "s" : ""} ${unknown.map((f) => `--${f}`).join(", ")}\nusage: ${usage}`,
+      2,
+    );
+}
+
+export function stringFlag(args: ParsedArgs, name: string): string | undefined {
+  const value = args.flags[name];
+  return typeof value === "string" ? value : undefined;
+}

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

@@ -0,0 +1,73 @@
+
+
+import type { Platform, PluginDecl, ResolvedAcl } from "../../../core/src/index.ts";
+import { BRIDGE_FEATURES } from "../../../core/src/protocol.ts";
+import { VERSION } from "../../../core/src/version.ts";
+import { resolveAcl } from "./acl.ts";
+import { nativeApi, nativeApiHash, writeBundleInfo } from "./compat.ts";
+import { type NativePlatform, pluginDecls } from "./native-plugins.ts";
+import type { BuildContext } from "./prepare.ts";
+import type { Project, ResolvedConfig } from "./project.ts";
+
+export { INIT_PREFIX, INIT_SUFFIX, renderInitScript } from "../../../core/src/protocol.ts";
+
+export interface BootData {
+  v: 1;
+  platform: Platform;
+  runtimeVersion: string;
+  dev: boolean;
+  app: { id: string; name: string; version: string; build: number };
+  plugins: Record<string, PluginDecl>;
+  /** Resolved capabilities (PL-11): the host enforces them before dispatching a call. */
+  acl?: ResolvedAcl;
+  /** Native builds: what web bundles this binary can run (UP-3, lib/compat.ts). */
+  nativeApi?: string;
+  /** Native builds: what the hosts speak beyond bridge protocol v1 (architecture.md §4). */
+  bridge?: { features: string[] };
+}
+
+/** Without `project` there is no ACL (everything allowed), as in unit tests of other parts. */
+export function makeBoot(
+  config: ResolvedConfig,
+  platform: Platform,
+  plugins: Record<string, PluginDecl>,
+  dev: boolean,
+  project?: Project,
+): BootData {
+  const acl = project ? resolveAcl(config.capabilities, project.plugins, platform) : undefined;
+  return {
+    v: 1,
+    platform,
+    runtimeVersion: runtimeVersion(),
+    dev,
+    app: { id: config.app.id, name: config.app.name, version: config.app.version, build: config.app.build },
+    plugins,
+    ...(acl ? { acl } : {}),
+    ...(project && platform !== "web"
+      ? { nativeApi: nativeApiHash(nativeApi(project, platform, plugins, acl, runtimeVersion())) }
+      : {}),
+    ...(platform !== "web" ? { bridge: { features: [...BRIDGE_FEATURES] } } : {}),
+  };
+}
+
+/** boot.json of a native build, with <outDir>/bundle.json written next to the build (UP-3). */
+export function makeNativeBoot(ctx: BuildContext, platform: NativePlatform): BootData {
+  const { project } = ctx;
+  const decls = pluginDecls(project.plugins, platform);
+  const boot = makeBoot(project.config, platform, decls, ctx.dev, project);
+  writeBundleInfo(
+    ctx.outDir,
+    project,
+    platform,
+    boot.runtimeVersion,
+    nativeApi(project, platform, decls, boot.acl, boot.runtimeVersion),
+    ctx.webDir,
+    ctx.html,
+  );
+  return boot;
+}
+
+/** The runtime version (UP-3, packages/core/src/version.ts). */
+export function runtimeVersion(): string {
+  return VERSION;
+}

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

@@ -0,0 +1,89 @@
+
+
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CliError } from "./log.ts";
+
+const CANDIDATES = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+];
+
+export function findChrome(): string {
+  const found =
+    [process.env.AKAN_NATIVE_CHROME, ...CANDIDATES].find((p): p is string => !!p && existsSync(p)) ??
+    Bun.which("google-chrome") ??
+    Bun.which("chromium");
+  if (!found) throw new CliError("no Chrome/Chromium found for `akan-native test web` (set AKAN_NATIVE_CHROME)");
+  return found;
+}
+
+function formatArg(arg: { type: string; value?: unknown; description?: string }): string {
+  if (arg.value !== undefined) return typeof arg.value === "string" ? arg.value : JSON.stringify(arg.value);
+  return arg.description ?? arg.type;
+}
+
+/** Opens `url` in a fresh headless profile and forwards console lines and exceptions. */
+export async function openHeadless(
+  url: string,
+  onLine: (line: string) => void,
+): Promise<{ stop(): void; exited: Promise<number> }> {
+  const profile = mkdtempSync(join(tmpdir(), "akan-native-chrome-"));
+  const port = 9300 + Math.floor(Math.random() * 500);
+  const chrome = Bun.spawn(
+    [
+      findChrome(),
+      "--headless=new",
+      "--disable-gpu",
+      "--no-first-run",
+      "--no-default-browser-check",
+      `--user-data-dir=${profile}`,
+      `--remote-debugging-port=${port}`,
+      "about:blank",
+    ],
+    { stdin: "ignore", stdout: "ignore", stderr: "ignore" },
+  );
+  let target: { webSocketDebuggerUrl: string } | undefined;
+  for (let i = 0; i < 100 && !target; i++) {
+    await Bun.sleep(100);
+    const list = (await fetch(`http://127.0.0.1:${port}/json`)
+      .then((r) => r.json())
+      .catch(() => [])) as { type: string; webSocketDebuggerUrl: string }[];
+    target = list.find((t) => t.type === "page");
+  }
+  if (!target) {
+    chrome.kill();
+    throw new CliError("headless Chrome did not start");
+  }
+  const ws = new WebSocket(target.webSocketDebuggerUrl);
+  await new Promise((resolve, reject) => {
+    ws.onopen = resolve;
+    ws.onerror = reject;
+  });
+  let id = 0;
+  const send = (method: string, params: object = {}) => ws.send(JSON.stringify({ id: ++id, method, params }));
+  ws.onmessage = (event) => {
+    const message = JSON.parse(String(event.data));
+    if (message.method === "Runtime.consoleAPICalled") {
+      onLine(`[page ${message.params.type}] ${message.params.args.map(formatArg).join(" ")}`);
+    } else if (message.method === "Runtime.exceptionThrown") {
+      const details = message.params.exceptionDetails;
+      onLine(`[page error] ${details.exception?.description ?? details.text}`);
+    }
+  };
+  send("Runtime.enable");
+  send("Page.enable");
+  send("Page.navigate", { url });
+  return {
+    exited: chrome.exited,
+    stop() {
+      try {
+        ws.close();
+      } catch {}
+      chrome.kill();
+      rmSync(profile, { recursive: true, force: true });
+    },
+  };
+}