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

package/vendor/@akanjs/native/packages/cli/src/commands/plugin.ts

@@ -0,0 +1,164 @@
+
+
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { parseArgs, stringFlag } from "../lib/args.ts";
+import {
+  buildModel,
+  type GenModel,
+  generateKotlin,
+  generateSwift,
+  kotlinStub,
+  specProblems,
+  swiftStub,
+  untypedMembers,
+} from "../lib/codegen.ts";
+import { CliError, dim, log } from "../lib/log.ts";
+import { androidPlugins, desktopModuleProblems, iosPlugins } from "../lib/native-plugins.ts";
+import { findAppDir, loadProject, type NativeSubset, type ResolvedPlugin, resolvePlugins } from "../lib/project.ts";
+import { readPluginSpec } from "../lib/spec.ts";
+import { compileAndroidPlugins } from "../platforms/android.ts";
+import { typecheckIosPlugins } from "../platforms/ios.ts";
+
+export const PLUGIN_USAGE =
+  "akan-native plugin check [dir] | akan-native plugin codegen [dir] [--out <dir>] | akan-native plugin stub <ios|android> [dir] | akan-native plugin compile <ios|android> [dir] [--only id,id]";
+
+/** The plugin in `dir` (a folder with native-plugin.json), or every plugin of the app there. */
+async function pluginsAt(dir: string): Promise<ResolvedPlugin[]> {
+  if (existsSync(join(dir, "native-plugin.json"))) return resolvePlugins(dir, ["."]);
+  return (await loadProject(findAppDir(dir))).plugins;
+}
+
+function onePlugin(plugins: ResolvedPlugin[], dir: string): ResolvedPlugin {
+  if (plugins.length !== 1) throw new CliError(`${dir} is not a plugin folder (no native-plugin.json)`);
+  return plugins[0]!;
+}
+
+const model = (plugin: ResolvedPlugin, platform?: "ios" | "android"): GenModel => {
+  const native = platform ? plugin.manifest[platform] : undefined;
+  const subset: NativeSubset = native && typeof native === "object" ? native : {};
+  return buildModel(readPluginSpec(plugin.dir), plugin.manifest.id, {
+    methods: subset.methods ?? plugin.manifest.methods,
+    events: subset.events ?? plugin.manifest.events,
+    source: relative(plugin.dir, join(plugin.dir, "src/index.ts")),
+  });
+};
+
+async function check(dir: string): Promise<number> {
+  let failed = 0;
+  for (const plugin of await pluginsAt(dir)) {
+    const id = plugin.manifest.id;
+    try {
+      const problems = [
+        ...specProblems(plugin.manifest, readPluginSpec(plugin.dir)),
+        ...(await desktopModuleProblems(plugin)),
+      ];
+      const untyped = untypedMembers(model(plugin));
+      if (problems.length) {
+        failed++;
+        log.error(`${id}:\n    ${problems.join("\n    ")}`);
+      } else log.ok(`${id}${plugin.manifest.codegen ? dim(" (codegen)") : ""}`);
+      for (const u of untyped) log.info(dim(`untyped ${u}`));
+    } catch (error) {
+      failed++;
+      log.error(`${id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return failed ? 1 : 0;
+}
+
+function codegen(plugin: ResolvedPlugin, out: string): number {
+  const written: string[] = [];
+  for (const platform of ["ios", "android"] as const) {
+    const native = plugin.manifest[platform];
+    const m = model(plugin, platform);
+    const file =
+      platform === "ios"
+        ? join(out, "ios", `${m.prefix}PluginSpec.swift`)
+        : join(out, "android", `${m.prefix}PluginSpec.kt`);
+    const pkg =
+      native && typeof native === "object" && "class" in native
+        ? native.class.replace(/\.[^.]+$/, "")
+        : `com.akanjs.plugins.${plugin.manifest.id.replace(/-/g, "")}`;
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, platform === "ios" ? generateSwift(m) : generateKotlin(m, pkg));
+    written.push(relative(process.cwd(), file) || file);
+  }
+  log.ok(`wrote ${written.join(", ")}`);
+  if (!plugin.manifest.codegen) log.info(dim('builds use these only with "codegen": true in native-plugin.json'));
+  return 0;
+}
+
+function stub(plugin: ResolvedPlugin, platform: "ios" | "android"): number {
+  const native = plugin.manifest[platform];
+  const m = model(plugin, platform);
+  const className = native && typeof native === "object" ? native.class.split(".").at(-1)! : `${m.prefix}Plugin`;
+  if (platform === "ios") console.info(swiftStub(m, className));
+  else {
+    const pkg =
+      native && typeof native === "object"
+        ? native.class.replace(/\.[^.]+$/, "")
+        : `com.akanjs.plugins.${plugin.manifest.id.replace(/-/g, "")}`;
+    console.info(kotlinStub(m, pkg, className));
+  }
+  return 0;
+}
+
+/** Compiles the shell with just these plugins' native sources and generated bindings. */
+async function compileNative(plugins: ResolvedPlugin[], platform: "ios" | "android", appDir: string): Promise<number> {
+  const natives = platform === "ios" ? iosPlugins(plugins) : androidPlugins(plugins);
+  if (!natives.length) throw new CliError(`none of these plugins has a native ${platform} implementation`);
+  const ids = natives.map((n) => n.plugin.manifest.id).join(", ");
+  log.step(`${platform === "ios" ? "swiftc -typecheck" : "kotlinc"}: shell + ${ids}`);
+  const started = performance.now();
+  const result =
+    platform === "ios"
+      ? await typecheckIosPlugins(iosPlugins(plugins), appDir)
+      : await compileAndroidPlugins(androidPlugins(plugins), appDir);
+  const output = `${result.stdout}${result.stderr}`.trim();
+  if (output) console.info(output);
+  if (result.code !== 0) {
+    log.error(`${platform} compile failed`);
+    return 1;
+  }
+  log.ok(`${platform}: compiled ${dim(`in ${Math.round(performance.now() - started)} ms`)}`);
+  return 0;
+}
+
+export async function plugin(argv: string[]): Promise<number> {
+  const args = parseArgs(argv);
+  const [sub, ...rest] = args.positional;
+  switch (sub) {
+    case "check":
+      return check(resolve(rest[0] ?? "."));
+    case "codegen": {
+      const dir = resolve(rest[0] ?? ".");
+      const p = onePlugin(await pluginsAt(dir), dir);
+      return codegen(p, resolve(stringFlag(args, "out") ?? join(p.dir, ".akan", "native", "codegen")));
+    }
+    case "stub": {
+      const platform = rest[0];
+      if (platform !== "ios" && platform !== "android") throw new CliError(`usage: ${PLUGIN_USAGE}`, 2);
+      const dir = resolve(rest[1] ?? ".");
+      return stub(onePlugin(await pluginsAt(dir), dir), platform);
+    }
+    case "compile": {
+      const platform = rest[0];
+      if (platform !== "ios" && platform !== "android") throw new CliError(`usage: ${PLUGIN_USAGE}`, 2);
+      const dir = resolve(rest[1] ?? ".");
+      const only = stringFlag(args, "only")
+        ?.split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+      let plugins = await pluginsAt(dir);
+      if (only) {
+        const unknown = only.filter((id) => !plugins.some((p) => p.manifest.id === id));
+        if (unknown.length) throw new CliError(`--only: no plugin ${unknown.join(", ")} here`);
+        plugins = plugins.filter((p) => only.includes(p.manifest.id));
+      }
+      return compileNative(plugins, platform, existsSync(join(dir, "native-plugin.json")) ? dir : findAppDir(dir));
+    }
+    default:
+      throw new CliError(`usage: ${PLUGIN_USAGE}`, 2);
+  }
+}

package/vendor/@akanjs/native/packages/cli/src/commands/signing.ts

@@ -0,0 +1,32 @@
+
+
+import { parseArgs } from "../lib/args.ts";
+import { CliError, dim, log } from "../lib/log.ts";
+import { devIdentity, setupSigning } from "../lib/signing.ts";
+
+export const SIGNING_USAGE = "akan-native signing setup | akan-native signing status";
+
+export async function signing(argv: string[]): Promise<number> {
+  const [sub] = parseArgs(argv).positional;
+  if (sub === "setup") {
+    log.step("creating a code-signing identity in the login keychain (macOS asks for your password to trust it)");
+    const { identity, created } = await setupSigning();
+    log.ok(`${created ? "created" : "using"} "${identity.name}" (${identity.hash})`);
+    log.info(
+      dim(
+        "macOS builds are signed with it from now on (AKAN_NATIVE_SIGNING=adhoc for ad-hoc). TCC grants and Keychain items survive rebuilds.",
+      ),
+    );
+    return 0;
+  }
+  if (sub === "status" || sub === undefined) {
+    const identity = await devIdentity();
+    log.info(
+      identity
+        ? `macOS builds are signed with "${identity.name}" (${identity.hash})`
+        : "macOS builds are ad-hoc signed (run `akan-native signing setup` for a stable identity)",
+    );
+    return 0;
+  }
+  throw new CliError(`usage: ${SIGNING_USAGE}`, 2);
+}

package/vendor/@akanjs/native/packages/cli/src/commands/test.ts

@@ -0,0 +1,130 @@
+
+
+import { checkFlags, parseArgs, stringFlag } from "../lib/args.ts";
+import { onStopSignal } from "../lib/launch.ts";
+import { bold, CliError, dim, green, log, red } from "../lib/log.ts";
+import { hostTargets, PLATFORM_TARGETS, TARGETS, type TargetPlatform } from "../platforms/index.ts";
+import { BOOLEAN_FLAGS, buildFromArgs } from "./build.ts";
+
+export const TEST_USAGE = `akan-native test <${TARGETS.join("|")}|all> [--app <dir>] [--mode <mode>] [--skip-web-build] [--timeout <s>] [--device <name>] [--avd <name>]`;
+
+const MARKER = "AKAN_NATIVE_SELFTEST ";
+const DESKTOP: readonly TargetPlatform[] = ["macos", "windows", "linux"];
+/** The report in base64 parts (`AKAN_NATIVE_SELFTEST_PART 1/3 …`): host logs cut long lines (Android ~4 KB). */
+const PART = /AKAN_NATIVE_SELFTEST_PART (\d+)\/(\d+) ([A-Za-z0-9+/=]+)/;
+
+interface Report {
+  pass: boolean;
+  platform: string;
+  results: { name: string; ok: boolean; detail?: string }[];
+}
+
+export async function test(argv: string[]): Promise<number> {
+  const args = parseArgs(argv, BOOLEAN_FLAGS);
+  
+  checkFlags(args, ["app", "mode", "skip-web-build", "timeout", "device", "avd"], TEST_USAGE);
+  const which = args.positional[0] ?? "all";
+  
+  const platforms: TargetPlatform[] = which === "all" ? hostTargets() : [which as TargetPlatform];
+  if (platforms.some((p) => !TARGETS.includes(p)))
+    throw new CliError(`expected a platform or "all": ${TARGETS.join(", ")}`, 2);
+  const timeout = Number(stringFlag(args, "timeout") ?? 180) * 1000;
+  
+  const device = stringFlag(args, "device");
+  const avd = stringFlag(args, "avd");
+  const target = { ...(device ? { device } : {}), ...(avd ? { avd } : {}) };
+
+  const summary: { platform: string; ok: boolean; detail: string }[] = [];
+  for (const [i, platform] of platforms.entries()) {
+    
+    if (i > 0) args.flags["skip-web-build"] = true;
+    const { ctx, artifact } = await buildFromArgs(args, { mode: "development", profile: "debug" }, platform);
+    log.step(`self-test on ${platform}`);
+    const tail: string[] = [];
+    let report: Report | null = null;
+    const parts = new Map<number, string>();
+    let resolveReport!: () => void;
+    const reported = new Promise<void>((resolve) => (resolveReport = resolve));
+    const app = await PLATFORM_TARGETS[platform].launch(ctx, artifact, {
+
+      env: {
+        AKAN_NATIVE_PUBLIC_SELFTEST: "1",
+        ...(DESKTOP.includes(platform)
+          ? {
+              AKAN_NATIVE_TEST_PANELS: process.env.AKAN_NATIVE_TEST_PANELS ?? "auto",
+              AKAN_NATIVE_TEST_NO_THROTTLING: "1",
+            }
+          : {}),
+      },
+      headless: true,
+      ...target,
+      onLine(line) {
+        const part = PART.exec(line);
+        if (part) {
+          parts.set(Number(part[1]), part[3]!);
+          if (parts.size === Number(part[2])) {
+            try {
+              const encoded = [...parts]
+                .sort(([a], [b]) => a - b)
+                .map(([, chunk]) => chunk)
+                .join("");
+              report = JSON.parse(Buffer.from(encoded, "base64").toString("utf8")) as Report;
+            } catch {
+              tail.push(line);
+            }
+            resolveReport();
+          }
+          return;
+        }
+        const at = line.indexOf(MARKER);
+        if (at >= 0) {
+          try {
+            report = JSON.parse(line.slice(at + MARKER.length)) as Report;
+          } catch {
+            tail.push(line);
+          }
+          resolveReport();
+          return;
+        }
+        tail.push(line);
+        if (tail.length > 40) tail.shift();
+      },
+    });
+    const off = onStopSignal(() => {
+      app.stop();
+      process.exit(130);
+    });
+    const timer = new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), timeout));
+    const outcome = await Promise.race([
+      reported.then(() => "report" as const),
+      app.exited.then(() => "exited" as const),
+      timer,
+    ]);
+    off();
+    app.stop();
+
+    const r = report as Report | null;
+    if (!r) {
+      log.error(`${platform}: no self-test report (${outcome})`);
+      if (tail.some((line) => line.includes("single-instance: another instance is already running"))) {
+        log.info(
+          `  The app is already running (single-instance handed this launch over). Quit it and run the test again.`,
+        );
+      }
+      for (const line of tail.slice(-20)) log.info(dim(line));
+      summary.push({ platform, ok: false, detail: `no report (${outcome})` });
+      continue;
+    }
+    for (const result of r.results) {
+      log.info(
+        `${result.ok ? green("PASS") : red("FAIL")} ${result.name}${result.detail ? dim(` — ${result.detail}`) : ""}`,
+      );
+    }
+    const failed = r.results.filter((x) => !x.ok).length;
+    summary.push({ platform, ok: r.pass, detail: `${r.results.length - failed}/${r.results.length}` });
+  }
+
+  console.info("");
+  for (const s of summary) console.info(`${s.ok ? green("✓") : red("✗")} ${bold(s.platform.padEnd(8))} ${s.detail}`);
+  return summary.every((s) => s.ok) ? 0 : 1;
+}

package/vendor/@akanjs/native/packages/cli/src/commands/toolchain.ts

@@ -0,0 +1,143 @@
+
+
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CliError, dim, log } from "../lib/log.ts";
+import {
+  androidSdkRoot,
+  installPath,
+  installTool,
+  missingSdkPackages,
+  pinnedKotlin,
+  pinnedSdkPackages,
+  resolveBuildTools,
+  resolveJdk,
+  rustToolchainFileVersion,
+  sdkLicenseAccepted,
+  sdkmanager,
+  TOOLCHAIN,
+  toolchainsDir,
+} from "../lib/toolchains.ts";
+
+export const TOOLCHAIN_USAGE =
+  "akan-native toolchain [list] | akan-native toolchain install <kotlin|jdk|bundletool|rust|android>";
+
+const short = (path: string) => path.replace(homedir(), "~");
+
+function list(): number {
+  const rows: [string, string, string][] = [];
+  const kotlin = pinnedKotlin();
+  rows.push([
+    "kotlinc",
+    TOOLCHAIN.kotlin.version,
+    kotlin ? `installed (${short(kotlin.home)})` : "not installed: installs on first Android build",
+  ]);
+  const jdk = resolveJdk();
+  rows.push([
+    "JDK",
+    `${TOOLCHAIN.jdk.minMajor}+ (install: Temurin ${TOOLCHAIN.jdk.version})`,
+    jdk ? `${jdk.version} (${jdk.source}: ${short(jdk.home)})` : "none found",
+  ]);
+  const sdk = androidSdkRoot();
+  const bt = sdk ? resolveBuildTools(sdk) : null;
+  rows.push([
+    "build-tools",
+    TOOLCHAIN.android.buildTools,
+    bt ? `${bt.version}${bt.warning ? " (not the pinned one)" : ""}` : "not found",
+  ]);
+  rows.push([
+    "Android platform",
+    `android-${TOOLCHAIN.android.compileSdk}`,
+    sdk && !missingSdkPackages(sdk).some((p) => p.startsWith("platforms;")) ? "installed" : "not installed",
+  ]);
+  rows.push([
+    "bundletool",
+    TOOLCHAIN.bundletool.version,
+    existsSync(installPath("bundletool", TOOLCHAIN.bundletool.version))
+      ? "installed (akan-native)"
+      : "installed on the first App Bundle build",
+  ]);
+  rows.push([
+    "Rust",
+    rustToolchainFileVersion() ?? TOOLCHAIN.rust.version,
+    "native/desktop/rust-toolchain.toml (rustup)",
+  ]);
+  rows.push(["Bun", TOOLCHAIN.bun.version, Bun.version]);
+  rows.push(["Xcode", `${TOOLCHAIN.xcode.min}+`, "see akan-native doctor ios"]);
+  console.info(`${"tool".padEnd(18)}${"pinned".padEnd(40)}found`);
+  for (const [tool, pinned, found] of rows) console.info(`${tool.padEnd(18)}${pinned.padEnd(40)}${found}`);
+  console.info(dim(`\ntoolchains folder: ${short(toolchainsDir())} (AKAN_NATIVE_HOME moves it)`));
+  return 0;
+}
+
+async function install(tool: string | undefined): Promise<number> {
+  switch (tool) {
+    case "kotlin":
+    case "kotlinc": {
+      const home = await installTool("kotlin");
+      log.ok(`kotlinc ${TOOLCHAIN.kotlin.version}: ${short(home)}`);
+      return 0;
+    }
+    case "bundletool": {
+      const home = await installTool("bundletool");
+      log.ok(`bundletool ${TOOLCHAIN.bundletool.version}: ${short(home)}`);
+      return 0;
+    }
+    case "jdk": {
+      const existing = resolveJdk();
+      if (existing)
+        log.info(
+          dim(
+            `a suitable JDK is already available: ${existing.version} (${existing.source}); installing the pinned one anyway`,
+          ),
+        );
+      const home = await installTool("jdk");
+      log.ok(`JDK ${TOOLCHAIN.jdk.version}: ${short(join(home, "Contents", "Home"))} (used when JAVA_HOME is not set)`);
+      return 0;
+    }
+    case "rust": {
+      const version = rustToolchainFileVersion() ?? TOOLCHAIN.rust.version;
+      const rustup = Bun.which("rustup", { PATH: `${process.env.PATH}:${join(homedir(), ".cargo", "bin")}` });
+      if (!rustup) throw new CliError("rustup not found. Install Rust: curl https://sh.rustup.rs -sSf | sh");
+      const p = Bun.spawn([rustup, "toolchain", "install", version, "--profile", "minimal"], {
+        stdout: "inherit",
+        stderr: "inherit",
+      });
+      return (await p.exited) === 0 ? 0 : 1;
+    }
+    case "android": {
+      const sdk = androidSdkRoot();
+      if (!sdk) throw new CliError("Android SDK not found (install Android Studio or set ANDROID_HOME)");
+      const missing = missingSdkPackages(sdk);
+      if (missing.length === 0) {
+        log.ok(`pinned SDK packages are installed: ${pinnedSdkPackages().join(", ")}`);
+        return 0;
+      }
+      const manager = sdkmanager(sdk);
+      const cmd = `sdkmanager ${missing.map((p) => `"${p}"`).join(" ")}`;
+      if (!manager)
+        throw new CliError(
+          `sdkmanager not found. Install "Android SDK Command-line Tools" in Android Studio > Settings > Android SDK > SDK Tools, then: ${cmd}`,
+        );
+      
+      if (!sdkLicenseAccepted(sdk))
+        throw new CliError(`Accept the Android SDK licenses yourself first: ${manager} --licenses\nthen run: ${cmd}`);
+      const p = Bun.spawn([manager, `--sdk_root=${sdk}`, ...missing], {
+        stdin: "ignore",
+        stdout: "inherit",
+        stderr: "inherit",
+      });
+      return (await p.exited) === 0 ? 0 : 1;
+    }
+    default:
+      throw new CliError(`usage: ${TOOLCHAIN_USAGE}`, 2);
+  }
+}
+
+export async function toolchain(args: string[]): Promise<number> {
+  const [sub, tool] = args;
+  if (!sub || sub === "list") return list();
+  if (sub === "install") return install(tool);
+  throw new CliError(`usage: ${TOOLCHAIN_USAGE}`, 2);
+}

package/vendor/@akanjs/native/packages/cli/src/commands/update.ts

@@ -0,0 +1,168 @@
+
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { checkFlags, type ParsedArgs, parseArgs, stringFlag } from "../lib/args.ts";
+import { runtimeVersion } from "../lib/boot.ts";
+import { BUNDLE_FILE, readBundleInfo } from "../lib/compat.ts";
+import { bold, CliError, dim, log } from "../lib/log.ts";
+import { findAppDir, loadProject } from "../lib/project.ts";
+import {
+  generateUpdateKey,
+  hostArch,
+  sha256,
+  signManifest,
+  type UpdateFile,
+  type UpdateManifest,
+  updateKeyPath,
+} from "../lib/updates.ts";
+import { publishAppUpdate } from "../platforms/desktop-update.ts";
+import { BOOLEAN_FLAGS, buildFromArgs } from "./build.ts";
+
+export const UPDATE_USAGE =
+  "akan-native update keygen [--app <dir>] | akan-native update publish <ios|android|macos|windows|linux> [--app <dir>] [--mode <mode>] [--debug] [--channel <name>] [--out <dir>] | akan-native update serve [--app <dir>] [--out <dir>] [--port <n>]";
+
+const outDir = (args: ParsedArgs, appDir: string) =>
+  resolve(stringFlag(args, "out") ?? join(appDir, ".akan", "native", "updates"));
+
+async function keygen(args: ParsedArgs): Promise<number> {
+  const project = await loadProject(findAppDir(stringFlag(args, "app") ?? process.cwd()));
+  const path = updateKeyPath(project.config.app.id);
+  const { publicKey, created } = generateUpdateKey(path);
+  if (created)
+    log.ok(
+      `created the update signing key ${path} ${dim("(keep it private and backed up: without it, installed apps accept no more updates)")}`,
+    );
+  else log.info(`using the existing key ${path}`);
+  log.info(
+    `Add to akan-native.config.ts:\n\n  updates: { url: "https://…/updates", publicKey: ${JSON.stringify(publicKey)} },\n`,
+  );
+  if (project.config.updates && project.config.updates.publicKey !== publicKey)
+    log.warn("akan-native.config.ts has a different updates.publicKey");
+  return 0;
+}
+
+/** Every file of a web bundle as the app serves it: index.html with the init script and CSP, public/, env.runtime.json. */
+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;
+}
+
+async function publish(args: ParsedArgs): Promise<number> {
+  const arg = args.positional[1];
+  const desktop = arg === "macos" || arg === "windows" || arg === "linux" ? arg : null;
+  if (!desktop && arg !== "ios" && arg !== "android") throw new CliError(`usage: ${UPDATE_USAGE}`, 2);
+  const platform = desktop ?? (arg as "ios" | "android");
+  const { ctx, artifact } = await buildFromArgs(
+    { positional: [platform], flags: args.flags },
+    { mode: "production", profile: "release" },
+    platform,
+  );
+  const { config, appDir } = ctx.project;
+  if (!config.updates)
+    throw new CliError("akan-native.config.ts has no updates: { url, publicKey } (run `akan-native update keygen`)");
+  const channel = stringFlag(args, "channel") ?? config.updates.channel;
+  
+  const out = join(outDir(args, appDir), desktop ? `${desktop}-${hostArch()}` : platform);
+  const keyPath = updateKeyPath(config.app.id);
+  const sequence = Math.floor(Date.now() / 1000);
+
+  let manifest: UpdateManifest;
+  if (desktop) {
+    manifest = await publishAppUpdate(ctx, desktop, artifact, out, channel, sequence);
+  } else {
+    const info = readBundleInfo(join(ctx.outDir, BUNDLE_FILE));
+    mkdirSync(join(out, "files"), { recursive: true });
+    const files: UpdateFile[] = webFiles(ctx.webDir, ctx.html, ctx.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 };
+    });
+    manifest = {
+      schema: 1,
+      kind: "web",
+      app: config.app.id,
+      platform,
+      channel,
+      nativeApi: info.nativeApi.hash,
+      sequence,
+      bundle: `${sequence}-${info.web.hash.slice(0, 8)}`,
+      runtimeVersion: runtimeVersion(),
+      version: config.app.version,
+      files,
+    };
+  }
+  const bytes = new TextEncoder().encode(`${JSON.stringify(manifest, null, 2)}\n`);
+  mkdirSync(out, { recursive: true });
+  writeFileSync(join(out, `${channel}.json`), bytes);
+  writeFileSync(join(out, `${channel}.json.sig`), `${signManifest(bytes, keyPath, config.updates.publicKey)}\n`);
+  const size = manifest.files.reduce((n, f) => n + f.size, 0);
+  log.ok(
+    `published ${bold(manifest.bundle)} to ${relative(process.cwd(), out) || out}/${channel}.json ${dim(`(${manifest.files.length} files, ${(size / 1024).toFixed(0)} KiB${manifest.nativeApi ? `, native API ${manifest.nativeApi}` : ""})`)}`,
+  );
+  log.info(
+    dim(
+      `Upload ${relative(process.cwd(), join(out, ".."))} to ${config.updates.url} (or try it with \`akan-native update serve\`).`,
+    ),
+  );
+  return 0;
+}
+
+async function serve(args: ParsedArgs): Promise<number> {
+  const appDir = findAppDir(stringFlag(args, "app") ?? process.cwd());
+  const root = outDir(args, appDir);
+  const port = Number(stringFlag(args, "port") ?? 8790);
+  const server = Bun.serve({
+    port,
+    hostname: "0.0.0.0", // the Android emulator reaches the Mac as 10.0.2.2
+    fetch(req) {
+      const path = decodeURIComponent(new URL(req.url).pathname);
+      const file = resolve(root, `.${path}`);
+      if (!file.startsWith(root + sep) || !existsSync(file) || statSync(file).isDirectory()) {
+        log.info(dim(`404 ${path}`));
+        return new Response("not found", { status: 404 });
+      }
+      log.info(dim(`200 ${path}`));
+      return new Response(Bun.file(file), { headers: { "cache-control": "no-store" } });
+    },
+  });
+  log.ok(
+    `serving ${relative(process.cwd(), root) || root} at http://localhost:${server.port} ${dim(`(Android emulator: http://10.0.2.2:${server.port})`)}`,
+  );
+  await new Promise(() => {});
+  return 0;
+}
+
+export async function update(argv: string[]): Promise<number> {
+  const args = parseArgs(argv, BOOLEAN_FLAGS);
+  
+  const known = {
+    keygen: ["app"],
+    publish: ["app", "mode", "debug", "channel", "out", "skip-web-build"],
+    serve: ["app", "out", "port"],
+  }[args.positional[0] as string];
+  if (known) checkFlags(args, known, UPDATE_USAGE);
+  switch (args.positional[0]) {
+    case "keygen":
+      return keygen(args);
+    case "publish":
+      return publish(args);
+    case "serve":
+      return serve(args);
+    default:
+      throw new CliError(`usage: ${UPDATE_USAGE}`, 2);
+  }
+}