@akanjs/cli 3.0.2 → 3.1.0-rc.0

package/{index-jk9xnck6.js → index-kjvrq3nc.js}

@@ -1,86 +1,17 @@
 // @bun
 import {
   binPlatforms,
+  ServerEnvProfile,
   Executor
-} from "./index-50wb2a26.js";
-
-// pkgs/@akanjs/devkit/mobile/mobileTarget.ts
-var trimSlashes = (value) => value.replace(/^\/+|\/+$/g, "");
-var getMobileTargets = async (app) => {
-  const config = await app.getConfig();
-  return Object.entries(config.native.targets).map(([name, target]) => ({ name, config: target }));
-};
-var isTemplateOnly = ({ basePaths, native }) => basePaths.size > 0 && Object.values(native.targets).every((target) => !target.basePath);
-var getMobileTargetChoices = async (app) => {
-  const config = await app.getConfig();
-  const targetNames = Object.keys(config.native.targets);
-  if (targetNames.length > 0 && !isTemplateOnly(config))
-    return targetNames;
-  return [...config.basePaths];
-};
-var resolveMobileTargetByBasePath = (targets, basePath) => {
-  const normalizedBasePath = trimSlashes(basePath);
-  const byBasePath = targets.find(({ config }) => config.basePath !== undefined && trimSlashes(config.basePath) === normalizedBasePath);
-  if (byBasePath)
-    return byBasePath;
-  const [template] = targets;
-  if (!template)
-    return;
-  return {
-    name: normalizedBasePath,
-    config: { ...template.config, name: normalizedBasePath, basePath: normalizedBasePath }
-  };
-};
-var resolveMobileTargets = async (app, selection) => {
-  const config = await app.getConfig();
-  const targets = await getMobileTargets(app);
-  if (targets.length === 0)
-    throw new Error(`No native targets configured for ${app.name}`);
-  if (!selection && targets.length === 1 && !isTemplateOnly(config))
-    return targets;
-  if (!selection) {
-    const choices = await getMobileTargetChoices(app);
-    if (choices.length === 1)
-      return resolveMobileTargets(app, choices[0]);
-    throw new Error(`Multiple native targets found for ${app.name}. Pass --target <${choices.join("|")}|all>.`);
-  }
-  if (selection === "all") {
-    if (Object.keys(config.native.targets).length > 1)
-      return targets;
-    const basePaths = [...config.basePaths];
-    if (basePaths.length > 1 || isTemplateOnly(config)) {
-      return basePaths.flatMap((basePath) => {
-        const resolved = resolveMobileTargetByBasePath(targets, basePath);
-        return resolved ? [resolved] : [];
-      });
-    }
-    return targets;
-  }
-  const target = targets.find((candidate) => candidate.name === selection);
-  if (target)
-    return [target];
-  const basePathTarget = resolveMobileTargetByBasePath(targets, selection);
-  if (basePathTarget && config.basePaths.has(trimSlashes(selection)))
-    return [basePathTarget];
-  const choices = await getMobileTargetChoices(app);
-  throw new Error(`Native target '${selection}' was not found. Available: ${choices.join(", ")}`);
-};
-var resolveAppId = (appId, platform) => {
-  if (typeof appId === "string")
-    return appId;
-  const id = appId[platform] ?? appId.default;
-  if (!id)
-    throw new Error(`native.appId names no id for ${platform}; give it ${platform} or default.`);
-  return id;
-};
-var appIdsOf = (appId) => typeof appId === "string" ? [appId] : Object.values(appId).filter((id) => !!id);
-var targetHtmlFilename = (target) => {
-  const basePath = trimSlashes(target.basePath ?? "");
-  return basePath ? `${basePath}.html` : "index.html";
-};
+} from "./index-55mynnqs.js";
+import {
+  resolveAppId,
+  targetHtmlFilename
+} from "./index-q958tqqg.js";
 
 // pkgs/@akanjs/devkit/mobile/nativeApp.ts
-import path6 from "path";
+import { rm as rm3 } from "fs/promises";
+import path7 from "path";
 
 // pkgs/@akanjs/devkit/mobile/desktopBin.ts
 import { chmod, mkdir, rename, rm, writeFile } from "fs/promises";
@@ -417,11 +348,19 @@ class NativeConfig {
     const desktop = NativeConfig.#compact({
       recovery: target.desktop?.recovery,
       screenCapture: target.desktop?.screenCapture,
+      webview2: target.desktop?.webview2,
+      publisher: target.desktop?.publisher,
       window: NativeConfig.#compact({ ...target.desktop?.window }),
       server: desktopServer,
       bin: desktopBin,
       dmg: NativeConfig.#dmg(target.desktop?.dmg, abs)
     });
+    const background = target.backgroundColor;
+    const shell = NativeConfig.#compact({
+      backgroundColor: typeof background === "string" ? background : background?.light,
+      backgroundColorDark: typeof background === "string" ? undefined : background?.dark,
+      devtools: target.devtools ? true : undefined
+    });
     const config = {
       app: {
         id: resolveAppId(target.appId, platform),
@@ -457,7 +396,8 @@ class NativeConfig {
       keyboard: { resize: "none" },
       ...desktop ? { desktop } : {},
       ...target.icon ? { icon: NativeConfig.#icon(target.icon, abs) } : {},
-      ...target.splash ? { splash: NativeConfig.#splash(target.splash, abs) } : {}
+      ...target.splash ? { splash: NativeConfig.#splash(target.splash, abs) } : {},
+      ...shell ? { shell } : {}
     };
     return { config, warnings };
   }
@@ -480,8 +420,9 @@ class NativeConfig {
     };
   }
   static #updates(target, env) {
-    const { url, publicKey, channel = env, ...rest } = target.updates ?? {};
-    return url && publicKey ? { ...rest, url, publicKey, ...channel ? { channel } : {} } : undefined;
+    const { url, publicKey, publicKeys, channel = env, ...rest } = target.updates ?? {};
+    const keys = publicKeys ? { publicKeys: [...publicKeys] } : publicKey ? { publicKey } : null;
+    return url && keys ? { ...rest, url, ...keys, ...channel ? { channel } : {} } : undefined;
   }
   static fileNameOf(name) {
     return name.replace(/[^A-Za-z0-9._-]/g, "-").replace(/^[-.]+|[-.]+$/g, "") || "app";
@@ -614,6 +555,71 @@ ${script}${html.slice(at)}`;
   }
 }
 
+// pkgs/@akanjs/devkit/mobile/serverBundleSecrets.ts
+import { readdir as readdir2, readFile, stat as stat2 } from "fs/promises";
+import path6 from "path";
+class ServerBundleSecrets {
+  workspaceRoot;
+  appDir;
+  static #largestFile = 64 * 1024 * 1024;
+  constructor(workspaceRoot, appDir) {
+    this.workspaceRoot = workspaceRoot;
+    this.appDir = appDir;
+  }
+  async envFiles() {
+    const libsDir = path6.join(this.workspaceRoot, "libs");
+    const libs = await readdir2(libsDir).catch(() => []);
+    const dirs = [path6.join(this.appDir, "env"), ...libs.map((lib) => path6.join(libsDir, lib, "env"))];
+    const files = await Promise.all(dirs.map(async (dir) => (await readdir2(dir).catch(() => [])).filter((name) => /^env\.server\.[A-Za-z0-9.-]+\.ts$/.test(name) && !/\.(type|example)\.ts$/.test(name)).map((name) => path6.join(dir, name))));
+    return files.flat();
+  }
+  async assertClean(bundleDir) {
+    const unread = [];
+    const secrets = [];
+    for (const file of await this.envFiles()) {
+      try {
+        const value = await ServerEnvProfile.evaluate(file, path6.dirname(path6.dirname(file)));
+        secrets.push(...ServerEnvProfile.secretValues(value).map((secret) => ({ file, ...secret })));
+      } catch {
+        unread.push(ServerBundleSecrets.#relative(this.workspaceRoot, file));
+      }
+    }
+    const found = [];
+    for (const bundled of await ServerBundleSecrets.#files(bundleDir)) {
+      const text = await readFile(bundled, "latin1");
+      for (const secret of secrets)
+        if (ServerBundleSecrets.#needles(secret.value).some((needle) => text.includes(needle)))
+          found.push(`${ServerBundleSecrets.#relative(bundleDir, bundled)} holds ${ServerBundleSecrets.#relative(this.workspaceRoot, secret.file)} ${secret.path}`);
+    }
+    if (found.length)
+      throw new Error(`The server this app carries holds secret values from the workspace's env files, so it is not signed or sent anywhere:
+  ${[...new Set(found)].join(`
+  `)}
+Build its server with a profile (native.desktop.server.profile), whose bundle carries no secret.`);
+    return unread;
+  }
+  static #needles(value) {
+    const escaped = JSON.stringify(value).slice(1, -1);
+    const line = value.split(/\r?\n/).find((part) => part.length >= 32);
+    return [...new Set([value, escaped, ...line ? [line] : []])];
+  }
+  static #relative(from, to) {
+    return path6.relative(from, to).split(path6.sep).join("/");
+  }
+  static async#files(dir) {
+    const files = [];
+    for (const entry of await readdir2(dir, { withFileTypes: true })) {
+      const file = path6.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules")
+          files.push(...await ServerBundleSecrets.#files(file));
+      } else if (entry.isFile() && (await stat2(file)).size <= ServerBundleSecrets.#largestFile)
+        files.push(file);
+    }
+    return files;
+  }
+}
+
 // pkgs/@akanjs/devkit/mobile/nativeApp.ts
 class NativeApp {
   app;
@@ -626,14 +632,14 @@ class NativeApp {
     this.app = app;
     this.target = target;
     this.env = env;
-    this.targetRoot = path6.join(app.workspace.workspaceRoot, "dist", "native", app.name, target.name);
-    this.web = new NativeWebDir(path6.join(this.targetRoot, "web"));
+    this.targetRoot = path7.join(app.workspace.workspaceRoot, "dist", "native", app.name, target.name);
+    this.web = new NativeWebDir(path7.join(this.targetRoot, "web"));
   }
   outDir(platform) {
-    return path6.join(this.targetRoot, "build", platform);
+    return path7.join(this.targetRoot, "build", platform);
   }
   devOutDir(platform) {
-    return path6.join(this.targetRoot, "dev", platform);
+    return path7.join(this.targetRoot, "dev", platform);
   }
   indexPath(platform) {
     const { config } = this.target;
@@ -643,13 +649,13 @@ class NativeApp {
   async assembleWeb(platform) {
     const dist = this.app.dist.cwdPath;
     return await this.web.assemble({ ...this.target.config, indexPath: this.indexPath(platform) }, {
-      html: path6.join(dist, "csr", targetHtmlFilename(this.target.config)),
-      publicDir: path6.join(dist, "public"),
-      fontsDir: path6.join(dist, ".akan", "artifact", "fonts")
+      html: path7.join(dist, "csr", targetHtmlFilename(this.target.config)),
+      publicDir: path7.join(dist, "public"),
+      fontsDir: path7.join(dist, ".akan", "artifact", "fonts")
     });
   }
   get binDir() {
-    return path6.join(this.targetRoot, "bin");
+    return path7.join(this.targetRoot, "bin");
   }
   async config({
     server,
@@ -729,27 +735,18 @@ class NativeApp {
       return {};
     return { PUBLIC_AKAN_SERVER_URL: `http://localhost:${await this.app.getDevPort()}` };
   }
-  async build(platform, { profile = "release", server, installer = false, arch } = {}) {
+  async build(platform, { profile = "release", server, installer = false, arch, sign = false, notarize = false } = {}) {
     NativeApp.#assertServerPlatform(platform, server);
     NativeApp.assertInstaller(platform, installer);
     await this.assembleWeb(platform);
     const { api, config } = await this.prepare(platform, server, arch);
+    const distribution = await this.#distribution(api, platform, profile, { sign, notarize }, server);
     return await api.build({
       ...this.#task(platform, config, { env: await this.#runtimeEnv(server) }),
       profile,
       ...arch ? { arch } : {},
-      ...platform === "windows" ? {
-        windows: {
-          ...installer ? { installer } : {},
-          ...profile === "release" ? NativeApp.#windowsSigning(api) : {}
-        }
-      } : {},
-      ...platform === "macos" ? {
-        macos: {
-          ...profile === "release" ? api.macosDistributionFromEnv(process.env) : {},
-          ...installer ? { dmg: true } : {}
-        }
-      } : {},
+      ...platform === "windows" ? { windows: { ...installer ? { installer } : {}, ...distribution.windows } } : {},
+      ...platform === "macos" ? { macos: { ...distribution.macos, ...installer ? { dmg: true } : {} } } : {},
       ...platform === "linux" && installer ? { linux: { appImage: true } } : {}
     });
   }
@@ -815,23 +812,46 @@ class NativeApp {
     });
   }
   get updatesDir() {
-    return path6.join(this.targetRoot, "updates");
+    return path7.join(this.targetRoot, "updates");
   }
-  async publishUpdate(platform, { channel, server } = {}) {
+  async publishUpdate(platform, {
+    channel,
+    server,
+    arch,
+    sign = false,
+    notarize = false
+  } = {}) {
     NativeApp.#assertServerPlatform(platform, server);
     this.#assertUpdates();
     await this.assembleWeb(platform);
-    const { api, config } = await this.prepare(platform, server);
+    const { api, config } = await this.prepare(platform, server, arch);
+    const distribution = await this.#distribution(api, platform, "release", { sign, notarize }, server);
     return await api.publishUpdate({
       ...this.#task(platform, config, { env: await this.#runtimeEnv(server) }),
       platform,
       out: this.updatesDir,
       ...channel ? { channel } : {},
-      ...platform === "macos" ? { macos: api.macosDistributionFromEnv(process.env) } : {},
-      ...platform === "windows" ? { windows: NativeApp.#windowsSigning(api) } : {}
+      ...arch ? { arch } : {},
+      ...distribution.macos ? { macos: distribution.macos } : {},
+      ...distribution.windows ? { windows: distribution.windows } : {}
     });
   }
-  async assertPublishable(platform, { channel, server = false } = {}) {
+  async#distribution(api, platform, profile, request, server) {
+    const distribution = api.requestedDistribution(platform, profile, request);
+    if (!distribution.notice) {
+      if (distribution.unused.length && (platform === "macos" || platform === "windows"))
+        this.app.logger.info(`${distribution.unused.join(", ")} set: this build is not signed without --sign.`);
+      return distribution;
+    }
+    if (server) {
+      const unread = await new ServerBundleSecrets(this.app.workspace.workspaceRoot, this.app.cwdPath).assertClean(server.dir);
+      if (unread.length)
+        this.app.logger.warn(`Not searched for secrets, as they could not be evaluated: ${unread.join(", ")}.`);
+    }
+    this.app.logger.warn(distribution.notice);
+    return distribution;
+  }
+  async assertPublishable(platform, { channel, server = false, arch } = {}) {
     this.#assertUpdates();
     const [api, { config }] = await Promise.all([
       NativeApi.load(this.app.cwdPath),
@@ -845,7 +865,8 @@ class NativeApp {
         platform,
         out: this.updatesDir,
         server,
-        ...channel ? { channel } : {}
+        ...channel ? { channel } : {},
+        ...arch ? { arch } : {}
       });
     } catch (error) {
       throw new Error(`Native target '${this.target.name}': ${error instanceof Error ? error.message : String(error)}`, {
@@ -880,12 +901,31 @@ class NativeApp {
     const { api, config } = await this.prepare(platform);
     if (!config.updates)
       throw new Error(`Native target '${this.target.name}' takes no updates: add native.updates: { url, publicKey } to akan.config.ts first.`);
-    const packed = await api.packUpdate({
-      ...this.#task(platform, config),
+    const dir = path7.resolve(out ?? path7.join(this.updatesDir, platform));
+    await Promise.all(["pack.json", "compat.json"].map((name) => rm3(path7.join(dir, name), { force: true })));
+    const packed = await api.packUpdate({ ...this.#task(platform, config), platform, out: dir });
+    const channel = config.updates.channel ?? "production";
+    const bundle = await Bun.file(path7.join(packed.out, "bundle.json")).json();
+    const pack = {
+      schema: 1,
+      app: this.app.name,
+      target: this.target.name,
       platform,
-      out: out ?? path6.join(this.updatesDir, platform)
-    });
-    return { ...packed, channel: config.updates.channel ?? "production" };
+      env: this.env ?? "main",
+      channel,
+      appId: packed.manifest.app,
+      appVersion: packed.manifest.version,
+      nativeApi: packed.manifest.nativeApi ?? "",
+      webHash: bundle.web.hash,
+      files: packed.manifest.files.length,
+      size: packed.manifest.files.reduce((sum, file) => sum + file.size, 0),
+      out: packed.out
+    };
+    return { ...packed, channel, pack };
+  }
+  static async writePack(pack) {
+    await Bun.write(path7.join(pack.out, "pack.json"), `${JSON.stringify(pack, null, 2)}
+`);
   }
   static async compareBundles(appDir, shipped, bundle) {
     return (await NativeApi.load(appDir)).compareBundles(shipped, bundle);
@@ -916,10 +956,6 @@ class NativeApp {
     const home = [lang, basePath, indexPath].flatMap((part) => (part ?? "").split("/")).filter((segment) => segment.length > 0);
     return `/${home.join("/")}?${params}`;
   }
-  static #windowsSigning(api) {
-    const signing = api.windowsSigningFromEnv(process.env);
-    return signing ? { signing } : {};
-  }
   static assertInstaller(platform, installer) {
     if (installer && (platform === "ios" || platform === "android"))
       throw new Error(`An installer is built for a desktop app (Windows, macOS, Linux), not for ${platform}.`);
@@ -962,8 +998,8 @@ var isPlaceholderAppId = (appId) => {
   return normalized.split(".").some((segment) => placeholderAppIdSegment.test(segment));
 };
 // pkgs/@akanjs/devkit/mobile/desktopServerStage.ts
-import { cp as cp2, mkdir as mkdir3, readdir as readdir2, rm as rm3, writeFile as writeFile2 } from "fs/promises";
-import path7 from "path";
+import { cp as cp2, mkdir as mkdir3, readdir as readdir3, rm as rm4, writeFile as writeFile2 } from "fs/promises";
+import path8 from "path";
 class DesktopServerStage {
   app;
   static uncarried = new Set([
@@ -980,23 +1016,25 @@ class DesktopServerStage {
   dir;
   constructor(app) {
     this.app = app;
-    this.dir = path7.join(app.cwdPath, ".akan", "desktop", "server");
+    this.dir = path8.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) {
+  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"
+      AKAN_SHUTDOWN_TIMEOUT_MS: "1000",
+      ...modules.length ? { AKAN_MODULES: modules.join(",") } : {}
     };
   }
   static imageStepsNotice(config, carried) {
@@ -1020,7 +1058,7 @@ class DesktopServerStage {
   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(path7.join(nodeModules, manifest)).json().catch(() => null);
+      const json = await Bun.file(path8.join(nodeModules, manifest)).json().catch(() => null);
       if (!json?.name || json.name === name)
         continue;
       const declared = { ...json.dependencies, ...json.optionalDependencies, ...json.peerDependencies };
@@ -1035,26 +1073,26 @@ class DesktopServerStage {
   async install(arch, omit = []) {
     const config = await this.app.getConfig();
     DesktopServerStage.assertCarriable(config);
-    await rm3(this.dir, { recursive: true, force: true });
+    await rm4(this.dir, { recursive: true, force: true });
     await mkdir3(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 writeFile2(path7.join(this.dir, "package.json"), JSON.stringify(DesktopServerStage.packageJson(config, built, omit), null, 2));
+    await writeFile2(path8.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.
 ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
-    await rm3(path7.join(this.dir, "node_modules", ".bin"), { recursive: true, force: true });
+    await rm4(path8.join(this.dir, "node_modules", ".bin"), { recursive: true, force: true });
     await this.#assertOmitted(omit);
   }
   async#assertOmitted(omit) {
-    const nodeModules = path7.join(this.dir, "node_modules");
+    const nodeModules = path8.join(this.dir, "node_modules");
     const kept = [];
     for (const name of omit) {
-      if (!await Bun.file(path7.join(nodeModules, name, "package.json")).exists())
+      if (!await Bun.file(path8.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"})`);
@@ -1062,19 +1100,79 @@ ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     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) {
+  async prepare(environment, run = {}) {
     const config = await this.app.getConfig();
     const dist = this.app.dist.cwdPath;
     await mkdir3(this.dir, { recursive: true });
-    for (const name of await readdir2(dist))
+    for (const name of await readdir3(dist))
       if (!DesktopServerStage.uncarried.has(name))
-        await cp2(path7.join(dist, name), path7.join(this.dir, name), { recursive: true });
+        await cp2(path8.join(dist, name), path8.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) };
+    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 path9 from "path";
+
+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))
+    };
+  }
+  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(dir) {
+    const files = [];
+    for await (const file of new Bun.Glob("**/*").scan({ cwd: dir, onlyFiles: true })) {
+      if (!file.endsWith(".tmp"))
+        files.push(file.split(path9.sep).join("/"));
+    }
+    const { releases, manifests } = UpdateUploader.order(files);
+    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(path9.join(dir, file)));
+      uploaded++;
+    }
+    for (const file of manifests) {
+      const type = file.endsWith(".json") ? "application/json" : "text/plain";
+      await this.bucket.write(keyOf(file), Bun.file(path9.join(dir, file)), { type });
+      uploaded++;
+    }
+    return { uploaded, skipped };
   }
 }
-export { DesktopServerStage, getMobileTargets, getMobileTargetChoices, resolveMobileTargets, resolveAppId, appIdsOf, NativeApp, isPlaceholderAppId };
+export { DesktopServerStage, NativeApp, isPlaceholderAppId, UpdateUploader };

package/{index-xwprn9nr.js → index-nz15k0b6.js}

@@ -116,7 +116,7 @@ class SubagentPool2 {
     }
   }
   async#run(id, kind, prompt, signal) {
-    const { CodeAgent } = await import("./CodeAgent-szbjv4gv.js");
+    const { CodeAgent } = await import("./CodeAgent-q7a4srt6.js");
     const budget = this.#options.parent.tools.subagent;
     const child = SubagentPool2.childOf(this.#options.parent, kind);
     const agent = await CodeAgent.create({