@better-update/cli 0.3.0 → 0.4.0

package/src/lib/expo-export.test.ts

@@ -1,94 +0,0 @@
-import path from "node:path";
-
-import { FileSystem } from "@effect/platform";
-import { Effect, Exit } from "effect";
-
-import { UpdatePublishError } from "./exit-codes";
-import { readExpoExportAssets } from "./expo-export";
-import { failureError } from "./test-utils";
-
-const makeFs = (files: Record<string, string>) =>
-  FileSystem.layerNoop({
-    readFileString: (filePath: string) => {
-      const value = files[filePath];
-      return value === undefined
-        ? Effect.die(new Error(`ENOENT: ${filePath}`))
-        : Effect.succeed(value);
-    },
-  });
-
-describe(readExpoExportAssets, () => {
-  it("parses launch bundle and regular assets from metadata.json", async () => {
-    const exportDir = "/tmp/export-ios";
-    const metadataPath = path.join(exportDir, "metadata.json");
-    const exit = await Effect.runPromiseExit(
-      readExpoExportAssets({ exportDir, platform: "ios" }).pipe(
-        Effect.provide(
-          makeFs({
-            [metadataPath]: JSON.stringify({
-              version: 0,
-              bundler: "metro",
-              fileMetadata: {
-                ios: {
-                  bundle: "_expo/static/js/ios/index-ba7f80c877854ce4d715c0cb029ac497.hbc",
-                  assets: [{ path: "assets/4e3f888fc8475f69fd5fa32f1ad5216a", ext: "png" }],
-                },
-              },
-            }),
-          }),
-        ),
-      ),
-    );
-
-    expect(Exit.isSuccess(exit)).toBe(true);
-    if (Exit.isSuccess(exit)) {
-      expect(exit.value).toStrictEqual([
-        {
-          path: path.join(
-            exportDir,
-            "_expo/static/js/ios/index-ba7f80c877854ce4d715c0cb029ac497.hbc",
-          ),
-          key: "index-ba7f80c877854ce4d715c0cb029ac497.hbc",
-          fileExt: "hbc",
-          contentType: "application/javascript",
-          isLaunch: true,
-        },
-        {
-          path: path.join(exportDir, "assets/4e3f888fc8475f69fd5fa32f1ad5216a"),
-          key: "4e3f888fc8475f69fd5fa32f1ad5216a",
-          fileExt: "png",
-          contentType: "image/png",
-          isLaunch: false,
-        },
-      ]);
-    }
-  });
-
-  it("fails when the requested platform is missing from metadata", async () => {
-    const exportDir = "/tmp/export-android";
-    const metadataPath = path.join(exportDir, "metadata.json");
-    const exit = await Effect.runPromiseExit(
-      readExpoExportAssets({ exportDir, platform: "android" }).pipe(
-        Effect.provide(
-          makeFs({
-            [metadataPath]: JSON.stringify({
-              version: 0,
-              bundler: "metro",
-              fileMetadata: {
-                ios: {
-                  bundle: "_expo/static/js/ios/index.hbc",
-                  assets: [],
-                },
-              },
-            }),
-          }),
-        ),
-      ),
-    );
-
-    expect(Exit.isFailure(exit)).toBe(true);
-    if (Exit.isFailure(exit)) {
-      expect(failureError(exit)).toBeInstanceOf(UpdatePublishError);
-    }
-  });
-});

package/src/lib/expo-export.ts

@@ -1,281 +0,0 @@
-import path from "node:path";
-
-import { Command, FileSystem } from "@effect/platform";
-import { Effect } from "effect";
-
-import type { CommandExecutor } from "@effect/platform";
-
-import { CliRuntime } from "../services/cli-runtime";
-import { BuildFailedError, UpdatePublishError } from "./exit-codes";
-import { asRecord } from "./record";
-
-import type { Platform } from "./build-profile";
-
-export interface ExportedUpdateAssetFile {
-  readonly path: string;
-  readonly key: string;
-  readonly fileExt: string;
-  readonly contentType: string;
-  readonly isLaunch: boolean;
-}
-
-interface ReadExpoPublicConfigOptions {
-  readonly projectRoot: string;
-  readonly envVars: Record<string, string>;
-}
-
-interface RunExpoExportOptions extends ReadExpoPublicConfigOptions {
-  readonly exportDir: string;
-  readonly platform: Platform;
-  readonly clear: boolean;
-}
-
-interface ReadExpoExportAssetsOptions {
-  readonly exportDir: string;
-  readonly platform: Platform;
-}
-
-const asString = (value: unknown): string | undefined =>
-  typeof value === "string" ? value : undefined;
-
-const normalizeExtension = (value: string | undefined): string | undefined => {
-  if (!value) {
-    return undefined;
-  }
-  return value.startsWith(".") ? value.slice(1) : value;
-};
-
-const inferContentType = (fileExt: string, isLaunch: boolean): string => {
-  const normalized = fileExt.toLowerCase();
-  if (isLaunch || normalized === "js" || normalized === "hbc" || normalized === "bundle") {
-    return "application/javascript";
-  }
-
-  switch (normalized) {
-    case "png": {
-      return "image/png";
-    }
-    case "jpg":
-    case "jpeg": {
-      return "image/jpeg";
-    }
-    case "webp": {
-      return "image/webp";
-    }
-    case "gif": {
-      return "image/gif";
-    }
-    case "svg": {
-      return "image/svg+xml";
-    }
-    case "json": {
-      return "application/json";
-    }
-    case "mp4": {
-      return "video/mp4";
-    }
-    case "mp3": {
-      return "audio/mpeg";
-    }
-    case "wav": {
-      return "audio/wav";
-    }
-    case "ttf": {
-      return "font/ttf";
-    }
-    case "otf": {
-      return "font/otf";
-    }
-    case "woff": {
-      return "font/woff";
-    }
-    case "woff2": {
-      return "font/woff2";
-    }
-    default: {
-      return "application/octet-stream";
-    }
-  }
-};
-
-const makeBunxCommand = (...args: readonly string[]): Command.Command =>
-  Command.make("bunx", ...args);
-
-const runCommand = (
-  cmd: Command.Command,
-  step: string,
-): Effect.Effect<void, BuildFailedError, CommandExecutor.CommandExecutor> =>
-  Command.exitCode(cmd.pipe(Command.stdout("inherit"), Command.stderr("inherit"))).pipe(
-    Effect.mapError(
-      (cause) =>
-        new BuildFailedError({
-          step,
-          exitCode: 1,
-          message: `${step} failed to spawn: ${String(cause)}`,
-        }),
-    ),
-    Effect.flatMap((code) =>
-      code === 0
-        ? Effect.void
-        : Effect.fail(
-            new BuildFailedError({
-              step,
-              exitCode: code,
-              message: `${step} exited with code ${code}`,
-            }),
-          ),
-    ),
-  );
-
-export const readExpoPublicConfig = ({
-  projectRoot,
-  envVars,
-}: ReadExpoPublicConfigOptions): Effect.Effect<
-  Record<string, unknown>,
-  UpdatePublishError,
-  CliRuntime | CommandExecutor.CommandExecutor
-> =>
-  Effect.gen(function* () {
-    const runtime = yield* CliRuntime;
-    const commandEnv = yield* runtime.commandEnvironment(envVars);
-    const stdout = yield* Command.string(
-      makeBunxCommand("expo", "config", "--type", "public", "--json").pipe(
-        Command.workingDirectory(projectRoot),
-        Command.env(commandEnv),
-      ),
-    ).pipe(
-      Effect.mapError(
-        (cause) =>
-          new UpdatePublishError({
-            message: `Failed to read Expo public config: ${String(cause)}`,
-          }),
-      ),
-    );
-
-    const parsed = yield* Effect.try({
-      try: () => JSON.parse(stdout) as unknown,
-      catch: () =>
-        new UpdatePublishError({
-          message: "Expo public config output was not valid JSON.",
-        }),
-    });
-
-    const config = asRecord(parsed);
-    if (!config) {
-      return yield* new UpdatePublishError({
-        message: "Expo public config did not decode to a JSON object.",
-      });
-    }
-
-    return config;
-  });
-
-export const runExpoExport = ({
-  projectRoot,
-  exportDir,
-  platform,
-  envVars,
-  clear,
-}: RunExpoExportOptions): Effect.Effect<
-  void,
-  BuildFailedError,
-  CliRuntime | CommandExecutor.CommandExecutor
-> =>
-  Effect.gen(function* () {
-    const runtime = yield* CliRuntime;
-    const commandEnv = yield* runtime.commandEnvironment(envVars);
-    const args = [
-      "expo",
-      "export",
-      "--platform",
-      platform,
-      "--output-dir",
-      exportDir,
-      "--dump-assetmap",
-    ];
-    if (clear) {
-      args.push("--clear");
-    }
-
-    return yield* runCommand(
-      makeBunxCommand(...args).pipe(Command.workingDirectory(projectRoot), Command.env(commandEnv)),
-      `expo export ${platform}`,
-    );
-  });
-
-export const readExpoExportAssets = ({
-  exportDir,
-  platform,
-}: ReadExpoExportAssetsOptions): Effect.Effect<
-  readonly ExportedUpdateAssetFile[],
-  UpdatePublishError,
-  FileSystem.FileSystem
-> =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const metadataPath = path.join(exportDir, "metadata.json");
-    const metadataText = yield* fs.readFileString(metadataPath).pipe(
-      Effect.mapError(
-        () =>
-          new UpdatePublishError({
-            message: `Expected Expo export metadata at ${metadataPath}.`,
-          }),
-      ),
-    );
-
-    const metadata = yield* Effect.try({
-      try: () => JSON.parse(metadataText) as unknown,
-      catch: () =>
-        new UpdatePublishError({
-          message: `Failed to parse ${metadataPath} as JSON.`,
-        }),
-    });
-
-    const platformMetadata = asRecord(asRecord(asRecord(metadata)?.["fileMetadata"])?.[platform]);
-    const bundlePath = asString(platformMetadata?.["bundle"]);
-    if (!bundlePath) {
-      return yield* new UpdatePublishError({
-        message: `Expo export did not contain a bundle path for platform "${platform}".`,
-      });
-    }
-
-    const bundleExt = normalizeExtension(path.extname(bundlePath)) ?? "js";
-    const rawAssets = Array.isArray(platformMetadata?.["assets"]) ? platformMetadata["assets"] : [];
-
-    // eslint-disable-next-line unicorn/no-array-method-this-argument -- Effect.forEach, not Array.prototype.forEach; the second arg is a mapping effect, not a thisArg
-    const assets = yield* Effect.forEach(rawAssets, (rawAsset, index) =>
-      Effect.gen(function* () {
-        const asset = asRecord(rawAsset);
-        const assetPath = asString(asset?.["path"]);
-        if (!assetPath) {
-          return yield* new UpdatePublishError({
-            message: `Expo export asset #${String(index + 1)} is missing its "path" field.`,
-          });
-        }
-
-        const fileExt =
-          normalizeExtension(asString(asset?.["ext"])) ??
-          normalizeExtension(path.extname(assetPath)) ??
-          "bin";
-
-        return {
-          path: path.join(exportDir, assetPath),
-          key: path.posix.basename(assetPath),
-          fileExt,
-          contentType: inferContentType(fileExt, false),
-          isLaunch: false,
-        } as const satisfies ExportedUpdateAssetFile;
-      }),
-    );
-
-    return [
-      {
-        path: path.join(exportDir, bundlePath),
-        key: path.posix.basename(bundlePath),
-        fileExt: bundleExt,
-        contentType: inferContentType(bundleExt, true),
-        isLaunch: true,
-      } as const satisfies ExportedUpdateAssetFile,
-      ...assets,
-    ] as const;
-  });

package/src/lib/fingerprint.ts

@@ -1,67 +0,0 @@
-import { Command } from "@effect/platform";
-import { Data, Effect } from "effect";
-
-import type { CommandExecutor } from "@effect/platform";
-
-import { isRecord } from "./record";
-
-export class FingerprintError extends Data.TaggedError("FingerprintError")<{
-  readonly message: string;
-}> {}
-
-export interface FingerprintSource {
-  readonly type: string;
-  readonly filePath?: string;
-  readonly reasons: readonly string[];
-  readonly hash: string | null;
-}
-
-export interface FingerprintResult {
-  readonly hash: string;
-  readonly sources: readonly FingerprintSource[];
-}
-
-export const runFingerprintFull = (
-  projectRoot: string,
-): Effect.Effect<FingerprintResult, FingerprintError, CommandExecutor.CommandExecutor> =>
-  Effect.gen(function* () {
-    const cmd = Command.make("bunx", "@expo/fingerprint", projectRoot).pipe(
-      Command.workingDirectory(projectRoot),
-    );
-    const stdout = yield* Command.string(cmd).pipe(
-      Effect.mapError(
-        (cause) =>
-          new FingerprintError({
-            message: `Failed to run "@expo/fingerprint": ${cause.message}`,
-          }),
-      ),
-    );
-
-    const parsed = yield* Effect.try({
-      try: (): unknown => JSON.parse(stdout),
-      catch: () =>
-        new FingerprintError({
-          message: "Failed to parse @expo/fingerprint output as JSON.",
-        }),
-    });
-
-    if (!isRecord(parsed)) {
-      return yield* new FingerprintError({
-        message: "@expo/fingerprint output was not a JSON object.",
-      });
-    }
-
-    const { hash } = parsed;
-    if (typeof hash !== "string" || hash.length === 0) {
-      return yield* new FingerprintError({
-        message: '@expo/fingerprint output did not contain a "hash" string field.',
-      });
-    }
-
-    const sourcesRaw = parsed["sources"];
-    const sources: readonly FingerprintSource[] = Array.isArray(sourcesRaw)
-      ? (sourcesRaw as readonly FingerprintSource[])
-      : [];
-
-    return { hash, sources };
-  });

package/src/lib/format-error.ts

@@ -1,22 +0,0 @@
-export const formatCause = (cause: unknown): string => {
-  if (cause instanceof Error) {
-    return cause.message;
-  }
-
-  if (typeof cause === "object" && cause !== null) {
-    const tagged = cause as { readonly _tag?: unknown; readonly message?: unknown };
-    const tag = typeof tagged._tag === "string" ? tagged._tag : undefined;
-    const message = typeof tagged.message === "string" ? tagged.message : undefined;
-    if (tag && message) {
-      return `${tag}: ${message}`;
-    }
-    if (message) {
-      return message;
-    }
-    if (tag) {
-      return tag;
-    }
-  }
-
-  return String(cause);
-};

package/src/lib/git-context.ts

@@ -1,56 +0,0 @@
-import { Command } from "@effect/platform";
-import { Effect } from "effect";
-
-import type { CommandExecutor } from "@effect/platform";
-
-export interface GitContext {
-  readonly ref: string | undefined;
-  readonly commit: string | undefined;
-  readonly commitMessage: string | undefined;
-  readonly dirty: boolean;
-}
-
-const runString = (
-  cmd: Command.Command,
-  cwd: string,
-): Effect.Effect<string, unknown, CommandExecutor.CommandExecutor> =>
-  Command.string(Command.workingDirectory(cmd, cwd));
-
-/**
- * Best-effort git context extraction. If git is missing, the directory isn't
- * a repo, or any command fails, we silently return undefined fields so the
- * build can still proceed. This is intentional — git context is metadata,
- * not a requirement.
- */
-export const readGitContext = (
-  projectRoot: string,
-): Effect.Effect<GitContext, never, CommandExecutor.CommandExecutor> =>
-  Effect.gen(function* () {
-    const [commit, ref, commitMessage, status] = yield* Effect.all(
-      [
-        runString(Command.make("git", "rev-parse", "HEAD"), projectRoot).pipe(
-          Effect.map((output) => output.trim()),
-          Effect.catchAll(() => Effect.succeed("")),
-        ),
-        runString(Command.make("git", "symbolic-ref", "--short", "HEAD"), projectRoot).pipe(
-          Effect.map((output) => output.trim()),
-          Effect.catchAll(() => Effect.succeed("")),
-        ),
-        runString(Command.make("git", "log", "-1", "--format=%s"), projectRoot).pipe(
-          Effect.map((output) => output.trim()),
-          Effect.catchAll(() => Effect.succeed("")),
-        ),
-        runString(Command.make("git", "status", "--porcelain"), projectRoot).pipe(
-          Effect.catchAll(() => Effect.succeed("")),
-        ),
-      ],
-      { concurrency: "unbounded" },
-    );
-
-    return {
-      ref: ref.length > 0 ? ref : undefined,
-      commit: commit.length > 0 ? commit : undefined,
-      commitMessage: commitMessage.length > 0 ? commitMessage : undefined,
-      dirty: status.trim().length > 0,
-    };
-  });

package/src/lib/gradle-config.ts

@@ -1,126 +0,0 @@
-import path from "node:path";
-
-import { FileSystem } from "@effect/platform";
-import { Console, Effect } from "effect";
-
-import { asRecord } from "./record";
-
-export interface GradleConfig {
-  readonly applicationId?: string;
-  readonly versionCode?: number;
-  readonly versionName?: string;
-}
-
-/**
- * Parse Groovy `build.gradle` to extract key Android config values.
- * Returns `undefined` if:
- * - Only `build.gradle.kts` exists (Kotlin DSL not supported by gradle-to-js)
- * - No build.gradle found at all
- * - Parse fails
- *
- * Informational only — never blocks the build.
- */
-export const readGradleConfig = (
-  androidDir: string,
-): Effect.Effect<GradleConfig | undefined, never, FileSystem.FileSystem> =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const gradlePath = path.join(androidDir, "app", "build.gradle");
-    const ktsPath = path.join(androidDir, "app", "build.gradle.kts");
-
-    const hasGroovy = yield* fs.exists(gradlePath).pipe(Effect.orElseSucceed(() => false));
-    const hasKts = yield* fs.exists(ktsPath).pipe(Effect.orElseSucceed(() => false));
-
-    if (!hasGroovy && hasKts) {
-      // Kotlin DSL — gradle-to-js cannot parse it
-      return undefined;
-    }
-
-    if (!hasGroovy) {
-      return undefined;
-    }
-
-    const content = yield* fs
-      .readFileString(gradlePath)
-      .pipe(Effect.catchAll(() => Effect.succeed(undefined)));
-    if (!content) {
-      return undefined;
-    }
-
-    return yield* Effect.tryPromise({
-      try: async () => {
-        const gradle =
-          // eslint-disable-next-line typescript/no-unsafe-type-assertion -- CJS require returns `any`; narrow to gradle-to-js declared shape
-          require("gradle-to-js") as {
-            parseText: (text: string) => Promise<Record<string, unknown>>;
-          };
-        return gradle.parseText(stripGroovyComments(content));
-      },
-      catch: () => undefined,
-    }).pipe(
-      Effect.map(extractGradleConfig),
-      Effect.catchAll(() => Effect.succeed(undefined)),
-    );
-  });
-
-/**
- * Log a warning if Gradle applicationId differs from app.json package name.
- */
-export const warnOnGradleMismatch = (
-  gradleConfig: GradleConfig | undefined,
-  expectedPackage: string,
-): Effect.Effect<void> => {
-  if (!gradleConfig?.applicationId) {
-    return Effect.void;
-  }
-  if (gradleConfig.applicationId === expectedPackage) {
-    return Effect.void;
-  }
-  return Console.warn(
-    `Gradle applicationId "${gradleConfig.applicationId}" differs from app.json package "${expectedPackage}". ` +
-      `The Gradle value will be used in the built APK/AAB.`,
-  );
-};
-
-// ── helpers ──────────────────────────────────────────────────────
-
-/**
- * Strip Groovy single-line and block comments.
- * gradle-to-js chokes on comments — EAS CLI does this same pre-processing.
- */
-const stripGroovyComments = (text: string): string =>
-  text.replaceAll(/\/\/.*$/gmu, "").replaceAll(/\/\*[\s\S]*?\*\//gu, "");
-
-const parseVersionCode = (raw: unknown): number | undefined => {
-  if (typeof raw === "number") {
-    return raw;
-  }
-  if (typeof raw === "string") {
-    return Number.parseInt(raw, 10) || undefined;
-  }
-  return undefined;
-};
-
-const extractGradleConfig = (parsed: Record<string, unknown>): GradleConfig => {
-  const android = asRecord(parsed["android"]);
-  const defaultConfig = asRecord(android?.["defaultConfig"]);
-
-  const applicationId =
-    typeof defaultConfig?.["applicationId"] === "string"
-      ? unquote(defaultConfig["applicationId"])
-      : undefined;
-  const versionCode = parseVersionCode(defaultConfig?.["versionCode"]);
-  const versionName =
-    typeof defaultConfig?.["versionName"] === "string"
-      ? unquote(defaultConfig["versionName"])
-      : undefined;
-
-  return {
-    ...(applicationId === undefined ? {} : { applicationId }),
-    ...(versionCode === undefined ? {} : { versionCode }),
-    ...(versionName === undefined ? {} : { versionName }),
-  };
-};
-
-const unquote = (input: string): string =>
-  input.startsWith('"') && input.endsWith('"') ? input.slice(1, -1) : input;