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

package/index-vk0pa0mn.js

@@ -0,0 +1,240 @@
+// @bun
+import {
+  DesktopBin,
+  UpdatePackFolder
+} from "./index-g1mbppa9.js";
+// 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/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/updateUploader.ts
+import { readdir as readdir2 } from "fs/promises";
+import path2 from "path";
+import { isRecord, trimTrailingSlashes } 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: trimTrailingSlashes(match[2] ?? "") };
+  }
+  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 };