@better-update/cli 0.3.0

package/src/commands/build/run-step.ts

@@ -0,0 +1,131 @@
+import process from "node:process";
+
+import { Command } from "@effect/platform";
+import { Effect, Fiber, Stream } from "effect";
+
+import type { CommandExecutor } from "@effect/platform";
+import type { Scope } from "effect";
+
+import { BuildFailedError } from "../../lib/exit-codes";
+
+import type { XcodebuildFormatter } from "../../lib/xcpretty-formatter";
+
+export const runStep = (
+  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}`,
+            }),
+          ),
+    ),
+  );
+
+/**
+ * Run a build step with stdout piped through a formatter (e.g., xcpretty).
+ * stderr passes through to the terminal directly.
+ */
+export const runStepFormatted = (
+  cmd: Command.Command,
+  step: string,
+  formatter: XcodebuildFormatter,
+): Effect.Effect<void, BuildFailedError, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    const proc = yield* Command.start(
+      cmd.pipe(Command.stdout("pipe"), Command.stderr("pipe")),
+    ).pipe(
+      Effect.mapError(
+        (cause) =>
+          new BuildFailedError({
+            step,
+            exitCode: 1,
+            message: `${step} failed to spawn: ${String(cause)}`,
+          }),
+      ),
+    );
+
+    const stdoutFiber = yield* proc.stdout.pipe(
+      Stream.decodeText(),
+      Stream.splitLines,
+      Stream.runForEach((line) => {
+        const formatted = formatter.pipe(line);
+        return formatted.length > 0
+          ? Effect.sync(() => {
+              for (const output of formatted) {
+                process.stdout.write(`${output}\n`);
+              }
+            })
+          : Effect.void;
+      }),
+      Effect.mapError(
+        (cause) =>
+          new BuildFailedError({
+            step,
+            exitCode: 1,
+            message: `${step} stdout stream error: ${String(cause)}`,
+          }),
+      ),
+      Effect.fork,
+    );
+
+    const stderrFiber = yield* proc.stderr.pipe(
+      Stream.decodeText(),
+      Stream.splitLines,
+      Stream.runForEach((line) => Effect.sync(() => process.stderr.write(`${line}\n`))),
+      Effect.mapError(
+        (cause) =>
+          new BuildFailedError({
+            step,
+            exitCode: 1,
+            message: `${step} stderr stream error: ${String(cause)}`,
+          }),
+      ),
+      Effect.fork,
+    );
+
+    // Join fibers concurrently — stream errors are non-fatal, exit code takes precedence.
+    yield* Effect.all([Fiber.join(stdoutFiber), Fiber.join(stderrFiber)], {
+      concurrency: 2,
+    }).pipe(Effect.catchAll(() => Effect.void));
+
+    const code = yield* proc.exitCode.pipe(
+      Effect.mapError(
+        (cause) =>
+          new BuildFailedError({
+            step,
+            exitCode: 1,
+            message: `${step} exit code error: ${String(cause)}`,
+          }),
+      ),
+    );
+
+    if (code !== 0) {
+      // Print build summary on failure for xcpretty diagnostics
+      const summary = formatter.getBuildSummary();
+      if (summary) {
+        process.stderr.write(`${summary}\n`);
+      }
+
+      return yield* new BuildFailedError({
+        step,
+        exitCode: code,
+        message: `${step} exited with code ${code}`,
+      });
+    }
+    return undefined;
+  });

package/src/commands/builds/compatibility-matrix.ts

@@ -0,0 +1,48 @@
+import { Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { printTable } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleBuildsCommandErrors } from "./helpers";
+
+export const compatibilityMatrixCommand = Command.make("compatibility-matrix", {}, () =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+    const result = yield* api.builds.compatibilityMatrix({
+      urlParams: { projectId },
+    });
+
+    if (result.rows.length === 0 && result.missingRuntimeVersions.length === 0) {
+      yield* Console.log("No compatibility data found.");
+      return;
+    }
+
+    if (result.rows.length > 0) {
+      yield* Console.log("Build-to-Channel Compatibility:");
+      yield* printTable(
+        ["Build ID", "Platform", "Runtime Version", "Channels"],
+        result.rows.map((row) => [
+          row.id,
+          row.platform,
+          row.runtimeVersion ?? "-",
+          row.channels.map((channel) => channel.channelName).join(", ") || "-",
+        ]),
+      );
+    }
+
+    if (result.missingRuntimeVersions.length > 0) {
+      yield* Console.log("\nMissing Runtime Versions:");
+      yield* printTable(
+        ["Channel", "Platform", "Runtime Version", "Updates"],
+        result.missingRuntimeVersions.map((missing) => [
+          missing.channelName,
+          missing.platform,
+          missing.runtimeVersion,
+          String(missing.updateCount),
+        ]),
+      );
+    }
+  }).pipe(handleBuildsCommandErrors),
+);

package/src/commands/builds/delete.ts

@@ -0,0 +1,15 @@
+import { Args, Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { apiClient } from "../../services/api-client";
+import { handleBuildsCommandErrors } from "./helpers";
+
+const id = Args.text({ name: "id" });
+
+export const deleteCommand = Command.make("delete", { id }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    yield* api.builds.delete({ path: { id: opts.id } });
+    yield* Console.log(`Build ${opts.id} deleted.`);
+  }).pipe(handleBuildsCommandErrors),
+);

package/src/commands/builds/get.ts

@@ -0,0 +1,34 @@
+import { Args, Command } from "@effect/cli";
+import { Effect } from "effect";
+
+import { printKeyValue } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleBuildsCommandErrors } from "./helpers";
+
+const id = Args.text({ name: "id" });
+
+export const getCommand = Command.make("get", { id }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const build = yield* api.builds.get({ path: { id: opts.id } });
+    yield* printKeyValue([
+      ["ID", build.id],
+      ["Platform", build.platform],
+      ["Profile", build.profile],
+      ["Distribution", build.distribution],
+      ["Version", build.appVersion ?? "-"],
+      ["Build Number", build.buildNumber ?? "-"],
+      ["Runtime Version", build.runtimeVersion ?? "-"],
+      ["Bundle ID", build.bundleId ?? "-"],
+      ["Git Ref", build.gitRef ?? "-"],
+      ["Message", build.message ?? "-"],
+      [
+        "Artifact",
+        build.artifact
+          ? `${build.artifact.format} (${String(build.artifact.byteSize)} bytes)`
+          : "none",
+      ],
+      ["Created", build.createdAt],
+    ]);
+  }).pipe(handleBuildsCommandErrors),
+);

package/src/commands/builds/helpers.ts

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

package/src/commands/builds/index.ts

@@ -0,0 +1,20 @@
+import { Command } from "@effect/cli";
+import { Console } from "effect";
+
+import { compatibilityMatrixCommand } from "./compatibility-matrix";
+import { deleteCommand } from "./delete";
+import { getCommand } from "./get";
+import { installLinkCommand } from "./install-link";
+import { listCommand } from "./list";
+
+export const buildsCommand = Command.make("builds", {}, () =>
+  Console.log("Manage builds. Run with --help for subcommands."),
+).pipe(
+  Command.withSubcommands([
+    listCommand,
+    getCommand,
+    deleteCommand,
+    installLinkCommand,
+    compatibilityMatrixCommand,
+  ]),
+);

package/src/commands/builds/install-link.ts

@@ -0,0 +1,20 @@
+import { Args, Command } from "@effect/cli";
+import { Effect } from "effect";
+
+import { printKeyValue } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleBuildsCommandErrors } from "./helpers";
+
+const id = Args.text({ name: "id" });
+
+export const installLinkCommand = Command.make("install-link", { id }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const result = yield* api.builds.getInstallLink({ path: { id: opts.id } });
+    yield* printKeyValue([
+      ["Artifact URL", result.artifactUrl],
+      ["Install URL", result.installUrl ?? "-"],
+      ["Expires", String(result.expires)],
+    ]);
+  }).pipe(handleBuildsCommandErrors),
+);

package/src/commands/builds/list.ts

@@ -0,0 +1,38 @@
+import { Command, Options } from "@effect/cli";
+import { Effect, Option } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { printTable } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleBuildsCommandErrors } from "./helpers";
+
+const platform = Options.choice("platform", ["ios", "android"]).pipe(Options.optional);
+const limit = Options.integer("limit").pipe(Options.withDefault(10));
+
+export const listCommand = Command.make("list", { platform, limit }, (opts) =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const platformFilter = Option.match(opts.platform, {
+      onNone: () => ({}) as Record<string, string>,
+      onSome: (platformValue) => ({ platform: platformValue }) as Record<string, string>,
+    });
+
+    const { items } = yield* api.builds.list({
+      urlParams: { projectId, ...platformFilter, page: 1, limit: opts.limit },
+    });
+
+    yield* printTable(
+      ["ID", "Platform", "Profile", "Distribution", "Version", "Created"],
+      items.map((build) => [
+        build.id,
+        build.platform,
+        build.profile,
+        build.distribution,
+        build.appVersion ?? "-",
+        build.createdAt,
+      ]),
+    );
+  }).pipe(handleBuildsCommandErrors),
+);

package/src/commands/channels/create.ts

@@ -0,0 +1,37 @@
+import { Command, Options } from "@effect/cli";
+import { Effect } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { printKeyValue } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleChannelCommandErrors, resolveNamedResourceId } from "./helpers";
+
+const name = Options.text("name");
+const branch = Options.text("branch");
+
+export const createCommand = Command.make("create", { name, branch }, (opts) =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const { items: branches } = yield* api.branches.list({
+      urlParams: { projectId, page: 1, limit: 1000 },
+    });
+    const branchId = yield* resolveNamedResourceId({
+      items: branches,
+      kind: "Branch",
+      name: opts.branch,
+    });
+
+    const channel = yield* api.channels.create({
+      payload: { projectId, name: opts.name, branchId },
+    });
+
+    yield* printKeyValue([
+      ["ID", channel.id],
+      ["Name", channel.name],
+      ["Branch", opts.branch],
+      ["Created", channel.createdAt],
+    ]);
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/channels/delete.ts

@@ -0,0 +1,15 @@
+import { Args, Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { apiClient } from "../../services/api-client";
+import { handleChannelCommandErrors } from "./helpers";
+
+const id = Args.text({ name: "id" });
+
+export const deleteCommand = Command.make("delete", { id }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    yield* api.channels.delete({ path: { id: opts.id } });
+    yield* Console.log(`Channel ${opts.id} deleted.`);
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/channels/helpers.ts

@@ -0,0 +1,18 @@
+import { Data } from "effect";
+
+import { makeCommandErrorHandler } from "../../lib/command-errors";
+import { resolveNamedResourceId as resolveNamedResourceIdBase } from "../../lib/resolve-named-resource";
+
+export class ChannelCommandError extends Data.TaggedError("ChannelCommandError")<{
+  readonly message: string;
+}> {}
+
+export const handleChannelCommandErrors = makeCommandErrorHandler({
+  ChannelCommandError: 2,
+});
+
+export const resolveNamedResourceId = (params: {
+  readonly items: readonly { readonly id: string; readonly name: string }[];
+  readonly kind: string;
+  readonly name: string;
+}) => resolveNamedResourceIdBase(params, (message) => new ChannelCommandError({ message }));

package/src/commands/channels/index.ts

@@ -0,0 +1,24 @@
+import { Command } from "@effect/cli";
+import { Console } from "effect";
+
+import { createCommand } from "./create";
+import { deleteCommand } from "./delete";
+import { listCommand } from "./list";
+import { pauseCommand } from "./pause";
+import { resumeCommand } from "./resume";
+import { rolloutCommand } from "./rollout";
+import { updateCommand } from "./update";
+
+export const channelsCommand = Command.make("channels", {}, () =>
+  Console.log("Manage channels. Run with --help for subcommands."),
+).pipe(
+  Command.withSubcommands([
+    listCommand,
+    createCommand,
+    updateCommand,
+    pauseCommand,
+    resumeCommand,
+    deleteCommand,
+    rolloutCommand,
+  ]),
+);

package/src/commands/channels/list.ts

@@ -0,0 +1,38 @@
+import { Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { printTable } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleChannelCommandErrors } from "./helpers";
+
+export const listCommand = Command.make("list", {}, () =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const [{ items }, { items: branches }] = yield* Effect.all([
+      api.channels.list({ urlParams: { projectId, page: 1, limit: 1000 } }),
+      api.branches.list({ urlParams: { projectId, page: 1, limit: 1000 } }),
+    ]);
+
+    if (items.length === 0) {
+      yield* Console.log("No channels found.");
+      return;
+    }
+
+    const branchNames = new Map(branches.map((branch) => [branch.id, branch.name]));
+
+    yield* printTable(
+      ["ID", "Name", "Branch", "Paused", "Rollout", "Created"],
+      items.map((channel) => [
+        channel.id,
+        channel.name,
+        branchNames.get(channel.branchId) ?? channel.branchId,
+        channel.isPaused ? "yes" : "no",
+        channel.branchMappingJson === null ? "-" : "active",
+        channel.createdAt,
+      ]),
+    );
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/channels/pause.ts

@@ -0,0 +1,15 @@
+import { Args, Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { apiClient } from "../../services/api-client";
+import { handleChannelCommandErrors } from "./helpers";
+
+const id = Args.text({ name: "id" });
+
+export const pauseCommand = Command.make("pause", { id }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const channel = yield* api.channels.pause({ path: { id: opts.id } });
+    yield* Console.log(`Channel "${channel.name}" paused.`);
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/channels/resume.ts

@@ -0,0 +1,15 @@
+import { Args, Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { apiClient } from "../../services/api-client";
+import { handleChannelCommandErrors } from "./helpers";
+
+const id = Args.text({ name: "id" });
+
+export const resumeCommand = Command.make("resume", { id }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const channel = yield* api.channels.resume({ path: { id: opts.id } });
+    yield* Console.log(`Channel "${channel.name}" resumed.`);
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/channels/rollout/complete.ts

@@ -0,0 +1,17 @@
+import { Args, Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { apiClient } from "../../../services/api-client";
+import { handleChannelCommandErrors } from "../helpers";
+
+const channelId = Args.text({ name: "channelId" });
+
+export const completeCommand = Command.make("complete", { channelId }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const channel = yield* api.channels.completeBranchRollout({
+      path: { id: opts.channelId },
+    });
+    yield* Console.log(`Completed rollout on channel "${channel.name}".`);
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/channels/rollout/create.ts

@@ -0,0 +1,36 @@
+import { Args, Command, Options } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../../../lib/app-json";
+import { rolloutPercentageOption } from "../../../lib/cli-schemas";
+import { apiClient } from "../../../services/api-client";
+import { handleChannelCommandErrors, resolveNamedResourceId } from "../helpers";
+
+const channelId = Args.text({ name: "channelId" });
+const branch = Options.text("branch");
+const percentage = rolloutPercentageOption("percentage");
+
+export const createCommand = Command.make("create", { channelId, branch, percentage }, (opts) =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const { items: branches } = yield* api.branches.list({
+      urlParams: { projectId, page: 1, limit: 1000 },
+    });
+    const newBranchId = yield* resolveNamedResourceId({
+      items: branches,
+      kind: "Branch",
+      name: opts.branch,
+    });
+
+    const channel = yield* api.channels.createBranchRollout({
+      path: { id: opts.channelId },
+      payload: { newBranchId, percentage: opts.percentage },
+    });
+
+    yield* Console.log(
+      `Started rollout on channel "${channel.name}" to branch "${opts.branch}" at ${String(opts.percentage)}%.`,
+    );
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/channels/rollout/index.ts

@@ -0,0 +1,11 @@
+import { Command } from "@effect/cli";
+import { Console } from "effect";
+
+import { completeCommand } from "./complete";
+import { createCommand } from "./create";
+import { revertCommand } from "./revert";
+import { updateCommand } from "./update";
+
+export const rolloutCommand = Command.make("rollout", {}, () =>
+  Console.log("Manage channel branch rollouts. Run with --help for subcommands."),
+).pipe(Command.withSubcommands([createCommand, updateCommand, completeCommand, revertCommand]));

package/src/commands/channels/rollout/revert.ts

@@ -0,0 +1,17 @@
+import { Args, Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { apiClient } from "../../../services/api-client";
+import { handleChannelCommandErrors } from "../helpers";
+
+const channelId = Args.text({ name: "channelId" });
+
+export const revertCommand = Command.make("revert", { channelId }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const channel = yield* api.channels.revertBranchRollout({
+      path: { id: opts.channelId },
+    });
+    yield* Console.log(`Reverted rollout on channel "${channel.name}".`);
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/channels/rollout/update.ts

@@ -0,0 +1,23 @@
+import { Args, Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { rolloutPercentageOption } from "../../../lib/cli-schemas";
+import { apiClient } from "../../../services/api-client";
+import { handleChannelCommandErrors } from "../helpers";
+
+const channelId = Args.text({ name: "channelId" });
+const percentage = rolloutPercentageOption("percentage");
+
+export const updateCommand = Command.make("update", { channelId, percentage }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const channel = yield* api.channels.updateBranchRollout({
+      path: { id: opts.channelId },
+      payload: { percentage: opts.percentage },
+    });
+
+    yield* Console.log(
+      `Updated rollout on channel "${channel.name}" to ${String(opts.percentage)}%.`,
+    );
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/channels/update.ts

@@ -0,0 +1,32 @@
+import { Args, Command, Options } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { apiClient } from "../../services/api-client";
+import { handleChannelCommandErrors, resolveNamedResourceId } from "./helpers";
+
+const id = Args.text({ name: "id" });
+const branch = Options.text("branch");
+
+export const updateCommand = Command.make("update", { id, branch }, (opts) =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const { items: branches } = yield* api.branches.list({
+      urlParams: { projectId, page: 1, limit: 1000 },
+    });
+    const branchId = yield* resolveNamedResourceId({
+      items: branches,
+      kind: "Branch",
+      name: opts.branch,
+    });
+
+    const channel = yield* api.channels.update({
+      path: { id: opts.id },
+      payload: { branchId },
+    });
+
+    yield* Console.log(`Channel "${channel.name}" relinked to branch "${opts.branch}".`);
+  }).pipe(handleChannelCommandErrors),
+);

package/src/commands/credentials/delete.ts

@@ -0,0 +1,24 @@
+import { Args, Command, Options } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { deleteCredential } from "../../lib/credentials-manager";
+import { apiClient } from "../../services/api-client";
+
+const id = Args.text({ name: "id" });
+const platform = Options.choice("platform", ["ios", "android"] as const);
+const type = Options.choice("type", [
+  "distribution-certificate",
+  "provisioning-profile",
+  "push-key",
+  "asc-api-key",
+  "keystore",
+  "google-service-account-key",
+] as const);
+
+export const deleteCommand = Command.make("delete", { id, platform, type }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    yield* deleteCredential(api, { id: opts.id, platform: opts.platform, type: opts.type });
+    yield* Console.log(`Credential ${opts.id} deleted.`);
+  }),
+);

package/src/commands/credentials/index.ts

@@ -0,0 +1,10 @@
+import { Command } from "@effect/cli";
+import { Console } from "effect";
+
+import { deleteCommand } from "./delete";
+import { listCommand } from "./list";
+import { uploadCommand } from "./upload";
+
+export const credentialsCommand = Command.make("credentials", {}, () =>
+  Console.log("Manage credentials. Run with --help for subcommands."),
+).pipe(Command.withSubcommands([listCommand, uploadCommand, deleteCommand]));