@better-update/cli 0.3.0

package/src/commands/analytics/adoption.ts

@@ -0,0 +1,40 @@
+import { Command, Options } from "@effect/cli";
+import { Console, Effect, Option } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { printTable } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleAnalyticsCommandErrors } from "./helpers";
+
+const period = Options.choice("period", ["1d", "7d", "30d", "90d"]).pipe(Options.optional);
+
+export const adoptionCommand = Command.make("adoption", { period }, (opts) =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const periodFilter = Option.match(opts.period, {
+      onNone: () => ({}) as Record<string, string>,
+      onSome: (periodValue) => ({ period: periodValue }) as Record<string, string>,
+    });
+
+    const result = yield* api.analytics.adoption({
+      urlParams: { projectId, ...periodFilter },
+    });
+
+    if (result.updates.length === 0) {
+      yield* Console.log("No adoption data found.");
+      return;
+    }
+
+    yield* printTable(
+      ["Update ID", "Devices", "First Seen", "Last Seen"],
+      result.updates.map((update) => [
+        update.updateId,
+        String(update.devices),
+        update.firstSeen,
+        update.lastSeen,
+      ]),
+    );
+  }).pipe(handleAnalyticsCommandErrors),
+);

package/src/commands/analytics/channels.ts

@@ -0,0 +1,35 @@
+import { Command, Options } from "@effect/cli";
+import { Effect, Option } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { printKeyValue } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleAnalyticsCommandErrors } from "./helpers";
+
+const channel = Options.text("channel");
+const period = Options.choice("period", ["1d", "7d", "30d", "90d"]).pipe(Options.optional);
+
+export const channelsCommand = Command.make("channels", { channel, period }, (opts) =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const periodFilter = Option.match(opts.period, {
+      onNone: () => ({}) as Record<string, string>,
+      onSome: (periodValue) => ({ period: periodValue }) as Record<string, string>,
+    });
+
+    const result = yield* api.analytics.channels({
+      urlParams: { projectId, channel: opts.channel, ...periodFilter },
+    });
+
+    yield* printKeyValue([
+      ["Channel", result.channel],
+      ["Total Requests", String(result.totalRequests)],
+      ["Unique Devices", String(result.uniqueDevices)],
+      ["Manifest", String(result.responseTypeDistribution.manifest)],
+      ["Directive", String(result.responseTypeDistribution.directive)],
+      ["No Update", String(result.responseTypeDistribution.no_update)],
+    ]);
+  }).pipe(handleAnalyticsCommandErrors),
+);

package/src/commands/analytics/helpers.ts

@@ -0,0 +1,3 @@
+import { makeCommandErrorHandler } from "../../lib/command-errors";
+
+export const handleAnalyticsCommandErrors = makeCommandErrorHandler();

package/src/commands/analytics/index.ts

@@ -0,0 +1,13 @@
+import { Command } from "@effect/cli";
+import { Console } from "effect";
+
+import { adoptionCommand } from "./adoption";
+import { channelsCommand } from "./channels";
+import { platformsCommand } from "./platforms";
+import { updatesCommand } from "./updates";
+
+export const analyticsCommand = Command.make("analytics", {}, () =>
+  Console.log("View deployment analytics. Run with --help for subcommands."),
+).pipe(
+  Command.withSubcommands([adoptionCommand, updatesCommand, channelsCommand, platformsCommand]),
+);

package/src/commands/analytics/platforms.ts

@@ -0,0 +1,39 @@
+import { Command, Options } from "@effect/cli";
+import { Console, Effect, Option } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { printTable } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleAnalyticsCommandErrors } from "./helpers";
+
+const period = Options.choice("period", ["1d", "7d", "30d", "90d"]).pipe(Options.optional);
+
+export const platformsCommand = Command.make("platforms", { period }, (opts) =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const periodFilter = Option.match(opts.period, {
+      onNone: () => ({}) as Record<string, string>,
+      onSome: (periodValue) => ({ period: periodValue }) as Record<string, string>,
+    });
+
+    const result = yield* api.analytics.platforms({
+      urlParams: { projectId, ...periodFilter },
+    });
+
+    if (result.platforms.length === 0) {
+      yield* Console.log("No platform data found.");
+      return;
+    }
+
+    yield* printTable(
+      ["Platform", "Requests", "Devices"],
+      result.platforms.map((platform) => [
+        platform.platform,
+        String(platform.requests),
+        String(platform.devices),
+      ]),
+    );
+  }).pipe(handleAnalyticsCommandErrors),
+);

package/src/commands/analytics/updates.ts

@@ -0,0 +1,35 @@
+import { Command, Options } from "@effect/cli";
+import { Effect, Option } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { printKeyValue } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleAnalyticsCommandErrors } from "./helpers";
+
+const updateId = Options.text("update-id");
+const period = Options.choice("period", ["1d", "7d", "30d", "90d"]).pipe(Options.optional);
+
+export const updatesCommand = Command.make("updates", { updateId, period }, (opts) =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const periodFilter = Option.match(opts.period, {
+      onNone: () => ({}) as Record<string, string>,
+      onSome: (periodValue) => ({ period: periodValue }) as Record<string, string>,
+    });
+
+    const result = yield* api.analytics.updates({
+      urlParams: { projectId, updateId: opts.updateId, ...periodFilter },
+    });
+
+    yield* printKeyValue([
+      ["Update ID", result.updateId],
+      ["Total Requests", String(result.totalRequests)],
+      ["Unique Devices", String(result.uniqueDevices)],
+      ["Manifest", String(result.byResponseType.manifest)],
+      ["Directive", String(result.byResponseType.directive)],
+      ["No Update", String(result.byResponseType.no_update)],
+    ]);
+  }).pipe(handleAnalyticsCommandErrors),
+);

package/src/commands/audit-logs/helpers.ts

@@ -0,0 +1,3 @@
+import { makeCommandErrorHandler } from "../../lib/command-errors";
+
+export const handleAuditLogCommandErrors = makeCommandErrorHandler();

package/src/commands/audit-logs/index.ts

@@ -0,0 +1,8 @@
+import { Command } from "@effect/cli";
+import { Console } from "effect";
+
+import { listCommand } from "./list";
+
+export const auditLogsCommand = Command.make("audit-logs", {}, () =>
+  Console.log("View audit logs. Run with --help for subcommands."),
+).pipe(Command.withSubcommands([listCommand]));

package/src/commands/audit-logs/list.ts

@@ -0,0 +1,66 @@
+import { Command, Options } from "@effect/cli";
+import { Console, Effect, Option } from "effect";
+
+import { printTable } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleAuditLogCommandErrors } from "./helpers";
+
+const action = Options.text("action").pipe(Options.optional);
+const resourceType = Options.text("resource-type").pipe(Options.optional);
+const actorId = Options.text("actor-id").pipe(Options.optional);
+const from = Options.text("from").pipe(Options.optional);
+const to = Options.text("to").pipe(Options.optional);
+
+export const listCommand = Command.make(
+  "list",
+  { action, resourceType, actorId, from, to },
+  (opts) =>
+    Effect.gen(function* () {
+      const api = yield* apiClient;
+
+      const filters = {
+        ...Option.match(opts.action, {
+          onNone: () => ({}),
+          onSome: (value) => ({ action: value }),
+        }),
+        ...Option.match(opts.resourceType, {
+          onNone: () => ({}),
+          onSome: (value) => ({ resourceType: value }),
+        }),
+        ...Option.match(opts.actorId, {
+          onNone: () => ({}),
+          onSome: (value) => ({ actorId: value }),
+        }),
+        ...Option.match(opts.from, {
+          onNone: () => ({}),
+          onSome: (value) => ({ from: value }),
+        }),
+        ...Option.match(opts.to, {
+          onNone: () => ({}),
+          onSome: (value) => ({ to: value }),
+        }),
+      } as Record<string, string>;
+
+      const { items } = yield* api["audit-logs"].list({
+        urlParams: { ...filters, page: 1, limit: 100 },
+      });
+
+      if (items.length === 0) {
+        yield* Console.log("No audit log entries found.");
+        return;
+      }
+
+      yield* printTable(
+        ["ID", "Action", "Resource Type", "Resource ID", "Actor", "Source", "Created"],
+        items.map((log) => [
+          log.id,
+          log.action,
+          log.resourceType,
+          log.resourceId ?? "-",
+          log.actorEmail,
+          log.source,
+          log.createdAt,
+        ]),
+      );
+    }).pipe(handleAuditLogCommandErrors),
+);

package/src/commands/branches.ts

@@ -0,0 +1,70 @@
+import { Args, Command, Options } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../lib/app-json";
+import { makeCommandErrorHandler } from "../lib/command-errors";
+import { printKeyValue, printTable } from "../lib/output";
+import { apiClient } from "../services/api-client";
+
+const handleErrors = makeCommandErrorHandler();
+
+const idArg = Args.text({ name: "id" });
+const nameOption = Options.text("name");
+
+const listCommand = Command.make("list", {}, () =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+    const { items } = yield* api.branches.list({
+      urlParams: { projectId, page: 1, limit: 1000 },
+    });
+
+    if (items.length === 0) {
+      yield* Console.log("No branches found.");
+      return;
+    }
+
+    yield* printTable(
+      ["ID", "Name", "Created"],
+      items.map((branch) => [branch.id, branch.name, branch.createdAt]),
+    );
+  }).pipe(handleErrors),
+);
+
+const createCommand = Command.make("create", { name: nameOption }, (opts) =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+    const branch = yield* api.branches.create({
+      payload: { projectId, name: opts.name },
+    });
+    yield* printKeyValue([
+      ["ID", branch.id],
+      ["Name", branch.name],
+      ["Created", branch.createdAt],
+    ]);
+  }).pipe(handleErrors),
+);
+
+const renameCommand = Command.make("rename", { id: idArg, name: nameOption }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const branch = yield* api.branches.rename({
+      path: { id: opts.id },
+      payload: { name: opts.name },
+    });
+    yield* Console.log(`Branch renamed to "${branch.name}".`);
+  }).pipe(handleErrors),
+);
+
+const deleteCommand = Command.make("delete", { id: idArg }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    yield* api.branches.delete({ path: { id: opts.id } });
+    yield* Console.log(`Branch ${opts.id} deleted.`);
+  }).pipe(handleErrors),
+);
+
+export const branchesCommand = Command.make("branches", {}, () =>
+  Console.log("Manage branches. Run with --help for subcommands."),
+).pipe(Command.withSubcommands([listCommand, createCommand, renameCommand, deleteCommand]));

package/src/commands/build/android.ts

@@ -0,0 +1,129 @@
+import path from "node:path";
+
+import { Command, FileSystem } from "@effect/platform";
+import { Effect } from "effect";
+
+import type { CommandExecutor } from "@effect/platform";
+import type { PlatformError } from "@effect/platform/Error";
+
+import { renderSigningGradle } from "../../lib/android-signing-gradle";
+import { findAndroidArtifact } from "../../lib/artifact-finder";
+import { downloadAndroidCredentials } from "../../lib/credentials-downloader";
+import { sha256File } from "../../lib/sha256";
+import { capitalize } from "../../lib/string-utils";
+import { CliRuntime } from "../../services/cli-runtime";
+import { runStep } from "./run-step";
+
+import type { AndroidProfile } from "../../lib/build-profile";
+import type {
+  ArtifactNotFoundError,
+  BuildFailedError,
+  MissingCredentialsError,
+} from "../../lib/exit-codes";
+import type { ApiClient } from "../../services/api-client";
+
+export interface RunAndroidBuildInput {
+  readonly api: ApiClient;
+  readonly tempDir: string;
+  readonly projectRoot: string;
+  readonly androidProfile: AndroidProfile;
+  readonly applicationIdentifier: string;
+  readonly envVars: Record<string, string>;
+  readonly projectId: string;
+}
+
+export interface RunAndroidBuildResult {
+  readonly artifactPath: string;
+  readonly byteSize: number;
+  readonly sha256: string;
+}
+
+/**
+ * Compose the Gradle task name from flavor, format, and buildType.
+ *
+ * Gradle naming convention: `<verb><Flavor><Variant>`, e.g.
+ *   - no flavor + apk + release       → `assembleRelease`
+ *   - no flavor + aab + release       → `bundleRelease`
+ *   - flavor=prod + aab + release     → `bundleProdRelease`
+ *   - flavor=prod + apk + debug       → `assembleProdDebug`
+ */
+const gradleTaskName = (
+  format: "apk" | "aab",
+  flavor: string | undefined,
+  buildType: "debug" | "release",
+): string => {
+  const verb = format === "aab" ? "bundle" : "assemble";
+  return flavor
+    ? `${verb}${capitalize(flavor)}${capitalize(buildType)}`
+    : `${verb}${capitalize(buildType)}`;
+};
+
+export const runAndroidBuild = (
+  input: RunAndroidBuildInput,
+): Effect.Effect<
+  RunAndroidBuildResult,
+  BuildFailedError | MissingCredentialsError | ArtifactNotFoundError | PlatformError,
+  CliRuntime | CommandExecutor.CommandExecutor | FileSystem.FileSystem
+> =>
+  Effect.gen(function* () {
+    const { api, tempDir, projectRoot, androidProfile, applicationIdentifier, envVars, projectId } =
+      input;
+    const runtime = yield* CliRuntime;
+
+    // Record build start so artifact-finder can reject stale outputs from
+    // Earlier builds that may still live in `android/app/build/outputs/`.
+    const buildStartMs = Date.now();
+
+    const { format } = androidProfile;
+    const { flavor } = androidProfile;
+    const buildType = androidProfile.buildType ?? "release";
+    const androidDir = path.join(projectRoot, "android");
+    const commandEnv = yield* runtime.commandEnvironment(envVars);
+
+    const credentials = yield* downloadAndroidCredentials(api, {
+      projectId,
+      applicationIdentifier,
+      tempDir,
+    });
+
+    yield* runStep(
+      Command.make("bunx", "expo", "prebuild", "--platform", "android", "--clean").pipe(
+        Command.workingDirectory(projectRoot),
+        Command.env(commandEnv),
+      ),
+      "expo prebuild android",
+    );
+
+    const fs = yield* FileSystem.FileSystem;
+    const signingGradlePath = path.join(tempDir, "signing.gradle");
+    yield* fs.writeFileString(
+      signingGradlePath,
+      renderSigningGradle({
+        keystorePath: credentials.keystorePath,
+        storePassword: credentials.storePassword,
+        keyAlias: credentials.keyAlias,
+        keyPassword: credentials.keyPassword,
+      }),
+    );
+
+    const taskName = gradleTaskName(format, flavor, buildType);
+    yield* runStep(
+      Command.make("./gradlew", "--init-script", signingGradlePath, `:app:${taskName}`).pipe(
+        Command.workingDirectory(androidDir),
+        Command.env(commandEnv),
+      ),
+      "gradlew",
+    );
+
+    const artifactPath = yield* findAndroidArtifact({
+      projectRoot,
+      format,
+      ...(flavor === undefined ? {} : { flavor }),
+      buildType,
+      minMtimeMs: buildStartMs,
+    });
+
+    const { sha256, byteSize } = yield* sha256File(artifactPath);
+
+    return { artifactPath, byteSize, sha256 };
+  });

package/src/commands/build/index.ts

@@ -0,0 +1,63 @@
+import { Command, Options } from "@effect/cli";
+import { Effect, Option } from "effect";
+
+import type { BadArgument, SystemError } from "@effect/platform/Error";
+
+import { runBuildWorkflow } from "../../application/build-workflow";
+import { exitWith } from "../../application/command-exit";
+
+import type {
+  ArtifactNotFoundError,
+  AuthRequiredError,
+  BuildFailedError,
+  BuildProfileError,
+  CompleteError,
+  EnvExportError,
+  KeychainError,
+  MissingCredentialsError,
+  PresignedUrlExpiredError,
+  ProjectNotLinkedError,
+  ProvisioningError,
+  ReserveError,
+  RuntimeVersionError,
+  UploadFailedError,
+} from "../../lib/exit-codes";
+
+const platform = Options.choice("platform", ["ios", "android"] as const);
+const profile = Options.text("profile").pipe(Options.withDefault("production"));
+const message = Options.text("message").pipe(Options.optional);
+const noUpload = Options.boolean("no-upload");
+const rawOutput = Options.boolean("raw-output");
+
+export const buildCommand = Command.make(
+  "build",
+  { platform, profile, message, noUpload, rawOutput },
+  (opts) =>
+    runBuildWorkflow({
+      platform: opts.platform,
+      profileName: opts.profile,
+      message: Option.getOrUndefined(opts.message),
+      noUpload: opts.noUpload,
+      rawOutput: opts.rawOutput,
+    }).pipe(
+      Effect.catchTags({
+        AuthRequiredError: (err: AuthRequiredError) => exitWith(3, err.message),
+        ProjectNotLinkedError: (err: ProjectNotLinkedError) => exitWith(4, err.message),
+        BuildProfileError: (err: BuildProfileError) => exitWith(2, err.message),
+        RuntimeVersionError: (err: RuntimeVersionError) => exitWith(2, err.message),
+        MissingCredentialsError: (err: MissingCredentialsError) =>
+          exitWith(5, `${err.message}\n${err.hint}`),
+        BuildFailedError: (err: BuildFailedError) => exitWith(6, err.message),
+        KeychainError: (err: KeychainError) => exitWith(6, err.message),
+        ProvisioningError: (err: ProvisioningError) => exitWith(6, err.message),
+        ArtifactNotFoundError: (err: ArtifactNotFoundError) => exitWith(6, err.message),
+        ReserveError: (err: ReserveError) => exitWith(7, err.message),
+        UploadFailedError: (err: UploadFailedError) => exitWith(7, err.message),
+        PresignedUrlExpiredError: (err: PresignedUrlExpiredError) => exitWith(7, err.message),
+        CompleteError: (err: CompleteError) => exitWith(7, err.message),
+        EnvExportError: (err: EnvExportError) => exitWith(7, err.message),
+        SystemError: (err: SystemError) => exitWith(6, `Filesystem error: ${err.message}`),
+        BadArgument: (err: BadArgument) => exitWith(6, `Invalid argument: ${err.message}`),
+      }),
+    ),
+);