@better-update/cli 0.3.0

package/src/commands/credentials/list.ts

@@ -0,0 +1,33 @@
+import { Command, Options } from "@effect/cli";
+import { Console, Effect, Option } from "effect";
+
+import { filterCredentials, listAllCredentials } from "../../lib/credentials-manager";
+import { printTable } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+
+const platform = Options.choice("platform", ["ios", "android"] as const).pipe(Options.optional);
+
+export const listCommand = Command.make("list", { platform }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const rows = yield* listAllCredentials(api);
+
+    const filtered = filterCredentials(
+      rows,
+      Option.match(opts.platform, {
+        onNone: () => ({}),
+        onSome: (platformValue) => ({ platform: platformValue }),
+      }),
+    );
+
+    if (filtered.length === 0) {
+      yield* Console.log("No credentials found.");
+      return;
+    }
+
+    yield* printTable(
+      ["ID", "Name", "Platform", "Type", "Distribution"],
+      filtered.map((row) => [row.id, row.name, row.platform, row.type, row.distribution ?? "-"]),
+    );
+  }),
+);

package/src/commands/credentials/upload.ts

@@ -0,0 +1,91 @@
+import { Command, Options } from "@effect/cli";
+import { Console, Effect, Option } from "effect";
+
+import { uploadCredential } from "../../lib/credentials-manager";
+import { printKeyValue } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+
+import type { CliCredentialType } from "../../lib/credentials-manager";
+
+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);
+const name = Options.text("name");
+const file = Options.text("file");
+
+const password = Options.text("password").pipe(Options.optional);
+const keyAlias = Options.text("key-alias").pipe(Options.optional);
+const keyPassword = Options.text("key-password").pipe(Options.optional);
+const keyId = Options.text("key-id").pipe(Options.optional);
+const issuerId = Options.text("issuer-id").pipe(Options.optional);
+const appleTeamIdentifier = Options.text("apple-team-identifier").pipe(Options.optional);
+
+export const uploadCommand = Command.make(
+  "upload",
+  {
+    platform,
+    type,
+    name,
+    file,
+    password,
+    keyAlias,
+    keyPassword,
+    keyId,
+    issuerId,
+    appleTeamIdentifier,
+  },
+  (opts) =>
+    Effect.gen(function* () {
+      const api = yield* apiClient;
+
+      const passwordOpt = Option.getOrUndefined(opts.password);
+      const keyAliasOpt = Option.getOrUndefined(opts.keyAlias);
+      const keyPasswordOpt = Option.getOrUndefined(opts.keyPassword);
+      const keyIdOpt = Option.getOrUndefined(opts.keyId);
+      const issuerIdOpt = Option.getOrUndefined(opts.issuerId);
+      const appleTeamIdentifierOpt = Option.getOrUndefined(opts.appleTeamIdentifier);
+
+      const input: {
+        readonly platform: typeof opts.platform;
+        readonly type: CliCredentialType;
+        readonly name: string;
+        readonly filePath: string;
+        readonly password?: string;
+        readonly keyAlias?: string;
+        readonly keyPassword?: string;
+        readonly keyId?: string;
+        readonly issuerId?: string;
+        readonly appleTeamIdentifier?: string;
+      } = {
+        platform: opts.platform,
+        type: opts.type,
+        name: opts.name,
+        filePath: opts.file,
+        ...(passwordOpt === undefined ? {} : { password: passwordOpt }),
+        ...(keyAliasOpt === undefined ? {} : { keyAlias: keyAliasOpt }),
+        ...(keyPasswordOpt === undefined ? {} : { keyPassword: keyPasswordOpt }),
+        ...(keyIdOpt === undefined ? {} : { keyId: keyIdOpt }),
+        ...(issuerIdOpt === undefined ? {} : { issuerId: issuerIdOpt }),
+        ...(appleTeamIdentifierOpt === undefined
+          ? {}
+          : { appleTeamIdentifier: appleTeamIdentifierOpt }),
+      };
+
+      const credential = yield* uploadCredential(api, input);
+
+      yield* Console.log("Credential uploaded successfully.");
+      yield* Console.log("");
+      yield* printKeyValue([
+        ["ID", credential.id],
+        ["Name", credential.name],
+        ["Platform", credential.platform],
+        ["Type", credential.type],
+      ]);
+    }),
+);

package/src/commands/env/delete.ts

@@ -0,0 +1,35 @@
+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 { EnvResourceNotFoundError, handleEnvCommandErrors } from "./helpers";
+
+const keyArg = Args.text({ name: "KEY" });
+const environmentOption = Options.text("environment").pipe(Options.withDefault("production"));
+
+export const deleteCommand = Command.make(
+  "delete",
+  { key: keyArg, environment: environmentOption },
+  ({ key, environment }) =>
+    Effect.gen(function* () {
+      const projectId = yield* readProjectId;
+      const api = yield* apiClient;
+
+      const existing = yield* api["env-vars"].list({
+        urlParams: { projectId, environment },
+      });
+
+      const match = existing.items.find((item) => item.key === key);
+
+      if (!match) {
+        return yield* new EnvResourceNotFoundError({
+          message: `Environment variable ${key} not found in ${environment}`,
+        });
+      }
+
+      yield* api["env-vars"].delete({ path: { id: match.id } });
+      yield* Console.log(`Deleted ${key} from ${environment}`);
+      return undefined;
+    }).pipe(handleEnvCommandErrors),
+);

package/src/commands/env/export.ts

@@ -0,0 +1,27 @@
+import { Command, Options } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { apiClient } from "../../services/api-client";
+import { handleEnvCommandErrors } from "./helpers";
+
+const environmentOption = Options.text("environment").pipe(Options.withDefault("production"));
+
+export const exportCommand = Command.make(
+  "export",
+  { environment: environmentOption },
+  ({ environment }) =>
+    Effect.gen(function* () {
+      const projectId = yield* readProjectId;
+      const api = yield* apiClient;
+
+      const result = yield* api["env-vars"].export({
+        urlParams: { projectId, environment },
+      });
+
+      for (const item of result.items) {
+        const escaped = item.value.replaceAll("'", String.raw`'\''`);
+        yield* Console.log(`${item.key}='${escaped}'`);
+      }
+    }).pipe(handleEnvCommandErrors),
+);

package/src/commands/env/get.ts

@@ -0,0 +1,25 @@
+import { Args, Command } from "@effect/cli";
+import { Effect } from "effect";
+
+import { printKeyValue } from "../../lib/output";
+import { apiClient } from "../../services/api-client";
+import { handleEnvCommandErrors } from "./helpers";
+
+const id = Args.text({ name: "id" });
+
+export const getCommand = Command.make("get", { id }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const envVar = yield* api["env-vars"].get({ path: { id: opts.id } });
+    yield* printKeyValue([
+      ["ID", envVar.id],
+      ["Key", envVar.key],
+      ["Environment", envVar.environment],
+      ["Visibility", envVar.visibility],
+      // eslint-disable-next-line eslint-js/no-restricted-syntax -- EnvVar.value nullable at storage; display empty when absent
+      ["Value", envVar.visibility === "plaintext" ? (envVar.value ?? "") : "******"],
+      ["Created", envVar.createdAt],
+      ["Updated", envVar.updatedAt],
+    ]);
+  }).pipe(handleEnvCommandErrors),
+);

package/src/commands/env/helpers.ts

@@ -0,0 +1,13 @@
+import { Data } from "effect";
+
+import { makeCommandErrorHandler } from "../../lib/command-errors";
+
+export class EnvResourceNotFoundError extends Data.TaggedError("EnvResourceNotFoundError")<{
+  readonly message: string;
+}> {}
+
+export const handleEnvCommandErrors = makeCommandErrorHandler({
+  EnvResourceNotFoundError: 1,
+  SystemError: 6,
+  BadArgument: 6,
+});

package/src/commands/env/import.ts

@@ -0,0 +1,31 @@
+import { Args, Command, Options } from "@effect/cli";
+import { FileSystem } from "@effect/platform";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { apiClient } from "../../services/api-client";
+import { handleEnvCommandErrors } from "./helpers";
+
+const fileArg = Args.text({ name: "file" });
+const environmentOption = Options.text("environment").pipe(Options.withDefault("production"));
+
+export const importCommand = Command.make(
+  "import",
+  { file: fileArg, environment: environmentOption },
+  ({ file, environment }) =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const content = yield* fs.readFileString(file);
+
+      const projectId = yield* readProjectId;
+      const api = yield* apiClient;
+
+      const result = yield* api["env-vars"].bulkImport({
+        payload: { projectId, environment, content, visibility: "plaintext" },
+      });
+
+      yield* Console.log(
+        `Imported: ${String(result.created)} created, ${String(result.updated)} updated, ${String(result.skipped)} skipped`,
+      );
+    }).pipe(handleEnvCommandErrors),
+);

package/src/commands/env/index.ts

@@ -0,0 +1,24 @@
+import { Command } from "@effect/cli";
+import { Console } from "effect";
+
+import { deleteCommand } from "./delete";
+import { exportCommand } from "./export";
+import { getCommand } from "./get";
+import { importCommand } from "./import";
+import { listCommand } from "./list";
+import { pullCommand } from "./pull";
+import { setCommand } from "./set";
+
+export const envCommand = Command.make("env", {}, () =>
+  Console.log("Manage environment variables. Run with --help for subcommands."),
+).pipe(
+  Command.withSubcommands([
+    listCommand,
+    getCommand,
+    setCommand,
+    deleteCommand,
+    importCommand,
+    exportCommand,
+    pullCommand,
+  ]),
+);

package/src/commands/env/list.ts

@@ -0,0 +1,44 @@
+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 { handleEnvCommandErrors } from "./helpers";
+
+const environmentOption = Options.text("environment").pipe(Options.optional);
+
+export const listCommand = Command.make(
+  "list",
+  { environment: environmentOption },
+  ({ environment }) =>
+    Effect.gen(function* () {
+      const projectId = yield* readProjectId;
+      const api = yield* apiClient;
+
+      const envFilter = Option.match(environment, {
+        onNone: () => ({}),
+        onSome: (value) => ({ environment: value }),
+      });
+
+      const result = yield* api["env-vars"].list({
+        urlParams: { projectId, ...envFilter },
+      });
+
+      if (result.items.length === 0) {
+        yield* Console.log("No environment variables found.");
+        return;
+      }
+
+      yield* printTable(
+        ["Key", "Environment", "Visibility", "Value"],
+        result.items.map((item) => [
+          item.key,
+          item.environment,
+          item.visibility,
+          // eslint-disable-next-line eslint-js/no-restricted-syntax -- EnvVar.value nullable at storage; display empty when absent
+          item.visibility === "plaintext" ? (item.value ?? "") : "••••••",
+        ]),
+      );
+    }).pipe(handleEnvCommandErrors),
+);

package/src/commands/env/pull.ts

@@ -0,0 +1,27 @@
+import { Command, Options } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { apiClient } from "../../services/api-client";
+import { handleEnvCommandErrors } from "./helpers";
+
+const environmentOption = Options.text("environment").pipe(Options.withDefault("production"));
+
+export const pullCommand = Command.make(
+  "pull",
+  { environment: environmentOption },
+  ({ environment }) =>
+    Effect.gen(function* () {
+      const projectId = yield* readProjectId;
+      const api = yield* apiClient;
+
+      const result = yield* api["env-vars"].export({
+        urlParams: { projectId, environment },
+      });
+
+      for (const item of result.items) {
+        const escaped = item.value.replaceAll("'", String.raw`'\''`);
+        yield* Console.log(`export ${item.key}='${escaped}'`);
+      }
+    }).pipe(handleEnvCommandErrors),
+);

package/src/commands/env/set.ts

@@ -0,0 +1,42 @@
+import { Command, Options } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../../lib/app-json";
+import { keyValueArg } from "../../lib/cli-schemas";
+import { apiClient } from "../../services/api-client";
+import { handleEnvCommandErrors } from "./helpers";
+
+const keyValue = keyValueArg("KEY=VALUE");
+const environmentOption = Options.text("environment").pipe(Options.withDefault("production"));
+const visibilityOption = Options.choice("visibility", ["plaintext", "sensitive", "secret"]).pipe(
+  Options.withDefault("plaintext" as const),
+);
+
+export const setCommand = Command.make(
+  "set",
+  { keyValue, environment: environmentOption, visibility: visibilityOption },
+  ({ keyValue: { key, value }, environment, visibility }) =>
+    Effect.gen(function* () {
+      const projectId = yield* readProjectId;
+      const api = yield* apiClient;
+
+      const existing = yield* api["env-vars"].list({
+        urlParams: { projectId, environment },
+      });
+
+      const match = existing.items.find((item) => item.key === key);
+
+      if (match) {
+        yield* api["env-vars"].update({
+          path: { id: match.id },
+          payload: { value, visibility },
+        });
+        yield* Console.log(`Updated ${key} in ${environment}`);
+      } else {
+        yield* api["env-vars"].create({
+          payload: { projectId, environment, key, value, visibility },
+        });
+        yield* Console.log(`Created ${key} in ${environment}`);
+      }
+    }).pipe(handleEnvCommandErrors),
+);

package/src/commands/fingerprint/compare.ts

@@ -0,0 +1,25 @@
+import { Args, Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { exitWith } from "../../application/command-exit";
+import { runFingerprintFull } from "../../lib/fingerprint";
+import { CliRuntime } from "../../services/cli-runtime";
+
+const hash = Args.text({ name: "hash" });
+
+export const compareCommand = Command.make("compare", { hash }, (opts) =>
+  Effect.gen(function* () {
+    const runtime = yield* CliRuntime;
+    const projectRoot = yield* runtime.cwd;
+    const result = yield* runFingerprintFull(projectRoot);
+
+    if (result.hash === opts.hash) {
+      yield* Console.log("Fingerprints match.");
+      return undefined;
+    }
+    yield* Console.log("Fingerprints differ.");
+    yield* Console.log(`  Local:    ${result.hash}`);
+    yield* Console.log(`  Provided: ${opts.hash}`);
+    return yield* exitWith(1, "Fingerprint mismatch");
+  }).pipe(Effect.catchTag("FingerprintError", (error) => exitWith(2, error.message))),
+);

package/src/commands/fingerprint/generate.ts

@@ -0,0 +1,18 @@
+import { Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { exitWith } from "../../application/command-exit";
+import { runFingerprintFull } from "../../lib/fingerprint";
+import { CliRuntime } from "../../services/cli-runtime";
+
+export const generateCommand = Command.make("generate", {}, () =>
+  Effect.gen(function* () {
+    const runtime = yield* CliRuntime;
+    const projectRoot = yield* runtime.cwd;
+    const result = yield* runFingerprintFull(projectRoot);
+    yield* Console.log(result.hash);
+    if (result.sources.length > 0) {
+      yield* Console.log(`${result.sources.length} sources`);
+    }
+  }).pipe(Effect.catchTag("FingerprintError", (error) => exitWith(2, error.message))),
+);

package/src/commands/fingerprint/index.ts

@@ -0,0 +1,9 @@
+import { Command } from "@effect/cli";
+import { Console } from "effect";
+
+import { compareCommand } from "./compare";
+import { generateCommand } from "./generate";
+
+export const fingerprintCommand = Command.make("fingerprint", {}, () =>
+  Console.log("Fingerprint utilities. Use --help for subcommands."),
+).pipe(Command.withSubcommands([generateCommand, compareCommand]));

package/src/commands/init.ts

@@ -0,0 +1,35 @@
+import { Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readAppJson, readSlug, writeProjectId } from "../lib/app-json";
+import { asString } from "../lib/build-profile";
+import { asRecord } from "../lib/record";
+import { apiClient } from "../services/api-client";
+
+export const initCommand = Command.make("init", {}, () =>
+  Effect.gen(function* () {
+    const appJson = yield* readAppJson;
+    const expo = asRecord(appJson["expo"]);
+    const name = asString(expo?.["name"]) ?? asString(expo?.["slug"]) ?? "untitled";
+    const slug = yield* readSlug;
+
+    yield* Console.log(`Linking project: ${name} (${slug})`);
+
+    const api = yield* apiClient;
+    const { items } = yield* api.projects.list({ urlParams: { page: 1, limit: 100 } });
+
+    const existing = items.find((project) => project.slug === slug);
+
+    if (existing) {
+      yield* Console.log(`Found existing project: ${existing.name} (${existing.id})`);
+      yield* writeProjectId(existing.id);
+    } else {
+      yield* Console.log("No existing project found. Creating new project...");
+      const project = yield* api.projects.create({ payload: { name, slug } });
+      yield* Console.log(`Created project: ${project.name} (${project.id})`);
+      yield* writeProjectId(project.id);
+    }
+
+    yield* Console.log("Project linked successfully. ID saved to app.json.");
+  }),
+);

package/src/commands/login.ts

@@ -0,0 +1,13 @@
+import { Command as CliCommand, Options } from "@effect/cli";
+import { Cause, Effect } from "effect";
+
+import { exitWith } from "../application/command-exit";
+import { runLogin } from "../application/login";
+
+const manualApiKey = Options.boolean("api-key");
+
+const loginFailed = (cause: Cause.Cause<unknown>) => exitWith(1, Cause.pretty(cause));
+
+export const loginCommand = CliCommand.make("login", { manualApiKey }, (opts) =>
+  runLogin({ manualApiKey: opts.manualApiKey }).pipe(Effect.catchAllCause(loginFailed)),
+);

package/src/commands/logout.ts

@@ -0,0 +1,12 @@
+import { Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { AuthStore } from "../services/auth-store";
+
+export const logoutCommand = Command.make("logout", {}, () =>
+  Effect.gen(function* () {
+    const authStore = yield* AuthStore;
+    yield* authStore.clearToken;
+    yield* Console.log("Logged out. Auth token removed.");
+  }),
+);

package/src/commands/projects.ts

@@ -0,0 +1,84 @@
+import { Args, Command, Options } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+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 slugOption = Options.text("slug");
+
+const listCommand = Command.make("list", {}, () =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const { items } = yield* api.projects.list({
+      urlParams: { page: 1, limit: 1000 },
+    });
+
+    if (items.length === 0) {
+      yield* Console.log("No projects found.");
+      return;
+    }
+
+    yield* printTable(
+      ["ID", "Name", "Slug", "Created"],
+      items.map((project) => [project.id, project.name, project.slug, project.createdAt]),
+    );
+  }).pipe(handleErrors),
+);
+
+const createCommand = Command.make("create", { name: nameOption, slug: slugOption }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const project = yield* api.projects.create({
+      payload: { name: opts.name, slug: opts.slug },
+    });
+    yield* printKeyValue([
+      ["ID", project.id],
+      ["Name", project.name],
+      ["Slug", project.slug],
+      ["Created", project.createdAt],
+    ]);
+  }).pipe(handleErrors),
+);
+
+const getCommand = Command.make("get", { id: idArg }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const project = yield* api.projects.get({ path: { id: opts.id } });
+    yield* printKeyValue([
+      ["ID", project.id],
+      ["Name", project.name],
+      ["Slug", project.slug],
+      ["Created", project.createdAt],
+    ]);
+  }).pipe(handleErrors),
+);
+
+const renameCommand = Command.make("rename", { id: idArg, name: nameOption }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const project = yield* api.projects.rename({
+      path: { id: opts.id },
+      payload: { name: opts.name },
+    });
+    yield* Console.log(`Project renamed to "${project.name}".`);
+  }).pipe(handleErrors),
+);
+
+const deleteCommand = Command.make("delete", { id: idArg }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    yield* api.projects.delete({ path: { id: opts.id } });
+    yield* Console.log(`Project ${opts.id} deleted.`);
+  }).pipe(handleErrors),
+);
+
+export const projectsCommand = Command.make("projects", {}, () =>
+  Console.log("Manage projects. Run with --help for subcommands."),
+).pipe(
+  Command.withSubcommands([listCommand, createCommand, getCommand, renameCommand, deleteCommand]),
+);

package/src/commands/status.ts

@@ -0,0 +1,48 @@
+import { Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { readProjectId } from "../lib/app-json";
+import { listAllCredentials } from "../lib/credentials-manager";
+import { printKeyValue } from "../lib/output";
+import { apiClient } from "../services/api-client";
+
+export const statusCommand = Command.make("status", {}, () =>
+  Effect.gen(function* () {
+    const projectId = yield* readProjectId;
+    const api = yield* apiClient;
+
+    const { project, credentials, builds } = yield* Effect.all(
+      {
+        project: api.projects.get({ path: { id: projectId } }),
+        credentials: listAllCredentials(api),
+        builds: api.builds.list({ urlParams: { projectId } }),
+      },
+      { concurrency: "unbounded" },
+    );
+
+    yield* Console.log("Project");
+    yield* Console.log("-------");
+    yield* printKeyValue([
+      ["Name", project.name],
+      ["ID", project.id],
+      ["Slug", project.slug],
+      ["Created", project.createdAt],
+    ]);
+
+    yield* Console.log("");
+    yield* Console.log("Credentials");
+    yield* Console.log("-----------");
+    const iosCreds = credentials.filter((cred) => cred.platform === "ios").length;
+    const androidCreds = credentials.filter((cred) => cred.platform === "android").length;
+    yield* printKeyValue([
+      ["iOS", String(iosCreds)],
+      ["Android", String(androidCreds)],
+      ["Total", String(credentials.length)],
+    ]);
+
+    yield* Console.log("");
+    yield* Console.log("Builds");
+    yield* Console.log("------");
+    yield* printKeyValue([["Total", String(builds.total)]]);
+  }),
+);

package/src/commands/update/delete.ts

@@ -0,0 +1,15 @@
+import { Args, Command } from "@effect/cli";
+import { Console, Effect } from "effect";
+
+import { apiClient } from "../../services/api-client";
+import { handleUpdateCommandErrors } from "./helpers";
+
+const groupId = Args.text({ name: "groupId" });
+
+export const deleteCommand = Command.make("delete", { groupId }, (opts) =>
+  Effect.gen(function* () {
+    const api = yield* apiClient;
+    const result = yield* api.updates.deleteGroup({ path: { groupId: opts.groupId } });
+    yield* Console.log(`Deleted ${String(result.deleted)} update(s) from group ${opts.groupId}.`);
+  }).pipe(handleUpdateCommandErrors),
+);