@akanjs/cli 3.1.0-rc.0 → 3.1.0-rc.2

package/{index-p9ystjrp.js → index-20cebtth.js}

@@ -38,40 +38,45 @@ import {
 } from "./index-k9rrten6.js";
 import {
   runner,
-  script
-} from "./index-6jjtnhkw.js";
+  script,
+  assertPromptable
+} from "./index-31ce9vhg.js";
 import {
   WorkspaceExecutor,
   AppExecutor,
   LibExecutor,
   PkgExecutor
-} from "./index-55mynnqs.js";
+} from "./index-2etqq75t.js";
 import {
   DesktopServerStage,
-  NativeApp,
   UpdateUploader
-} from "./index-kjvrq3nc.js";
+} from "./index-g0vwzy9m.js";
+import {
+  NativePublicEnv,
+  UpdatePackFolder,
+  NativeApp
+} from "./index-0909wckt.js";
 import {
   LibraryScript
-} from "./index-c1x0be5j.js";
+} from "./index-bea2gwc6.js";
 import {
   stripAnsi
 } from "./index-7md2g9vw.js";
 import {
   SlicePlanner,
   formatSlicePlan
-} from "./index-qt22xstj.js";
+} from "./index-58vvz603.js";
+import {
+  openBrowser
+} from "./index-9dp031by.js";
 import {
   resolveMobileTargets,
   resolveAppId
 } from "./index-q958tqqg.js";
-import {
-  openBrowser
-} from "./index-9dp031by.js";
 
 // pkgs/@akanjs/cli/application/application.script.ts
 import { confirm } from "@inquirer/prompts";
-import { Logger as Logger6 } from "akanjs/common";
+import { Logger as Logger6, toError as toError2 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/application/application.runner.ts
 import { realpathSync } from "fs";
@@ -1888,8 +1893,8 @@ ${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-1yaqsrdq.js")).ApplicationBuildRunner;
+import { Logger as Logger3, toError } from "akanjs/common";
+var loadBuildRunner = async () => (await import("./applicationBuildRunner-by10r9gf.js")).ApplicationBuildRunner;
 var loadPrompts = async () => await import("@inquirer/prompts");
 
 class ApplicationRunner extends runner("application") {
@@ -1914,6 +1919,9 @@ class ApplicationRunner extends runner("application") {
       throw new Error(`No script files found. make a script file in apps/${app.name}/script folder`);
     }
     const scriptFiles = (await app.readdir("script")).filter((file) => file.endsWith(".ts"));
+    assertPromptable("Missing argument 'filename'", {
+      choices: scriptFiles.map((file) => file.replace(".ts", ""))
+    });
     const scriptFile = await (await loadPrompts()).select({
       message: "Select script to run",
       choices: scriptFiles.map((file) => ({ name: file, value: file.replace(".ts", "") }))
@@ -2047,7 +2055,7 @@ try {
     await new (await loadBuildRunner())(app).typecheck(options);
   }
   async typecheckLibrary(lib, options = {}) {
-    const { ProjectTypecheck } = await import("./projectTypecheck-cvtkrzp2.js");
+    const { ProjectTypecheck } = await import("./projectTypecheck-jamtx95x.js");
     const root = lib.workspace.workspaceRoot;
     await new ProjectTypecheck(lib.cwdPath, root, { ...process.env, AKAN_WORKSPACE_ROOT: root }).run([
       "../../server.ts",
@@ -2078,9 +2086,9 @@ try {
     fast = false,
     reporter,
     spinner = false,
-    profile
+    envProfile
   } = {}) {
-    return new (await loadBuildRunner())(app, { fast, reporter, profile }).build({ spinner });
+    return new (await loadBuildRunner())(app, { fast, reporter, profile: envProfile }).build({ spinner });
   }
   async start(app, {
     open = false,
@@ -2189,44 +2197,46 @@ try {
     };
     return canonical(reported) === canonical(own);
   }
-  async releaseIos(app, { target, env = "main", teamId, adHoc = false } = {}) {
+  async releaseIos(app, { target, env = "main", teamId, adHoc = false, publicEnv } = {}) {
     const targets = await resolveMobileTargets(app, target);
-    await this.#buildMobileCsr(app, env);
+    await this.#buildMobileCsr(app, env, undefined, publicEnv ? await NativePublicEnv.load(publicEnv) : null);
     for (const mobileTarget of targets)
       this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).releaseIos({ teamId, adHoc }));
   }
-  async releaseAndroid(app, format, { target, env = "main" } = {}) {
+  async releaseAndroid(app, format, { target, env = "main", publicEnv } = {}) {
     const targets = await resolveMobileTargets(app, target);
     NativeApp.androidSigning();
-    await this.#buildMobileCsr(app, env);
+    await this.#buildMobileCsr(app, env, undefined, publicEnv ? await NativePublicEnv.load(publicEnv) : null);
     for (const mobileTarget of targets)
       this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).releaseAndroid({ formats: [format] }));
   }
-  async packUpdate(app, platform, { target, env = "main", out, against }) {
+  async packUpdate(app, platform, { target, env = "main", out, against, publicEnv }) {
     const targets = await resolveMobileTargets(app, target);
     const [mobileTarget] = targets;
     if (!mobileTarget || targets.length > 1)
       throw new Error("pack-update packs one native target at a time; pass --target <name>.");
-    await this.#buildMobileCsr(app, env);
-    const { pack } = await new NativeApp(app, mobileTarget, env).packUpdate(platform, { out });
+    const nativeApp = new NativeApp(app, mobileTarget, env);
+    await UpdatePackFolder.clear(path5.resolve(out ?? path5.join(nativeApp.updatesDir, platform)));
+    const pinned = publicEnv ? await NativePublicEnv.load(publicEnv) : against ? await NativePublicEnv.recordedIn(against) : null;
+    await this.#buildMobileCsr(app, env, undefined, pinned);
+    const { pack } = await nativeApp.packUpdate(platform, { out });
     app.logger.info(`packed ${mobileTarget.name} ${platform} for channel '${pack.channel}' to ${pack.out}: ${pack.files} files, ${(pack.size / 1024).toFixed(0)} KiB, native API ${pack.nativeApi}`);
     if (against) {
-      const compat = await NativeApp.compareBundles(app.cwdPath, against, path5.join(pack.out, "bundle.json"));
-      pack.compat = { against, ...compat };
-      await Bun.write(path5.join(pack.out, "compat.json"), `${JSON.stringify(pack.compat, null, 2)}
-`);
+      const bundle = path5.join(pack.out, UpdatePackFolder.bundleFile);
+      const compat = await NativeApp.compareBundles(app.cwdPath, against, bundle);
+      const envProblem = await NativePublicEnv.problemAgainst(against, bundle);
+      await UpdatePackFolder.writeCompat(pack, {
+        against,
+        compatible: compat.compatible && !envProblem,
+        problems: [...compat.problems, ...envProblem ? [envProblem] : []]
+      });
     }
-    await NativeApp.writePack(pack);
-    if (!pack.compat)
-      return pack;
-    if (pack.compat.compatible) {
+    await UpdatePackFolder.write(pack);
+    const verdict = UpdatePackFolder.storeBuildVerdict(pack);
+    if (verdict)
+      throw verdict;
+    if (pack.compat)
       app.logger.info(`runs in the store build of ${against}`);
-      return pack;
-    }
-    app.logger.error(`This bundle needs a new store build; the one ${against} came from provides another native API:
-- ${pack.compat.problems.join(`
-- `)}`);
-    process.exitCode = 2;
     return pack;
   }
   async updateKeygen(app, platform, target) {
@@ -2237,16 +2247,27 @@ try {
       if (seen.has(appId))
         continue;
       seen.add(appId);
-      const { publicKey, keyPath, created } = await new NativeApp(app, mobileTarget).updateKeygen(nativePlatform);
+      const { publicKey, keyId, 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(`  native: { updates: { url: "https://\u2026/${app.name}", publicKeys: [${JSON.stringify(publicKey)}] } }`);
+      app.log(`  keyId ${keyId}: what publish-update --revoke and updates.revokedKeys name this key by`);
       const { publicKey: one, publicKeys } = mobileTarget.config.updates ?? {};
       const declared = publicKeys ?? (one ? [one] : null);
       if (declared && !declared.includes(publicKey))
         app.logger.warn(`native.targets.${mobileTarget.name}.updates.publicKeys does not hold this key; releases it signs would not verify.`);
     }
   }
-  async publishUpdate(app, platform, { target, env = "main", channel, upload, arch, sign = false, notarize = false } = {}) {
+  async publishUpdate(app, platform, {
+    target,
+    env = "main",
+    channel,
+    upload,
+    arch,
+    sign = false,
+    notarize = false,
+    revoke,
+    resetSequence
+  } = {}) {
     if (arch && platform !== "desktop")
       throw new Error(`--arch picks a desktop release's CPU; ${platform} publishes its web bundle.`);
     const targets = await resolveMobileTargets(app, target);
@@ -2260,7 +2281,9 @@ try {
       await new NativeApp(app, mobileTarget, env).assertPublishable(nativePlatform, {
         server: ApplicationRunner.carriesServer(mobileTarget, nativePlatform),
         ...channel ? { channel } : {},
-        ...arch ? { arch } : {}
+        ...arch ? { arch } : {},
+        revoke,
+        resetSequence
       });
     const carried = await this.#stageMobile(app, nativePlatform, targets, env, arch);
     for (const mobileTarget of targets) {
@@ -2270,15 +2293,17 @@ try {
         ...arch ? { arch } : {},
         sign,
         notarize,
+        revoke,
+        resetSequence,
         ...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`);
       if (!uploader) {
-        app.log(`Upload ${nativeApp.updatesDir} to ${mobileTarget.config.updates?.url}, the manifests last.`);
+        app.log(`Upload ${nativeApp.updatesDir} to ${mobileTarget.config.updates?.url}, the manifests last, without pack-update's records (pack.json, compat.json, manifest.template.json, bundle.json); --upload s3://\u2026 sends just this release.`);
         continue;
       }
-      const { uploaded, skipped } = await uploader.upload(nativeApp.updatesDir);
+      const { uploaded, skipped } = await uploader.upload(nativeApp.updatesDir, published);
       app.log(`Uploaded ${uploaded} file(s) to ${upload}, the manifests last; ${skipped} the bucket already held. Installed apps read ${mobileTarget.config.updates?.url}.`);
     }
   }
@@ -2300,13 +2325,14 @@ try {
       if (typeof server !== "object")
         return { omit: [], modules: [] };
       const { omit = [], modules = [], profile, env, restart, watchdog } = server;
+      const { intervalMs, failures } = typeof watchdog === "object" ? watchdog : {};
       return {
         omit,
         modules,
         ...profile ? { profile } : {},
         ...env ? { env } : {},
         ...restart !== undefined ? { restart } : {},
-        ...typeof watchdog === "object" ? { watchdog } : {}
+        ...intervalMs && failures ? { watchdog: { intervalMs, failures } } : {}
       };
     });
     const [first = { omit: [], modules: [] }, ...rest] = servers;
@@ -2318,7 +2344,7 @@ try {
     agree("omit different packages", ({ omit }) => omit.join(", "));
     agree("name different env profiles", ({ profile }) => profile ?? "");
     agree("mount different modules", ({ modules }) => modules.join(", "));
-    agree("set a different env", ({ env }) => env ? JSON.stringify(env) : "");
+    agree("set a different env", ({ env }) => env ? JSON.stringify(env, Object.keys(env).sort()) : "");
     agree("restart differently", ({ restart }) => String(restart ?? ""));
     agree("watch it differently", ({ watchdog }) => watchdog ? JSON.stringify(watchdog) : "");
     return first;
@@ -2331,7 +2357,11 @@ try {
     const { modules, env: serverEnv, restart, watchdog } = server;
     return await stage?.prepare(env, { modules, env: serverEnv, restart, watchdog });
   }
-  async#buildMobileCsr(app, env, profile) {
+  async#buildMobileCsr(app, env, envProfile, publicEnv = null) {
+    if (publicEnv?.AKAN_PUBLIC_ENV !== undefined && publicEnv.AKAN_PUBLIC_ENV !== env)
+      throw new Error(`--env ${env} differs from the public env's AKAN_PUBLIC_ENV ${publicEnv.AKAN_PUBLIC_ENV}.`);
+    if (publicEnv)
+      NativePublicEnv.pin(publicEnv);
     const prevEnv = {
       AKAN_PUBLIC_ENV: process.env.AKAN_PUBLIC_ENV,
       AKAN_PUBLIC_OPERATION_MODE: process.env.AKAN_PUBLIC_OPERATION_MODE,
@@ -2343,7 +2373,7 @@ try {
       APP_OPERATION_MODE: "release"
     });
     try {
-      await new (await loadBuildRunner())(app, { environment: env, profile }).build({ spinner: true });
+      await new (await loadBuildRunner())(app, { environment: env, profile: envProfile }).build({ spinner: true });
     } finally {
       for (const [key, value] of Object.entries(prevEnv)) {
         if (value === undefined)
@@ -2352,6 +2382,11 @@ try {
           process.env[key] = value;
       }
     }
+    if (!publicEnv)
+      return;
+    const differs = NativePublicEnv.diff(publicEnv, await NativePublicEnv.built(app) ?? {});
+    if (differs.length)
+      throw new Error(`The web build inlined other values than --public-env gave for ${differs.join(", ")}.`);
   }
   async#runMobileTargets(targets, task) {
     const results = [];
@@ -2367,7 +2402,7 @@ try {
     if (failures.length === 0)
       return;
     for (const failure of failures) {
-      const message = failure.error instanceof Error ? failure.error.message : String(failure.error);
+      const message = toError(failure.error).message;
       Logger3.rawLog(`Native target ${failure.target} failed: ${message}`, undefined, "error");
     }
     throw new Error(`${failures.length}/${results.length} native targets failed`);
@@ -3240,6 +3275,9 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   static devServerReadyTimeoutMs = DevSupervisor.bootTimeoutMs;
   #interrupt = new InterruptTeardown;
   async confirmDatabaseModeDependencyInstall(databaseMode, installSpecs) {
+    assertPromptable(`Database mode '${databaseMode}' requires missing dependencies: ${installSpecs.join(", ")}`, {
+      remedy: `install them first with \`bun add ${installSpecs.join(" ")}\``
+    });
     return await confirm({
       message: `Database mode '${databaseMode}' requires missing dependencies: ${installSpecs.join(", ")}. Install them now?`,
       default: true
@@ -3312,7 +3350,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     if (!quiet)
       Logger6.rawLog(`Creating an optimized production build for ${app.name}...`);
     try {
-      const result = await this.applicationRunner.build(app, { fast, spinner: !quiet, profile });
+      const result = await this.applicationRunner.build(app, { fast, spinner: !quiet, envProfile: profile });
       Logger6.rawLog(`${app.name} built in dist/apps/${app.name}`);
       if (!quiet)
         ApplicationBuildReporter.printSummary(result);
@@ -3325,10 +3363,12 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   async typecheck(exec, { write = true, clean = false, incremental = true, tests = false } = {}) {
     if (!(exec instanceof AppExecutor) && !(exec instanceof LibExecutor))
       throw new Error(`akan typecheck takes an app or a library; ${exec.name} is a package, checked by its own tsconfig.`);
-    if (exec instanceof LibExecutor)
+    if (exec instanceof AppExecutor)
+      await exec.scanSync({ write });
+    else if (write)
       await this.libraryScript.syncLibrary(exec);
     else
-      await exec.scanSync({ write });
+      await exec.scan({ write: false });
     const spinner = exec.spinning(`Typechecking ${exec.name}${tests ? " with its tests" : ""}...`);
     try {
       if (exec instanceof LibExecutor)
@@ -3593,13 +3633,13 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       await Promise.all(shares.map(async (share) => await share.close()));
     }, "Abandoning the tunnel release; the shares expire on their own.");
     await Promise.all(apps.map(async (app) => {
-      const { TunnelShare } = await import("./TunnelShare-21mm6dr5.js");
+      const { TunnelShare } = await import("./TunnelShare-f1egrktx.js");
       const share = await TunnelShare.open(app, { workspace: app.workspace });
       shares.push(share);
       urls.set(app.name, share.url);
       Logger6.rawLog(`${app.name} is shared at ${share.url}`);
     })).catch((error) => {
-      Logger6.rawLog(`Could not open the tunnel: ${error instanceof Error ? error.message : String(error)}`, undefined, "error");
+      Logger6.rawLog(`Could not open the tunnel: ${toError2(error).message}`, undefined, "error");
     });
     return urls;
   }