@akanjs/cli 3.0.0-beta.27 → 3.0.0-beta.29

package/{index-118vq9dh.js → index-n9gxx7bp.js}

@@ -37,27 +37,29 @@ import {
 import {
   runner,
   script
-} from "./index-58cyna2s.js";
+} from "./index-b68zfsvz.js";
 import {
   WorkspaceExecutor,
   AppExecutor,
   LibExecutor,
   PkgExecutor
-} from "./index-0n9q1f23.js";
-import {
-  LibraryScript
-} from "./index-5mm3g24t.js";
+} from "./index-r8gp8zk3.js";
 import {
+  DesktopServerStage,
   resolveMobileTargets,
+  resolveAppId,
   NativeApp
-} from "./index-y736f42m.js";
+} from "./index-1hs6jrys.js";
+import {
+  LibraryScript
+} from "./index-qtz88kh0.js";
 import {
   stripAnsi
 } from "./index-7md2g9vw.js";
 import {
   SlicePlanner,
   formatSlicePlan
-} from "./index-860zjnr1.js";
+} from "./index-nbg9bfnr.js";
 import {
   openBrowser
 } from "./index-9dp031by.js";
@@ -67,6 +69,7 @@ import { confirm } from "@inquirer/prompts";
 import { Logger as Logger6 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/application/application.runner.ts
+import { realpathSync } from "fs";
 import path5 from "path";
 
 // pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
@@ -725,6 +728,7 @@ class AkanAppHost {
   #backendGaveUp = false;
   #backendLifecycleState = "stopped";
   #pendingRestartReason = null;
+  #backendRestart = null;
   #pendingRecycle = null;
   #restartFailedAfterApply = null;
   #stopping = false;
@@ -796,7 +800,9 @@ class AkanAppHost {
     this.#cancelIdleSuspend();
     this.#stopIdleWatcher();
     this.#clearRestartTimers();
+    this.#pendingRestartReason = null;
     this.#failPendingBuilderMessages("dev server is shutting down");
+    await this.#backendRestart;
     await this.#stopBackend();
     this.#stopBuilder();
     return this;
@@ -817,6 +823,12 @@ class AkanAppHost {
     return await createTunnel(type, { app: this.app, environment });
   }
   #startBackend(startStatus = null) {
+    if (this.#stopping)
+      return;
+    if (this.#backend) {
+      this.logger.warn(`backend pid=${this.#backend.pid} is still running; not starting a second one`);
+      return;
+    }
     this.#builderRequests.startGeneration();
     this.#discardPendingBuilderMessages("the backend restarted while the builder was away");
     this.#backendStartStatus = startStatus;
@@ -849,6 +861,8 @@ class AkanAppHost {
             message: msg.data.message
           });
           this.#sendOrQueueBuildStatus(status);
+          if (!status.ok)
+            this.#emitDevEvent("failed", status.message);
           return;
         }
         if (backendMsgTypeSet.has(msg.type))
@@ -997,11 +1011,17 @@ class AkanAppHost {
       clearTimeout(this.#restartTimer);
     this.#restartTimer = setTimeout(() => {
       this.#restartTimer = null;
+      this.#backendRestart ??= this.#drainBackendRestarts().finally(() => {
+        this.#backendRestart = null;
+      });
+    }, BACKEND_RESTART_DEBOUNCE_MS);
+  }
+  async#drainBackendRestarts() {
+    while (this.#pendingRestartReason && !this.#restartTimer && !this.#stopping) {
       const next = this.#pendingRestartReason;
       this.#pendingRestartReason = null;
-      if (next)
-        this.#restartBackend(next);
-    }, BACKEND_RESTART_DEBOUNCE_MS);
+      await this.#restartBackend(next);
+    }
   }
   async#restartBackend(reason) {
     this.logger.verbose(`[backend-reload] restarting backend generation=${reason.generation ?? "(unknown)"} files=${reason.files.length} roles=${reason.roles.join(",") || "(none)"}`);
@@ -1306,7 +1326,7 @@ ${this.#backendStderrTail.join(`
     this.logger.info(`[idle-suspend] no build activity for ${Math.round(idleMs / 1000)}s; released the builder \u2014 the next edit or route request brings it back`);
   }
   get #restartPending() {
-    return !!(this.#pendingRecycle || this.#restartTimer || this.#backendRecoveryTimer || this.#builderRecoveryTimer || this.#rssRecycleReason);
+    return !!(this.#pendingRecycle || this.#restartTimer || this.#backendRestart || this.#backendRecoveryTimer || this.#builderRecoveryTimer || this.#rssRecycleReason);
   }
   async#startIdleWatcher() {
     try {
@@ -1609,6 +1629,7 @@ ${this.#backendStderrTail.join(`
     this.#clearRestartTimers();
     this.#builderRecoveryAttempts = 0;
     this.#pendingRestartReason = null;
+    await this.#backendRestart;
     this.#lastGoodFrontend = {};
     this.#buildStatusByPhase.clear();
     this.#pendingBuildStatusReplay = [];
@@ -1846,7 +1867,7 @@ ${uniqueCandidates.map((candidate) => `  - ${candidate}`).join(`
 
 // pkgs/@akanjs/cli/application/application.runner.ts
 import { Logger as Logger3 } from "akanjs/common";
-var loadBuildRunner = async () => (await import("./applicationBuildRunner-r6b9rkb8.js")).ApplicationBuildRunner;
+var loadBuildRunner = async () => (await import("./applicationBuildRunner-ez37p161.js")).ApplicationBuildRunner;
 var loadPrompts = async () => await import("@inquirer/prompts");
 
 class ApplicationRunner extends runner("application") {
@@ -2038,59 +2059,155 @@ try {
       setTimeout(() => openBrowser(`http://localhost:${env.AKAN_PUBLIC_CLIENT_PORT ?? env.PORT ?? "8282"}`), 3000);
     return appHost;
   }
-  async buildMobile(app, platform, { target, env = "debug", profile = "release" } = {}) {
+  async buildMobile(app, platform, { target, env = "debug", profile = "release", installer = false } = {}) {
     const targets = await resolveMobileTargets(app, target);
-    await this.#buildMobileCsr(app, env);
+    if (installer && platform !== "windows")
+      throw new Error(`--installer builds a Windows setup program; this computer builds for ${platform}.`);
+    const carried = await this.#stageMobile(app, platform, targets, env);
     await this.#runMobileTargets(targets, async (mobileTarget) => {
-      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget).build(platform, { profile }));
+      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).build(platform, {
+        profile,
+        ...carried && ApplicationRunner.carriesServer(mobileTarget, platform) ? { server: carried } : {},
+        ...installer ? { installer } : {}
+      }));
     });
   }
-  async startMobile(app, platform, { target, env = "local", operation = "local", device, teamId } = {}) {
-    const targets = await resolveMobileTargets(app, target);
-    const [mobileTarget] = targets;
-    if (!mobileTarget || targets.length > 1)
-      throw new Error(`start-${platform === "ios" || platform === "android" ? platform : "desktop"} runs one mobile target at a time; pass --target <name>.`);
-    const nativeApp = new NativeApp(app, mobileTarget);
+  async buildDesktop(app, options = {}) {
+    await this.buildMobile(app, NativeApp.desktopPlatform(), options);
+  }
+  async startMobile(app, platform, { target, env = "local", operation = "local", device, teamId, interrupt } = {}) {
+    const mobileTarget = await ApplicationRunner.startTarget(app, platform, target);
+    const nativeApp = new NativeApp(app, mobileTarget, env);
     const selection = { ...device ? { device } : {}, ...teamId ? { teamId } : {} };
     if (operation === "release") {
-      await this.#buildMobileCsr(app, env);
-      const running = await nativeApp.run(platform, { ...selection, profile: "release" });
+      const carried = await this.#stageMobile(app, platform, [mobileTarget], env);
+      const running = await nativeApp.run(platform, {
+        ...selection,
+        profile: "release",
+        ...carried ? { server: carried } : {}
+      });
       await running.exited;
       return;
     }
     const upstream = `http://localhost:${await app.getDevPort()}`;
-    if (!await ApplicationRunner.#answers(upstream))
+    if (!await ApplicationRunner.answers(upstream, app.name, app.workspace.workspaceRoot))
       throw new Error(`No dev server answers on ${upstream}; run \`akan start ${app.name}\` first.`);
     const { i18n } = await app.getConfig();
     const session = await nativeApp.dev(platform, { upstream, lang: i18n.defaultLocale, ...selection });
-    process.once("SIGINT", () => {
-      session.stop().finally(() => process.exit(130));
-    });
+    if (interrupt)
+      interrupt.add(async () => await session.stop(), "Abandoning the app's shutdown; its window may stay open.", 130);
+    else
+      process.once("SIGINT", () => {
+        session.stop().finally(() => process.exit(130));
+      });
     await session.exited;
   }
   async startDesktop(app, options = {}) {
     await this.startMobile(app, NativeApp.desktopPlatform(), options);
   }
-  static async#answers(url) {
-    try {
-      await fetch(new URL("/_akan/app/health", url), { signal: AbortSignal.timeout(3000) });
-      return true;
-    } catch {
+  static async startTarget(app, platform = NativeApp.desktopPlatform(), target) {
+    const targets = await resolveMobileTargets(app, target);
+    const [mobileTarget] = targets;
+    if (!mobileTarget || targets.length > 1)
+      throw new Error(`start-${platform === "ios" || platform === "android" ? platform : "desktop"} runs one mobile target at a time; pass --target <name>.`);
+    return mobileTarget;
+  }
+  static async answers(url, appName, workspaceRoot) {
+    const signal = AbortSignal.timeout(3000);
+    const health = await fetch(new URL("/_akan/app/health", url), { signal }).catch(() => null);
+    if (!health)
       return false;
+    const info = await fetch(new URL("/_akan/app/info", url), { signal }).then(async (res) => res.ok ? await res.json() : null).catch(() => null);
+    const stopIt = `Stop it (\`akan start ${appName} --kill\` takes the port over) or give ${appName} another port with AKAN_DEV_PORT`;
+    if (info?.appName === appName) {
+      if (typeof info.workspaceRoot !== "string" || ApplicationRunner.#sameCheckout(info.workspaceRoot, workspaceRoot))
+        return true;
+      throw new Error(`${url} is the dev server of ${appName} in ${info.workspaceRoot}, not in ${workspaceRoot}. ${stopIt}.`);
     }
+    if (typeof info?.appName === "string")
+      throw new Error(`${url} is the dev server of ${info.appName}, not ${appName}. ${stopIt}.`);
+    const { pid } = await health.json().catch(() => null) ?? {};
+    throw new Error(typeof pid === "number" ? `${url} is an akan dev server (pid ${pid}) too old to say which app it serves. ${stopIt}.` : `${url} answers, but not as an akan dev server. Stop what holds the port or give ${appName} another port with AKAN_DEV_PORT.`);
+  }
+  static #sameCheckout(reported, own) {
+    const canonical = (root) => {
+      try {
+        return realpathSync.native(root);
+      } catch {
+        return path5.resolve(root);
+      }
+    };
+    return canonical(reported) === canonical(own);
   }
   async releaseIos(app, { target, env = "main", teamId, adHoc = false } = {}) {
     const targets = await resolveMobileTargets(app, target);
     await this.#buildMobileCsr(app, env);
     for (const mobileTarget of targets)
-      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget).releaseIos({ teamId, adHoc }));
+      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).releaseIos({ teamId, adHoc }));
   }
   async releaseAndroid(app, format, { target, env = "main" } = {}) {
     const targets = await resolveMobileTargets(app, target);
     NativeApp.androidSigning();
     await this.#buildMobileCsr(app, env);
     for (const mobileTarget of targets)
-      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget).releaseAndroid({ formats: [format] }));
+      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).releaseAndroid({ formats: [format] }));
+  }
+  async packUpdate(app, platform, { target, env = "main", out, against }) {
+    const targets = await resolveMobileTargets(app, target);
+    const [mobileTarget] = targets;
+    if (!mobileTarget || targets.length > 1)
+      throw new Error("pack-update packs one mobile target at a time; pass --target <name>.");
+    await this.#buildMobileCsr(app, env);
+    const packed = await new NativeApp(app, mobileTarget, env).packUpdate(platform, { out });
+    const size = packed.manifest.files.reduce((sum, file) => sum + file.size, 0);
+    app.logger.info(`packed ${mobileTarget.name} ${platform} for channel '${packed.channel}' to ${packed.out}: ${packed.manifest.files.length} files, ${(size / 1024).toFixed(0)} KiB, native API ${packed.manifest.nativeApi}`);
+    if (!against)
+      return;
+    const bundle = path5.join(packed.out, "bundle.json");
+    const compat = await NativeApp.compareBundles(app.cwdPath, against, bundle);
+    await Bun.write(path5.join(packed.out, "compat.json"), `${JSON.stringify({ against, ...compat }, null, 2)}
+`);
+    if (!compat.compatible)
+      throw new Error(`This bundle needs a new store build; the one ${against} came from provides another native API:
+- ${compat.problems.join(`
+- `)}`);
+    app.logger.info(`runs in the store build of ${against}`);
+  }
+  async updateKeygen(app, platform, target) {
+    const nativePlatform = platform === "desktop" ? NativeApp.desktopPlatform() : platform;
+    const seen = new Set;
+    for (const mobileTarget of await resolveMobileTargets(app, target ?? "all")) {
+      const appId = resolveAppId(mobileTarget.config.appId, nativePlatform);
+      if (seen.has(appId))
+        continue;
+      seen.add(appId);
+      const { publicKey, keyPath, created } = await new NativeApp(app, mobileTarget).updateKeygen(nativePlatform);
+      app.log(`${appId}: ${created ? "made" : "read"} ${keyPath}${created ? " (keep it private and backed up: without it, installed apps take no more updates)" : ""}`);
+      app.log(`  mobile: { updates: { url: "https://\u2026/${app.name}", publicKey: ${JSON.stringify(publicKey)} } }`);
+      const declared = mobileTarget.config.updates?.publicKey;
+      if (declared && declared !== publicKey)
+        app.logger.warn(`mobile.targets.${mobileTarget.name}.updates.publicKey is another key's; releases would not verify.`);
+    }
+  }
+  async publishUpdate(app, platform, { target, env = "main", channel } = {}) {
+    const targets = await resolveMobileTargets(app, target);
+    const nativePlatform = platform === "desktop" ? NativeApp.desktopPlatform() : platform;
+    for (const mobileTarget of targets)
+      await new NativeApp(app, mobileTarget, env).assertPublishable(nativePlatform, {
+        server: ApplicationRunner.carriesServer(mobileTarget, nativePlatform),
+        ...channel ? { channel } : {}
+      });
+    const carried = await this.#stageMobile(app, nativePlatform, targets, env);
+    for (const mobileTarget of targets) {
+      const nativeApp = new NativeApp(app, mobileTarget, env);
+      const published = await nativeApp.publishUpdate(nativePlatform, {
+        ...channel ? { channel } : {},
+        ...carried && ApplicationRunner.carriesServer(mobileTarget, nativePlatform) ? { server: carried } : {}
+      });
+      this.#reportBuild(app, mobileTarget, published.build);
+      app.log(`${app.name}/${mobileTarget.name} ${published.bundle}: ${published.dir}/${published.channel}.json, ${published.files} files, ${Math.round(published.size / 1024)} KiB`);
+      app.log(`Upload ${nativeApp.updatesDir} to ${mobileTarget.config.updates?.url}, the manifests last.`);
+    }
   }
   #reportBuild(app, mobileTarget, { artifacts, warnings, signing }) {
     for (const warning of warnings)
@@ -2100,6 +2217,15 @@ try {
     for (const artifact of artifacts)
       app.log(`${app.name}/${mobileTarget.name} ${artifact.kind}: ${artifact.path}`);
   }
+  static carriesServer({ config }, platform = NativeApp.desktopPlatform()) {
+    return platform !== "ios" && platform !== "android" && config.native?.desktop?.server === true;
+  }
+  async#stageMobile(app, platform, targets, env) {
+    const stage = targets.some((mobileTarget) => ApplicationRunner.carriesServer(mobileTarget, platform)) ? new DesktopServerStage(app) : null;
+    await stage?.install();
+    await this.#buildMobileCsr(app, env);
+    return await stage?.prepare(env);
+  }
   async#buildMobileCsr(app, env) {
     const prevEnv = {
       AKAN_PUBLIC_ENV: process.env.AKAN_PUBLIC_ENV,
@@ -2112,7 +2238,7 @@ try {
       APP_OPERATION_MODE: "release"
     });
     try {
-      await new (await loadBuildRunner())(app).build({ spinner: true });
+      await new (await loadBuildRunner())(app, { environment: env }).build({ spinner: true });
     } finally {
       for (const [key, value] of Object.entries(prevEnv)) {
         if (value === undefined)
@@ -2956,6 +3082,7 @@ class InterruptTeardown {
   #listen;
   #report;
   #interrupted = false;
+  #chain = Promise.resolve();
   ownsExit = true;
   constructor({ exit, listen, report } = {}) {
     this.#exit = exit ?? ((code) => process.exit(code));
@@ -2964,36 +3091,48 @@ class InterruptTeardown {
     });
     this.#report = report ?? ((message) => Logger5.rawLog(message, undefined, "error"));
   }
-  add(run, abandoned) {
-    this.#teardowns.push({ run, abandoned, running: false });
+  add(run, abandoned, exitCode = 0) {
+    this.#teardowns.push({ run, abandoned, exitCode, state: "pending" });
     if (this.#teardowns.length === 1)
       this.#listen(() => this.#onSignal());
   }
+  async runAll() {
+    await this.#runTeardowns();
+  }
   #onSignal() {
     if (this.#interrupted) {
       for (const one of this.#teardowns)
-        if (one.running)
+        if (one.state !== "done")
           this.#report(one.abandoned);
       this.#exit(130);
       return;
     }
     this.#interrupted = true;
-    Promise.all(this.#teardowns.map(async (one) => {
-      one.running = true;
-      await one.run().catch(() => {
-        return;
-      });
-      one.running = false;
-    })).finally(() => {
+    this.#runTeardowns().finally(() => {
       if (this.ownsExit)
-        this.#exit(0);
+        this.#exit(Math.max(0, ...this.#teardowns.map((one) => one.exitCode)));
     });
   }
+  async#runTeardowns() {
+    this.#chain = this.#chain.then(async () => {
+      for (const one of this.#teardowns.toReversed()) {
+        if (one.state !== "pending")
+          continue;
+        one.state = "running";
+        await one.run().catch(() => {
+          return;
+        });
+        one.state = "done";
+      }
+    });
+    await this.#chain;
+  }
 }
 
 // pkgs/@akanjs/cli/application/application.script.ts
 class ApplicationScript extends script("application", [ApplicationRunner, LibraryScript]) {
   static dbShutdownTimeoutMs = 20000;
+  static devServerReadyTimeoutMs = DevSupervisor.bootTimeoutMs;
   #interrupt = new InterruptTeardown;
   async confirmDatabaseModeDependencyInstall(databaseMode, installSpecs) {
     return await confirm({
@@ -3205,6 +3344,10 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     await app.scanSync({ write });
     await this.applicationRunner.buildMobile(app, "android", options);
   }
+  async buildDesktop(app, { write = true, ...options } = {}) {
+    await app.scanSync({ write });
+    await this.applicationRunner.buildDesktop(app, options);
+  }
   async startIos(app, { write = true, ...options } = {}) {
     await app.scanSync({ write });
     await this.applicationRunner.startMobile(app, "ios", options);
@@ -3215,7 +3358,43 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   }
   async startDesktop(app, { write = true, ...options } = {}) {
     await app.scanSync({ write });
-    await this.applicationRunner.startDesktop(app, options);
+    if (options.operation === "release")
+      return await this.applicationRunner.startDesktop(app, options);
+    const mobileTarget = await ApplicationRunner.startTarget(app, undefined, options.target);
+    if (!ApplicationRunner.carriesServer(mobileTarget))
+      return await this.applicationRunner.startDesktop(app, options);
+    DesktopServerStage.assertCarriable(await app.getConfig());
+    const upstream = `http://localhost:${await app.getDevPort()}`;
+    try {
+      if (await ApplicationRunner.answers(upstream, app.name, app.workspace.workspaceRoot))
+        app.log(`The desktop app follows the dev server on ${upstream}.`);
+      else
+        await this.#startDevServerFor(app, upstream);
+      await this.applicationRunner.startDesktop(app, { ...options, interrupt: this.#interrupt });
+    } finally {
+      await this.#interrupt.runAll();
+    }
+  }
+  async#startDevServerFor(app, upstream) {
+    app.log(`No dev server answers on ${upstream}; starting \`akan start ${app.name}\` for the desktop app.`);
+    let settle = () => {};
+    const settled = new Promise((resolve) => settle = resolve);
+    const appHost = await this.startOne(app, {
+      write: false,
+      onDevEvent: (event) => {
+        if ("state" in event && (event.state === "ready" || event.state === "failed"))
+          settle(event.state);
+      }
+    });
+    this.#interrupt.add(async () => {
+      await appHost.stop();
+    }, "Abandoning the dev server shutdown; its processes may still be running.", 130);
+    let state;
+    const timedOut = await DevSupervisor.timesOut(settled.then((settledState) => state = settledState), ApplicationScript.devServerReadyTimeoutMs);
+    if (state === "ready")
+      return;
+    await this.#interrupt.runAll();
+    throw new Error(timedOut ? `akan start ${app.name} did not answer within ${ApplicationScript.devServerReadyTimeoutMs / 1000}s; see its log above.` : `akan start ${app.name} gave up restarting its server; see its log above.`);
   }
   async releaseIos(app, {
     write = true,
@@ -3235,6 +3414,27 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     ApplicationScript.#assertReleaseEnv("releaseAndroid", options.env ?? "main", allowLocalRelease);
     await this.applicationRunner.releaseAndroid(app, format, options);
   }
+  async packUpdate(app, platform, {
+    write = true,
+    allowLocalRelease = false,
+    ...options
+  } = {}) {
+    await app.scanSync({ write });
+    ApplicationScript.#assertReleaseEnv("packUpdate", options.env ?? "main", allowLocalRelease);
+    await this.applicationRunner.packUpdate(app, platform, options);
+  }
+  async updateKeygen(app, platform, { target } = {}) {
+    await this.applicationRunner.updateKeygen(app, platform, target);
+  }
+  async publishUpdate(app, platform, {
+    write = true,
+    allowLocalRelease = false,
+    ...options
+  } = {}) {
+    await app.scanSync({ write });
+    ApplicationScript.#assertReleaseEnv("publishUpdate", options.env ?? "main", allowLocalRelease);
+    await this.applicationRunner.publishUpdate(app, platform, options);
+  }
   static #assertReleaseEnv(command, env, allowLocalRelease) {
     if (env === "local" && !allowLocalRelease)
       throw new Error(`${command} --env local is blocked. Pass allowLocalRelease only for explicit local release testing.`);

package/{index-860zjnr1.js → index-nbg9bfnr.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   AppInfo
-} from "./index-0n9q1f23.js";
+} from "./index-r8gp8zk3.js";
 
 // pkgs/@akanjs/devkit/slicePlanner.ts
 class SlicePlanner {

package/{index-5mm3g24t.js → index-qtz88kh0.js}

@@ -2,10 +2,10 @@
 import {
   runner,
   script
-} from "./index-58cyna2s.js";
+} from "./index-b68zfsvz.js";
 import {
   LibExecutor
-} from "./index-0n9q1f23.js";
+} from "./index-r8gp8zk3.js";
 import {
   LibSource,
   formatLibStatuses