@akanjs/cli 3.1.0-rc.1 → 3.1.0-rc.3

package/{index-rc5rwyps.js → index-jj7yapwq.js}

@@ -1,26 +1,29 @@
 // @bun
 import {
   GlobalConfig,
-  CloudApi
-} from "./index-pgj2rt78.js";
-import {
-  script
-} from "./index-6jjtnhkw.js";
+  CloudApi,
+  CloudUpdates,
+  PipelineSecrets
+} from "./index-wjqbc7sf.js";
 import {
   PkgExecutor
-} from "./index-55mynnqs.js";
+} from "./index-bv210r6t.js";
 import {
-  NativeApp
-} from "./index-1w2qaee2.js";
+  NativePublicEnv,
+  UpdatePackFolder
+} from "./index-qf8g88j9.js";
+import {
+  script
+} from "./index-3x7yeecy.js";
 import {
   ApplicationScript
-} from "./index-jx4bzvwg.js";
+} from "./index-1a7nhq56.js";
 import {
   PackageScript
-} from "./index-gnyf1fqy.js";
+} from "./index-qvghfv6v.js";
 import {
   CloudRunner
-} from "./index-8ggztp8k.js";
+} from "./index-wanhh011.js";
 
 // pkgs/@akanjs/cli/cloud/cloud.script.ts
 import { Logger } from "akanjs/common";
@@ -31,12 +34,14 @@ class CloudScript2 extends script("cloud", [CloudRunner, ApplicationScript, Pack
   async logout(workspace, host) {
     await this.cloudRunner.logout(await GlobalConfig.hostFor(workspace, host));
   }
+  async#cloudApi(workspace, given) {
+    const host = await GlobalConfig.hostFor(workspace, given);
+    await this.login(workspace, host);
+    return await CloudApi.fromHost(workspace, host);
+  }
   async downloadEnv(workspace, workspaceId = workspace.getWorkspaceId({ allowEmpty: true }), { host: given } = {}) {
     if (workspaceId) {
-      const host = await GlobalConfig.hostFor(workspace, given);
-      await this.login(workspace, host);
-      const cloudApi = await CloudApi.fromHost(workspace, host);
-      await this.cloudRunner.downloadEnv(cloudApi, workspace, workspaceId);
+      await this.cloudRunner.downloadEnv(await this.#cloudApi(workspace, given), workspace, workspaceId);
       return;
     }
     await this.cloudRunner.downloadEnvByScp(workspace);
@@ -51,10 +56,7 @@ class CloudScript2 extends script("cloud", [CloudRunner, ApplicationScript, Pack
       throw new Error("A scoped env upload needs a cloud workspace id \u2014 the scp target is workspace-wide.");
     const { files, path } = await this.cloudRunner.gatherEnvFiles(workspace, { scope, archivePath });
     if (workspaceId) {
-      const host = await GlobalConfig.hostFor(workspace, given);
-      await this.login(workspace, host);
-      const cloudApi = await CloudApi.fromHost(workspace, host);
-      await this.cloudRunner.uploadEnv(cloudApi, workspaceId, path);
+      await this.cloudRunner.uploadEnv(await this.#cloudApi(workspace, given), workspaceId, path);
       return { workspaceId, files };
     }
     await this.cloudRunner.uploadEnvByScp(workspace, path);
@@ -67,19 +69,16 @@ class CloudScript2 extends script("cloud", [CloudRunner, ApplicationScript, Pack
     subspace,
     host: given
   }) {
-    const devProjectId = await this.cloudRunner.secretProject(workspace, subspace);
+    PipelineSecrets.assertName(name);
+    PipelineSecrets.assertBranch(branch);
+    const devProjectId = await this.cloudRunner.projectOf(workspace, subspace);
     const value = await this.cloudRunner.readSecretValue(name, file);
-    const host = await GlobalConfig.hostFor(workspace, given);
-    await this.login(workspace, host);
-    const cloudApi = await CloudApi.fromHost(workspace, host);
-    await this.cloudRunner.uploadSecret(cloudApi, devProjectId, { name, branch, value });
+    await this.cloudRunner.uploadSecret(await this.#cloudApi(workspace, given), devProjectId, { name, branch, value });
   }
   async listSecrets(workspace, { branch, subspace, host: given }) {
-    const devProjectId = await this.cloudRunner.secretProject(workspace, subspace);
-    const host = await GlobalConfig.hostFor(workspace, given);
-    await this.login(workspace, host);
-    const cloudApi = await CloudApi.fromHost(workspace, host);
-    await this.cloudRunner.listSecrets(cloudApi, devProjectId, branch);
+    PipelineSecrets.assertBranch(branch);
+    const devProjectId = await this.cloudRunner.projectOf(workspace, subspace);
+    await this.cloudRunner.listSecrets(await this.#cloudApi(workspace, given), devProjectId, branch);
   }
   async removeSecret(workspace, {
     name,
@@ -87,11 +86,10 @@ class CloudScript2 extends script("cloud", [CloudRunner, ApplicationScript, Pack
     subspace,
     host: given
   }) {
-    const devProjectId = await this.cloudRunner.secretProject(workspace, subspace);
-    const host = await GlobalConfig.hostFor(workspace, given);
-    await this.login(workspace, host);
-    const cloudApi = await CloudApi.fromHost(workspace, host);
-    await this.cloudRunner.removeSecret(cloudApi, devProjectId, { name, branch });
+    PipelineSecrets.assertName(name);
+    PipelineSecrets.assertBranch(branch);
+    const devProjectId = await this.cloudRunner.projectOf(workspace, subspace);
+    await this.cloudRunner.removeSecret(await this.#cloudApi(workspace, given), devProjectId, { name, branch });
   }
   async pushUpdate(workspace, app, {
     platform,
@@ -103,31 +101,42 @@ class CloudScript2 extends script("cloud", [CloudRunner, ApplicationScript, Pack
     host: given,
     write,
     allowLocalRelease,
-    pack: packDir
+    pack: packDir,
+    publicEnv
   }) {
-    const devProjectId = await this.cloudRunner.secretProject(workspace, subspace);
-    const pack = packDir ? await NativeApp.readPack(packDir) : await this.applicationScript.packUpdate(app, platform, {
-      target,
-      env,
-      write,
-      allowLocalRelease
-    });
-    if (pack.app !== app.name || pack.platform !== platform || target && pack.target !== target)
-      throw new Error(`The pack in ${pack.out} is ${pack.app} ${pack.target} ${pack.platform}, not ${app.name} ${target ?? pack.target} ${platform}.`);
-    if (pack.compat && !pack.compat.compatible) {
-      Logger.error(`The pack in ${pack.out} needs a new store build; it differs from the one ${pack.compat.against} came from:
-- ${pack.compat.problems.join(`
-- `)}`);
-      process.exitCode = 2;
-      return null;
-    }
-    const host = await GlobalConfig.hostFor(workspace, given);
-    await this.login(workspace, host);
-    return await this.cloudRunner.pushUpdate(await CloudApi.fromHost(workspace, host), devProjectId, pack, {
+    if (packDir && publicEnv)
+      throw new Error("--public-env picks what a pack is built with, and --pack uploads one already built: give one.");
+    const devProjectId = await this.cloudRunner.projectOf(workspace, subspace, app.name);
+    const pack = await this.#packToPush(app, { platform, target, env, write, allowLocalRelease, packDir, publicEnv });
+    const verdict = UpdatePackFolder.storeBuildVerdict(pack);
+    if (verdict)
+      throw verdict;
+    return await this.cloudRunner.pushUpdate(await this.#cloudApi(workspace, given), devProjectId, pack, {
       channel,
       notes
     });
   }
+  async#packToPush(app, {
+    platform,
+    target,
+    env,
+    write,
+    allowLocalRelease,
+    packDir,
+    publicEnv
+  }) {
+    if (packDir)
+      return await this.cloudRunner.readPack(app, packDir, { platform, target, env, allowLocalRelease });
+    if (!platform)
+      throw new Error("push-update needs --platform ios or android to pack, or --pack <dir> to upload what `akan pack-update` wrote.");
+    return await this.applicationScript.packUpdate(app, platform, {
+      target: target ?? undefined,
+      env: env ?? "main",
+      write,
+      allowLocalRelease,
+      publicEnv: publicEnv ?? undefined
+    });
+  }
   async registerBinary(workspace, app, {
     platform,
     distribution,
@@ -136,18 +145,20 @@ class CloudScript2 extends script("cloud", [CloudRunner, ApplicationScript, Pack
     subspace,
     host: given,
     write,
-    allowLocalRelease
+    allowLocalRelease,
+    publicEnv
   }) {
-    const devProjectId = await this.cloudRunner.secretProject(workspace, subspace);
+    const devProjectId = await this.cloudRunner.projectOf(workspace, subspace, app.name);
+    const storeBundle = await CloudUpdates.storeBundlePath(app, target, platform);
+    const recorded = !publicEnv && await NativePublicEnv.recordedIn(storeBundle);
     const pack = await this.applicationScript.packUpdate(app, platform, {
       target,
       env,
       write,
-      allowLocalRelease
+      allowLocalRelease,
+      publicEnv: publicEnv ?? (recorded ? storeBundle : undefined)
     });
-    const host = await GlobalConfig.hostFor(workspace, given);
-    await this.login(workspace, host);
-    return await this.cloudRunner.registerBinary(await CloudApi.fromHost(workspace, host), devProjectId, app, pack, {
+    return await this.cloudRunner.registerBinary(await this.#cloudApi(workspace, given), devProjectId, app, pack, {
       distribution,
       env
     });

package/index-kmamh5bv.js

@@ -0,0 +1,241 @@
+// @bun
+import {
+  DesktopBin,
+  UpdatePackFolder
+} from "./index-qf8g88j9.js";
+
+// pkgs/@akanjs/devkit/mobile/placeholderAppId.ts
+var PLACEHOLDER_APP_IDS = [
+  "com.myapp.app",
+  "com.myorg.myapp",
+  "com.example.app",
+  "com.example.myapp"
+];
+var placeholderAppIdSegment = /^(example|examples|myorg|myapp|mycompany|myorganization|changeme|todo|sample|test)$/;
+var isPlaceholderAppId = (appId) => {
+  const normalized = appId?.trim().toLowerCase() ?? "";
+  if (!normalized)
+    return true;
+  if (PLACEHOLDER_APP_IDS.includes(normalized))
+    return true;
+  return normalized.split(".").some((segment) => placeholderAppIdSegment.test(segment));
+};
+// pkgs/@akanjs/devkit/mobile/desktopServerStage.ts
+import { cp, mkdir, readdir, rm, writeFile } from "fs/promises";
+import path from "path";
+import { toError } from "akanjs/common";
+class DesktopServerStage {
+  app;
+  static uncarried = new Set([
+    "Dockerfile",
+    "package.json",
+    "rscWorker.js",
+    "console.js",
+    "console-runtime.js",
+    "csr",
+    "public",
+    ".akan"
+  ]);
+  static rscRenderer = "react-server-dom-webpack";
+  dir;
+  constructor(app) {
+    this.app = app;
+    this.dir = path.join(app.cwdPath, ".akan", "desktop", "server");
+  }
+  static assertCarriable(config) {
+    if (!config.database.modes.includes("single"))
+      throw new Error(`desktop.server in native puts the server in the app, where only database mode single runs (no Redis or Postgres); apps/${config.app.name}/akan.config.ts declares ${config.database.modes.join(", ")}.`);
+  }
+  static env(config, environment, { modules = [], env = {} } = {}) {
+    const { PORT: _port, AKAN_LOG_TO_FILE: _fileLog, ...image } = config.getProductionEnv(environment);
+    return {
+      ...image,
+      ...env,
+      AKAN_PUBLIC_OPERATION_MODE: "edge",
+      AKAN_DATABASE_MODE: "single",
+      AKAN_DATABASE_MODES: "single",
+      AKAN_SSR: "false",
+      AKAN_CSR: "false",
+      AKAN_MCP: "false",
+      AKAN_SHUTDOWN_TIMEOUT_MS: "1000",
+      ...modules.length ? { AKAN_MODULES: modules.join(",") } : {}
+    };
+  }
+  static imageStepsNotice(config, carried) {
+    const steps = typeof config.docker === "string" ? null : config.docker.preRuns.length + config.docker.postRuns.length;
+    if (steps === 0)
+      return null;
+    const image = steps === null ? `apps/${config.app.name}/akan.config.ts writes its own Dockerfile` : `The image runs ${steps} docker step${steps === 1 ? "" : "s"} from the app and its libs`;
+    return carried.length ? {
+      level: "info",
+      message: `${image}; the desktop app's server runs none of them and carries only bin: ${carried.join(", ")}.`
+    } : {
+      level: "warn",
+      message: `${image}, and a desktop app's server runs none of them: declare in bin the executables its code spawns, or those calls fail on the user's computer.`
+    };
+  }
+  static packageJson(config, built, omit = []) {
+    const otherDrivers = new Set(config.database.modes.filter((mode) => mode !== "single").flatMap((mode) => config.getDatabaseModeRuntimePackages(mode)));
+    const dependencies = Object.entries(built.dependencies ?? {}).filter(([name]) => !omit.includes(name) && (config.externalLibs.includes(name) || name !== DesktopServerStage.rscRenderer && !otherDrivers.has(name)));
+    return { ...built, dependencies: Object.fromEntries(dependencies) };
+  }
+  static async dependentsOf(nodeModules, name) {
+    const dependents = new Set;
+    for await (const manifest of new Bun.Glob("**/package.json").scan({ cwd: nodeModules, onlyFiles: true })) {
+      const json = await Bun.file(path.join(nodeModules, manifest)).json().catch(() => null);
+      if (!json?.name || json.name === name)
+        continue;
+      const declared = { ...json.dependencies, ...json.optionalDependencies, ...json.peerDependencies };
+      if (name in declared)
+        dependents.add(json.name);
+    }
+    return [...dependents].sort();
+  }
+  static installArgs(arch) {
+    return ["install", "--production", "--prefer-offline", ...arch && arch !== process.arch ? [`--cpu=${arch}`] : []];
+  }
+  async install(arch, omit = []) {
+    const config = await this.app.getConfig();
+    DesktopServerStage.assertCarriable(config);
+    await rm(this.dir, { recursive: true, force: true });
+    await mkdir(this.dir, { recursive: true });
+    const built = config.getProductionPackageJson();
+    for (const name of omit.filter((name) => !(name in (built.dependencies ?? {}))))
+      this.app.logger.warn(`desktop.server.omit names ${name}, which the server does not depend on directly.`);
+    await writeFile(path.join(this.dir, "package.json"), JSON.stringify(DesktopServerStage.packageJson(config, built, omit), null, 2));
+    try {
+      await this.app.spawn(process.execPath, DesktopServerStage.installArgs(arch), { cwd: this.dir });
+    } catch (error) {
+      throw new Error(`The desktop app's server could not install its packages in ${this.dir}: it needs the npm registry, or a Bun cache that already holds every one of them.
+${toError(error).message}`, { cause: error });
+    }
+    await rm(path.join(this.dir, "node_modules", ".bin"), { recursive: true, force: true });
+    await this.#assertOmitted(omit);
+  }
+  async#assertOmitted(omit) {
+    const nodeModules = path.join(this.dir, "node_modules");
+    const kept = [];
+    for (const name of omit) {
+      if (!await Bun.file(path.join(nodeModules, name, "package.json")).exists())
+        continue;
+      const dependents = await DesktopServerStage.dependentsOf(nodeModules, name);
+      kept.push(`${name} (needed by ${dependents.join(", ") || "a package that names it"})`);
+    }
+    if (kept.length)
+      throw new Error(`desktop.server.omit leaves out packages another dependency still installs: ${kept.join("; ")}. Omit those too, or keep the package.`);
+  }
+  async prepare(environment, run = {}) {
+    const config = await this.app.getConfig();
+    const dist = this.app.dist.cwdPath;
+    await mkdir(this.dir, { recursive: true });
+    for (const name of await readdir(dist))
+      if (!DesktopServerStage.uncarried.has(name))
+        await cp(path.join(dist, name), path.join(this.dir, name), { recursive: true });
+    const scanInfo = this.app.getScanInfo({ allowEmpty: true }) ?? await this.app.scan({ write: false });
+    const carried = [...DesktopBin.select(config, scanInfo.getLibs()).keys()];
+    const notice = DesktopServerStage.imageStepsNotice(config, carried);
+    if (notice)
+      this.app.logger[notice.level](notice.message);
+    return {
+      dir: this.dir,
+      entry: "main.js",
+      env: DesktopServerStage.env(config, environment, run),
+      ...run.restart !== undefined ? { restart: run.restart } : {},
+      ...run.watchdog ? { watchdog: run.watchdog } : {}
+    };
+  }
+}
+// pkgs/@akanjs/devkit/mobile/updateUploader.ts
+import { readdir as readdir2 } from "fs/promises";
+import path2 from "path";
+import { isRecord } from "akanjs/common";
+class UpdateUploader {
+  bucket;
+  prefix;
+  static #manifest = /\.json(?:\.sig)?$/;
+  static parseTarget(target) {
+    const match = /^s3:\/\/([^/]+)\/?(.*)$/.exec(target.trim());
+    if (!match?.[1])
+      throw new Error(`--upload takes s3://<bucket>/<prefix>, not ${JSON.stringify(target)}.`);
+    return { bucket: match[1], prefix: (match[2] ?? "").replace(/\/+$/, "") };
+  }
+  static order(files) {
+    const manifests = files.filter((file) => UpdateUploader.#manifest.test(file));
+    return {
+      releases: files.filter((file) => !UpdateUploader.#manifest.test(file)).sort((a, b) => a.localeCompare(b)),
+      manifests: manifests.sort((a, b) => Number(a.endsWith(".json")) - Number(b.endsWith(".json")) || a.localeCompare(b))
+    };
+  }
+  static async releaseFiles(updatesDir, { dir, channel, bundle }) {
+    const keyOf = (file) => UpdateUploader.#keyOf(updatesDir, dir, file);
+    const desktop = await UpdateUploader.#read(path2.join(dir, `${channel}.json`));
+    if (desktop?.bundle === bundle) {
+      const archive = desktop.archive?.url;
+      const patches = UpdateUploader.#field(desktop.patches, "url");
+      return [archive, ...patches, `${channel}.json.sig`, `${channel}.json`].map(keyOf);
+    }
+    const names = await readdir2(path2.join(dir, channel)).catch(() => []);
+    for (const name of names.filter((name) => name.endsWith(".json"))) {
+      const envelope = await UpdateUploader.#read(path2.join(dir, channel, name));
+      const manifest = typeof envelope?.manifest === "string" ? UpdateUploader.#parse(Buffer.from(envelope.manifest, "base64").toString("utf8")) : null;
+      if (manifest?.bundle !== bundle)
+        continue;
+      const hashes = [...new Set(UpdateUploader.#field(manifest.files, "sha256"))];
+      if (!hashes.every((hash) => typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash)))
+        throw new Error(`${path2.join(dir, channel, name)} lists a file whose sha256 is not 64 hex digits; nothing was uploaded.`);
+      return [...hashes.map((hash) => `${UpdatePackFolder.filesDir}/${hash}`), `${channel}/${name}`].map(keyOf);
+    }
+    throw new Error(`${dir} holds no ${channel} manifest of release ${bundle}; nothing was uploaded.`);
+  }
+  static #keyOf(updatesDir, dir, file) {
+    const resolved = typeof file === "string" ? path2.resolve(dir, file) : "";
+    const key = path2.relative(updatesDir, resolved);
+    if (!resolved.startsWith(`${path2.resolve(dir)}${path2.sep}`) || key.startsWith("..") || path2.isAbsolute(key))
+      throw new Error(`The release in ${dir} names ${typeof file === "string" ? JSON.stringify(file) : "a file with no path"}, which is not inside that folder; nothing was uploaded.`);
+    return key.split(path2.sep).join("/");
+  }
+  static #field(list, key) {
+    return Array.isArray(list) ? list.map((item) => isRecord(item) ? item[key] : undefined) : [];
+  }
+  static async#read(file) {
+    const text = await Bun.file(file).text().catch(() => "");
+    return UpdateUploader.#parse(text);
+  }
+  static #parse(text) {
+    try {
+      const value = JSON.parse(text);
+      return isRecord(value) ? value : null;
+    } catch {
+      return null;
+    }
+  }
+  constructor(bucket, prefix) {
+    this.bucket = bucket;
+    this.prefix = prefix;
+  }
+  static forTarget(target) {
+    const { bucket, prefix } = UpdateUploader.parseTarget(target);
+    return new UpdateUploader(new Bun.S3Client({ bucket }), prefix);
+  }
+  async upload(updatesDir, release) {
+    const { releases, manifests } = UpdateUploader.order(await UpdateUploader.releaseFiles(updatesDir, release));
+    const keyOf = (file) => this.prefix ? `${this.prefix}/${file}` : file;
+    let uploaded = 0;
+    let skipped = 0;
+    for (const file of releases) {
+      if (await this.bucket.exists(keyOf(file))) {
+        skipped++;
+        continue;
+      }
+      await this.bucket.write(keyOf(file), Bun.file(path2.join(updatesDir, file)));
+      uploaded++;
+    }
+    for (const file of manifests) {
+      const type = file.endsWith(".json") ? "application/json" : "text/plain";
+      await this.bucket.write(keyOf(file), Bun.file(path2.join(updatesDir, file)), { type });
+      uploaded++;
+    }
+    return { uploaded, skipped };
+  }
+}
+export { DesktopServerStage, isPlaceholderAppId, UpdateUploader };

package/{index-fm46xrf1.js → index-q5abh0jq.js}

@@ -5,13 +5,13 @@ import {
   writeGeneratedSyncState,
   createRepairReport,
   renderRepairReport
-} from "./index-05g3jayg.js";
+} from "./index-wdze51wz.js";
 import {
   AkanContextAnalyzer
-} from "./index-2mx692qq.js";
+} from "./index-vhfjzda3.js";
 import {
   runner
-} from "./index-6jjtnhkw.js";
+} from "./index-3x7yeecy.js";
 
 // pkgs/@akanjs/cli/repair/repair.runner.ts
 var spawnShell = async (workspace, command) => await workspace.spawn("bash", ["-lc", command.startsWith("akan ") ? `bun run ${command}` : command], {