@htgabriel/release-kit 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,2900 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/exec/run.ts
+var run_exports = {};
+__export(run_exports, {
+  ReleaseKitError: () => ReleaseKitError,
+  defaultRun: () => defaultRun,
+  fail: () => fail,
+  formatCommand: () => formatCommand,
+  requireSuccess: () => requireSuccess
+});
+import crossSpawn from "cross-spawn";
+function fail(message, code = 1) {
+  throw new ReleaseKitError(message, { code });
+}
+function formatCommand(command, args, env = {}) {
+  const exported = Object.entries(env).filter(([key, value]) => value !== void 0 && (key === "APP_VARIANT" || key.startsWith("EAS_"))).map(([key, value]) => `${key}=${value}`).join(" ");
+  const body = [command, ...args].join(" ");
+  return exported ? `${exported} ${body}` : body;
+}
+function requireSuccess(result, label) {
+  if (result.dryRun) return result;
+  if (result.status === 0) return result;
+  const how = result.signal ? `sinal ${result.signal}` : `exit ${result.status}`;
+  const detail = (result.stderr || result.stdout || result.error?.message || "").trim();
+  fail(`${label} falhou (${how}).${detail ? `
+${detail}` : ""}`);
+}
+var ReleaseKitError, defaultRun;
+var init_run = __esm({
+  "src/exec/run.ts"() {
+    "use strict";
+    ReleaseKitError = class extends Error {
+      code;
+      constructor(message, { code = 1 } = {}) {
+        super(message);
+        this.name = "ReleaseKitError";
+        this.code = code;
+      }
+    };
+    defaultRun = (command, args, { cwd, env, inherit = false, dryRun = false } = {}) => {
+      const extraEnv = env ?? {};
+      if (dryRun) {
+        return {
+          status: 0,
+          signal: null,
+          stdout: "",
+          stderr: "",
+          dryRun: true,
+          printed: formatCommand(command, args, extraEnv)
+        };
+      }
+      const result = crossSpawn.sync(command, args, {
+        cwd,
+        env: { ...process.env, ...extraEnv },
+        encoding: "utf8",
+        stdio: inherit ? "inherit" : "pipe",
+        maxBuffer: 32 * 1024 * 1024
+      });
+      return {
+        status: result.status ?? 1,
+        signal: result.signal ?? null,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        error: result.error
+      };
+    };
+  }
+});
+
+// src/env/store.ts
+var store_exports = {};
+__export(store_exports, {
+  ENV_FILENAME: () => ENV_FILENAME,
+  credentialsDir: () => credentialsDir,
+  envPath: () => envPath,
+  materializeSecretContent: () => materializeSecretContent,
+  readEnvFile: () => readEnvFile,
+  resolveFileCredential: () => resolveFileCredential,
+  storeCredentialFile: () => storeCredentialFile,
+  writeEnvFile: () => writeEnvFile
+});
+import { chmodSync, copyFileSync, existsSync as existsSync3, mkdirSync, mkdtempSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir, tmpdir } from "os";
+import { basename, join as join3 } from "path";
+import dotenv from "dotenv";
+function envPath(repoRoot) {
+  return join3(repoRoot, ENV_FILENAME);
+}
+function readEnvFile(repoRoot) {
+  const path = envPath(repoRoot);
+  if (!existsSync3(path)) return {};
+  return dotenv.parse(readFileSync3(path, "utf8"));
+}
+function writeEnvFile(repoRoot, updates) {
+  const current = readEnvFile(repoRoot);
+  const merged = { ...current };
+  for (const [key, value] of Object.entries(updates)) {
+    if (value === void 0) continue;
+    merged[key] = value;
+  }
+  const body = Object.entries(merged).map(([key, value]) => `${key}=${escapeEnvValue(value)}`).join("\n");
+  const path = envPath(repoRoot);
+  writeFileSync2(path, `${body}
+`);
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+  return path;
+}
+function escapeEnvValue(value) {
+  if (/[\s#"'$]/.test(value)) return `"${value.replace(/"/g, '\\"')}"`;
+  return value;
+}
+function credentialsDir(slug) {
+  return join3(homedir(), ".release-kit", slug);
+}
+function storeCredentialFile(slug, sourcePath, filename) {
+  const dir = credentialsDir(slug);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const destName = filename ?? basename(sourcePath);
+  const dest = join3(dir, destName);
+  copyFileSync(sourcePath, dest);
+  try {
+    chmodSync(dest, 384);
+  } catch {
+  }
+  return dest;
+}
+function materializeSecretContent(content, filename) {
+  const dir = mkdtempSync(join3(tmpdir(), "release-kit-"));
+  const path = join3(dir, filename);
+  writeFileSync2(path, content);
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+  return {
+    path,
+    cleanup: () => rmSync(dir, { recursive: true, force: true })
+  };
+}
+function resolveFileCredential(env, pathKey, contentKey, filename) {
+  const directPath = env[pathKey];
+  if (directPath) return { path: directPath, cleanup: () => {
+  } };
+  const content = env[contentKey];
+  if (content) return materializeSecretContent(content, filename);
+  return null;
+}
+var ENV_FILENAME;
+var init_store = __esm({
+  "src/env/store.ts"() {
+    "use strict";
+    ENV_FILENAME = ".env.release";
+  }
+});
+
+// src/cli/parse.ts
+import { parseArgs } from "util";
+function parseCliArgs(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    strict: true,
+    options: {
+      channel: { type: "string" },
+      platform: { type: "string" },
+      version: { type: "string" },
+      push: { type: "boolean" },
+      edit: { type: "boolean" },
+      "skip-editor": { type: "boolean" },
+      cloud: { type: "boolean" },
+      output: { type: "string" },
+      latest: { type: "boolean" },
+      path: { type: "string" },
+      to: { type: "string" },
+      message: { type: "string" },
+      deep: { type: "boolean" },
+      "build-id": { type: "string" },
+      "skip-doctor": { type: "boolean" },
+      "allow-toolchain-drift": { type: "boolean" },
+      "i-know-this-is-production": { type: "boolean" },
+      "confirm-version": { type: "string" },
+      "dry-run": { type: "boolean" },
+      json: { type: "boolean" },
+      verbose: { type: "boolean" },
+      yes: { type: "boolean", short: "y" },
+      "non-interactive": { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  const [command, ...rest] = positionals;
+  return {
+    command,
+    positionals: rest,
+    flags: {
+      channel: values.channel,
+      platform: values.platform,
+      version: values.version,
+      push: values.push,
+      edit: values.edit,
+      skipEditor: values["skip-editor"],
+      cloud: values.cloud,
+      output: values.output,
+      latest: values.latest,
+      path: values.path,
+      to: values.to,
+      message: values.message,
+      deep: values.deep,
+      buildId: values["build-id"],
+      skipDoctor: values["skip-doctor"],
+      allowToolchainDrift: values["allow-toolchain-drift"],
+      iKnowThisIsProduction: values["i-know-this-is-production"],
+      confirmVersion: values["confirm-version"],
+      dryRun: values["dry-run"],
+      json: values.json,
+      verbose: values.verbose,
+      yes: values.yes,
+      nonInteractive: values["non-interactive"],
+      help: values.help
+    }
+  };
+}
+
+// src/cli/init.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6, resolve as resolve2 } from "path";
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/project/detect.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+var LOCKFILES = {
+  yarn: "yarn.lock",
+  pnpm: "pnpm-lock.yaml",
+  npm: "package-lock.json"
+};
+function detectPackageManager(repoRoot) {
+  for (const [pm, lockfile] of Object.entries(LOCKFILES)) {
+    if (existsSync(join(repoRoot, lockfile))) return pm;
+  }
+  return "npm";
+}
+function detectAppDir(repoRoot) {
+  if (hasExpoAppJson(repoRoot)) return ".";
+  const candidateDirs = ["apps", "packages"];
+  for (const dir of candidateDirs) {
+    const base = join(repoRoot, dir);
+    if (!existsSync(base)) continue;
+    const entries = safeReadDir(base);
+    for (const entry of entries) {
+      const candidate = join(dir, entry);
+      if (hasExpoAppJson(join(repoRoot, candidate))) return candidate;
+    }
+  }
+  return null;
+}
+function hasExpoAppJson(dir) {
+  const path = join(dir, "app.json");
+  if (!existsSync(path)) return false;
+  try {
+    const json = JSON.parse(readFileSync(path, "utf8"));
+    return typeof json.expo === "object" && json.expo !== null;
+  } catch {
+    return false;
+  }
+}
+function safeReadDir(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function readEasJson(appDir) {
+  const path = join(appDir, "eas.json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/project/expo.ts
+init_run();
+function resolveExpoConfig(ctx, env = {}) {
+  const result = ctx.run("npx", ["expo", "config", "--json"], {
+    cwd: ctx.appDir,
+    env: { ...ctx.env, ...env },
+    inherit: false
+  });
+  if (result.status !== 0) {
+    fail(`expo config --json falhou.
+${result.stderr || result.stdout}`);
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch (error) {
+    fail(`expo config --json n\xE3o devolveu JSON v\xE1lido: ${error.message}`);
+  }
+}
+
+// src/cli/resolve.ts
+import { resolve } from "path";
+import crossSpawn2 from "cross-spawn";
+
+// src/context.ts
+init_run();
+
+// src/ui/log.ts
+import pc from "picocolors";
+function createLogger(options = {}) {
+  const write = options.write ?? ((line) => console.error(line));
+  const silent = Boolean(options.json);
+  const emit = (line) => {
+    if (silent) return;
+    write(line);
+  };
+  return {
+    info: (message) => emit(message),
+    warn: (message) => emit(pc.yellow(`! ${message}`)),
+    error: (message) => emit(pc.red(`\u2717 ${message}`)),
+    success: (message) => emit(pc.green(`\u2713 ${message}`)),
+    step: (message) => emit(pc.cyan(`\u2192 ${message}`)),
+    debug: (message) => {
+      if (!options.verbose) return;
+      emit(pc.dim(message));
+    }
+  };
+}
+
+// src/context.ts
+function createContext(overrides) {
+  const env = overrides.env ?? process.env;
+  const json = Boolean(overrides.json);
+  return {
+    repoRoot: overrides.repoRoot,
+    appDir: overrides.appDir ?? overrides.repoRoot,
+    releaseDir: overrides.releaseDir ?? `${overrides.repoRoot}/.release`,
+    env,
+    dryRun: Boolean(overrides.dryRun),
+    json,
+    verbose: Boolean(overrides.verbose),
+    nonInteractive: overrides.nonInteractive ?? !process.stdin.isTTY,
+    run: overrides.run ?? defaultRun,
+    log: overrides.log ?? createLogger({ json, verbose: overrides.verbose }),
+    confirm: overrides.confirm
+  };
+}
+
+// src/config/load.ts
+init_run();
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { z as z2 } from "zod";
+
+// src/config/schema.ts
+import { z } from "zod";
+var platformSchema = z.enum(["android", "ios"]);
+var versionSourceSchema = z.enum(["app.json", "package.json"]);
+var gitPolicySchema = z.object({
+  releaseBranch: z.string().default("main"),
+  tagFormat: z.string().default("v{version}"),
+  requireClean: z.boolean().default(true),
+  requireSyncedWithRemote: z.boolean().default(true),
+  remote: z.string().default("origin")
+});
+var iosChannelSchema = z.object({
+  bundleId: z.string(),
+  ascAppId: z.string().optional(),
+  appleTeamId: z.string().optional(),
+  phasedRelease: z.boolean().default(false),
+  automaticRelease: z.boolean().default(false),
+  copyright: z.string().optional()
+});
+var androidChannelSchema = z.object({
+  package: z.string(),
+  testTrack: z.string().default("internal"),
+  productionTrack: z.string().default("production"),
+  initialRollout: z.number().min(0).max(1).default(1)
+});
+var otaSchema = z.object({
+  channel: z.string()
+});
+var channelSchema = z.object({
+  /** Canal protegido (produção): exige --i-know-this-is-production ou confirmação digitando a versão. */
+  protected: z.boolean().default(false),
+  /** Se false, o canal nunca envia à loja (ex: build local de sideload). */
+  store: z.boolean().default(true),
+  buildProfile: z.string(),
+  submitProfile: z.string().optional(),
+  /** Nome do "environment" do EAS (eas.json build.<profile>.environment) — usado nos checks de fingerprint/Sentry. */
+  easEnvironment: z.string().optional(),
+  /** Se o build profile já reusa o build number/versionCode (eas.json autoIncrement). */
+  autoIncrement: z.boolean().default(true),
+  /** Profiles com upload de sourcemap desligado (ex: SENTRY_DISABLE_AUTO_UPLOAD) não exigem token no doctor. */
+  sentryUploadDisabled: z.boolean().default(false),
+  env: z.record(z.string(), z.string()).default({}),
+  ios: iosChannelSchema.optional(),
+  android: androidChannelSchema.optional(),
+  ota: otaSchema.optional()
+});
+var toolchainBaselineSchema = z.object({
+  easCli: z.object({ min: z.string(), tested: z.string() }).optional(),
+  node: z.object({ min: z.string(), tested: z.string() }).optional(),
+  jdk: z.object({ min: z.string(), tested: z.string() }).optional(),
+  xcode: z.object({ min: z.string(), tested: z.string() }).optional(),
+  cocoapods: z.object({ min: z.string(), tested: z.string() }).optional()
+});
+var doctorConfigSchema = z.object({
+  sentry: z.boolean().default(false),
+  expoDoctor: z.boolean().default(true)
+});
+var releaseKitConfigSchema = z.object({
+  $schema: z.string().optional(),
+  appDir: z.string().default("."),
+  /** Conta/organização esperada no `eas whoami` (opcional; reforça o doctor). */
+  easOwner: z.string().optional(),
+  platforms: z.array(platformSchema).min(1),
+  locales: z.array(z.string()).min(1).default(["pt-BR"]),
+  notesDir: z.string().default("release-notes"),
+  version: z.object({ source: versionSourceSchema.default("app.json") }).default({ source: "app.json" }),
+  git: gitPolicySchema.default({}),
+  channels: z.record(z.string(), channelSchema).refine((channels) => Object.keys(channels).length > 0, {
+    message: 'defina ao menos um canal em "channels"'
+  }),
+  toolchain: toolchainBaselineSchema.default({}),
+  doctor: doctorConfigSchema.default({})
+});
+function parseConfig(input) {
+  return releaseKitConfigSchema.parse(input);
+}
+function channelOf(config, name) {
+  const channel = config.channels[name];
+  if (!channel) {
+    const available = Object.keys(config.channels).join(", ");
+    throw new Error(`canal desconhecido: "${name}". Canais dispon\xEDveis: ${available}`);
+  }
+  return channel;
+}
+
+// src/config/load.ts
+var CONFIG_FILENAME = "release-kit.config.json";
+function configPath(repoRoot) {
+  return join2(repoRoot, CONFIG_FILENAME);
+}
+function loadConfig(repoRoot) {
+  const path = configPath(repoRoot);
+  if (!existsSync2(path)) {
+    fail(
+      `${CONFIG_FILENAME} n\xE3o encontrado em ${repoRoot}. Rode \`release-kit init\` para criar a configura\xE7\xE3o.`
+    );
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    fail(`${CONFIG_FILENAME} n\xE3o \xE9 um JSON v\xE1lido: ${error.message}`);
+  }
+  try {
+    return parseConfig(raw);
+  } catch (error) {
+    if (error instanceof z2.ZodError) {
+      const issues = error.issues.map((issue) => `  - ${issue.path.join(".") || "(raiz)"}: ${issue.message}`);
+      fail(`${CONFIG_FILENAME} inv\xE1lido:
+${issues.join("\n")}`);
+    }
+    throw error;
+  }
+}
+function writeConfig(repoRoot, config) {
+  const path = configPath(repoRoot);
+  const withSchema = { $schema: "./node_modules/@htgabriel/release-kit/schema.json", ...config };
+  writeFileSync(path, `${JSON.stringify(withSchema, null, 2)}
+`);
+  return path;
+}
+
+// src/cli/resolve.ts
+function findRepoRoot(cwd = process.cwd()) {
+  const result = crossSpawn2.sync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" });
+  if (result.status === 0 && result.stdout) return result.stdout.trim();
+  return cwd;
+}
+function buildContext(flags = {}) {
+  const repoRoot = findRepoRoot();
+  const json = Boolean(flags.json);
+  return createContext({
+    repoRoot,
+    dryRun: Boolean(flags.dryRun),
+    json,
+    verbose: Boolean(flags.verbose),
+    nonInteractive: flags.nonInteractive ?? !process.stdin.isTTY,
+    log: createLogger({ json, verbose: flags.verbose })
+  });
+}
+function withAppDir(ctx, config) {
+  return { ...ctx, appDir: resolve(ctx.repoRoot, config.appDir), releaseDir: resolve(ctx.repoRoot, config.appDir, ".release") };
+}
+function loadContextAndConfig(flags = {}) {
+  const base = buildContext(flags);
+  const config = loadConfig(base.repoRoot);
+  return { ctx: withAppDir(base, config), config };
+}
+
+// src/cli/init.ts
+init_store();
+
+// src/eas/cli.ts
+init_run();
+function eas(ctx, args, { inherit = false, env = {}, cwd } = {}) {
+  return ctx.run("eas", args, {
+    cwd: cwd ?? ctx.appDir,
+    env,
+    inherit,
+    dryRun: ctx.dryRun
+  });
+}
+function parseRemoteVersion(stdout) {
+  const text2 = String(stdout || "").trim();
+  const jsonStart = text2.indexOf("{");
+  if (jsonStart === -1) return { versionCode: null, buildNumber: null, raw: text2 };
+  try {
+    const parsed = JSON.parse(text2.slice(jsonStart));
+    return {
+      versionCode: parsed.versionCode != null ? String(parsed.versionCode) : null,
+      buildNumber: parsed.buildNumber != null ? String(parsed.buildNumber) : null,
+      raw: parsed
+    };
+  } catch {
+    return { versionCode: null, buildNumber: null, raw: text2 };
+  }
+}
+function projectRemoteVersion(ctx, { platform, buildProfile }) {
+  const args = ["build:version:get", "--non-interactive", "--json", "-e", buildProfile, "-p", platform];
+  const result = eas(ctx, args);
+  if (ctx.dryRun) return { versionCode: null, buildNumber: null, raw: null, dryRun: true };
+  requireSuccess(result, "eas build:version:get");
+  return parseRemoteVersion(result.stdout);
+}
+function expectedBuildNumber(current, { autoIncrement, platform }) {
+  const key = platform === "ios" ? "buildNumber" : "versionCode";
+  const currentValue = current[key];
+  if (!currentValue) return { key, current: null, expected: null };
+  if (!autoIncrement) return { key, current: currentValue, expected: currentValue };
+  const numeric = Number(currentValue);
+  if (!Number.isFinite(numeric)) return { key, current: currentValue, expected: null };
+  return { key, current: currentValue, expected: String(numeric + 1) };
+}
+function easWhoami(ctx) {
+  const result = eas(ctx, ["whoami"]);
+  if (ctx.dryRun) return { ok: true, account: null, raw: "[dry-run]" };
+  if (result.status !== 0) return { ok: false, account: null, raw: result.stderr || result.stdout };
+  const account = result.stdout.trim().split("\n").pop() ?? null;
+  return { ok: true, account, raw: result.stdout };
+}
+function easEnvList(ctx, environment) {
+  return eas(ctx, ["env:list", environment, "--format", "short"]);
+}
+function easEnvListHasKey(ctx, environment, key) {
+  const result = easEnvList(ctx, environment);
+  if (ctx.dryRun) return true;
+  if (result.status !== 0) return false;
+  const pattern = new RegExp(`(^|\\n)${key}(\\n|$)`);
+  return pattern.test(`${result.stdout}
+${result.stderr}`);
+}
+function easFingerprintGenerate(ctx, environment) {
+  return eas(ctx, ["fingerprint:generate", "--non-interactive", "--json", "--environment", environment]);
+}
+function easFingerprintCompare(ctx, environment, buildId) {
+  return eas(ctx, [
+    "fingerprint:compare",
+    "--non-interactive",
+    "--json",
+    "--build-id",
+    buildId,
+    "--environment",
+    environment
+  ]);
+}
+function easBuild(ctx, opts) {
+  const args = ["build", "-p", opts.platform, "--profile", opts.buildProfile, "--non-interactive"];
+  if (opts.local) args.push("--local");
+  if (opts.output) args.push("--output", opts.output);
+  return eas(ctx, args, { inherit: true, env: opts.env });
+}
+function easSubmit(ctx, opts) {
+  const args = ["submit", "-p", opts.platform, "--profile", opts.submitProfile, "--path", opts.path, "--non-interactive"];
+  return eas(ctx, args, { inherit: true, env: opts.env });
+}
+function easUpdate(ctx, opts) {
+  const args = ["update", "--channel", opts.channel, "--non-interactive"];
+  if (opts.message) args.push("--message", opts.message);
+  if (opts.platform) args.push("--platform", opts.platform);
+  return eas(ctx, args, { inherit: true, env: opts.env });
+}
+function assertEasCliAvailable(ctx) {
+  const result = ctx.run("eas", ["--version"], { cwd: ctx.appDir });
+  if (result.status !== 0) {
+    fail("eas-cli n\xE3o encontrado no PATH. Instale com `npm install -g eas-cli` e rode `eas login`.");
+  }
+}
+
+// src/stores/apple/client.ts
+init_run();
+
+// src/stores/apple/auth.ts
+import { createPrivateKey, createSign } from "crypto";
+function base64url(input) {
+  const buffer = typeof input === "string" ? Buffer.from(input) : input;
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function createAppStoreConnectToken(credentials, now = Date.now()) {
+  const iat = Math.floor(now / 1e3);
+  const exp = iat + 19 * 60;
+  const header = base64url(JSON.stringify({ alg: "ES256", kid: credentials.keyId, typ: "JWT" }));
+  const payload = base64url(
+    JSON.stringify({
+      iss: credentials.issuerId,
+      iat,
+      exp,
+      aud: "appstoreconnect-v1"
+    })
+  );
+  const signingInput = `${header}.${payload}`;
+  const key = createPrivateKey({ key: credentials.privateKeyPem, format: "pem" });
+  const signer = createSign("SHA256");
+  signer.update(signingInput);
+  signer.end();
+  const signature = signer.sign({ key, dsaEncoding: "ieee-p1363" });
+  return `${signingInput}.${base64url(signature)}`;
+}
+
+// src/stores/apple/client.ts
+var APP_STORE_CONNECT_BASE = "https://api.appstoreconnect.apple.com/v1";
+var AppStoreConnectClient = class {
+  credentials;
+  baseUrl;
+  fetchImpl;
+  constructor(options) {
+    this.credentials = options.credentials;
+    this.baseUrl = options.baseUrl ?? APP_STORE_CONNECT_BASE;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  token() {
+    return createAppStoreConnectToken(this.credentials);
+  }
+  async request(method, path, body) {
+    const url = path.startsWith("http") ? path : `${this.baseUrl}${path}`;
+    const response = await this.fetchImpl(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.token()}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const text2 = await response.text();
+    if (!response.ok) {
+      fail(`App Store Connect API ${method} ${path} \u2192 ${response.status}
+${text2}`);
+    }
+    if (!text2) return void 0;
+    return JSON.parse(text2);
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+};
+
+// src/stores/apple/apps.ts
+init_run();
+async function findAppByBundleId(client, bundleId) {
+  const result = await client.get(`/apps?filter[bundleId]=${encodeURIComponent(bundleId)}`);
+  const [app] = result.data;
+  if (!app) return null;
+  return { id: app.id, name: app.attributes.name };
+}
+async function requireAppByBundleId(client, bundleId) {
+  const app = await findAppByBundleId(client, bundleId);
+  if (!app) fail(`App com bundleId ${bundleId} n\xE3o encontrado no App Store Connect (chave sem acesso ao app, ou app ainda n\xE3o criado).`);
+  return app;
+}
+
+// src/stores/google/client.ts
+init_run();
+
+// src/stores/google/auth.ts
+init_run();
+import { createSign as createSign2 } from "crypto";
+function parseServiceAccountJson(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    fail(`JSON da service account inv\xE1lido: ${error.message}`);
+  }
+  const account = parsed;
+  if (!account.client_email || !account.private_key) {
+    fail("JSON da service account sem client_email/private_key.");
+  }
+  return account;
+}
+function base64url2(input) {
+  const buffer = typeof input === "string" ? Buffer.from(input) : input;
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var ANDROID_PUBLISHER_SCOPE = "https://www.googleapis.com/auth/androidpublisher";
+async function fetchAccessToken(account, fetchImpl = fetch, now = Date.now()) {
+  const iat = Math.floor(now / 1e3);
+  const exp = iat + 60 * 60;
+  const header = base64url2(JSON.stringify({ alg: "RS256", typ: "JWT" }));
+  const payload = base64url2(
+    JSON.stringify({
+      iss: account.client_email,
+      scope: ANDROID_PUBLISHER_SCOPE,
+      aud: TOKEN_URL,
+      iat,
+      exp
+    })
+  );
+  const signingInput = `${header}.${payload}`;
+  const signer = createSign2("RSA-SHA256");
+  signer.update(signingInput);
+  signer.end();
+  const signature = signer.sign(account.private_key);
+  const assertion = `${signingInput}.${base64url2(signature)}`;
+  const response = await fetchImpl(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+      assertion
+    }).toString()
+  });
+  const text2 = await response.text();
+  if (!response.ok) fail(`Falha ao obter access_token do Google: ${response.status}
+${text2}`);
+  const json = JSON.parse(text2);
+  if (!json.access_token) fail("Resposta do Google sem access_token.");
+  return json.access_token;
+}
+
+// src/stores/google/client.ts
+var ANDROID_PUBLISHER_BASE = "https://androidpublisher.googleapis.com/androidpublisher/v3";
+var AndroidPublisherClient = class {
+  account;
+  baseUrl;
+  fetchImpl;
+  cachedToken = null;
+  constructor(options) {
+    this.account = options.account;
+    this.baseUrl = options.baseUrl ?? ANDROID_PUBLISHER_BASE;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async token() {
+    if (!this.cachedToken) {
+      this.cachedToken = await fetchAccessToken(this.account, this.fetchImpl);
+    }
+    return this.cachedToken;
+  }
+  async request(method, path, body) {
+    const token = await this.token();
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const text2 = await response.text();
+    if (!response.ok) fail(`Android Publisher API ${method} ${path} \u2192 ${response.status}
+${text2}`);
+    if (!text2) return void 0;
+    return JSON.parse(text2);
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/stores/google/tracks.ts
+init_run();
+
+// src/notes/limits.ts
+init_run();
+var PLAY_NOTES_MAX = 500;
+var APPLE_WHATS_NEW_MAX = 4e3;
+function notesMaxFor(target) {
+  return target === "play" ? PLAY_NOTES_MAX : APPLE_WHATS_NEW_MAX;
+}
+function assertNotesWithinLimit(text2, target, locale) {
+  const max = notesMaxFor(target);
+  if (text2.length > max) {
+    fail(`Notas ${target} (${locale}) t\xEAm ${text2.length} caracteres (m\xE1ximo ${max}).`);
+  }
+  if (!text2.trim()) {
+    fail(`Notas ${target} (${locale}) est\xE3o vazias.`);
+  }
+}
+
+// src/stores/google/tracks.ts
+async function withEdit(client, packageName, fn) {
+  const edit = await client.post(`/applications/${packageName}/edits`);
+  try {
+    const result = await fn(edit.id);
+    await client.post(`/applications/${packageName}/edits/${edit.id}:commit`);
+    return result;
+  } catch (error) {
+    await client.delete(`/applications/${packageName}/edits/${edit.id}`).catch(() => {
+    });
+    throw error;
+  }
+}
+async function withReadOnlyEdit(client, packageName, fn) {
+  const edit = await client.post(`/applications/${packageName}/edits`);
+  try {
+    return await fn(edit.id);
+  } finally {
+    await client.delete(`/applications/${packageName}/edits/${edit.id}`).catch(() => {
+    });
+  }
+}
+function findTargetRelease(releases, versionCode) {
+  if (versionCode) {
+    return releases.find((release) => (release.versionCodes ?? []).includes(String(versionCode)));
+  }
+  return releases.find((release) => release.status === "completed") ?? releases[0];
+}
+async function validatePlayAccess(client, packageName) {
+  await withReadOnlyEdit(client, packageName, async () => void 0);
+}
+async function promoteRelease(client, input) {
+  return withEdit(client, input.packageName, async (editId) => {
+    const source = await client.get(`/applications/${input.packageName}/edits/${editId}/tracks/${input.fromTrack}`);
+    const releases = source.releases ?? [];
+    const target = findTargetRelease(releases);
+    if (!target || !target.versionCodes?.length) {
+      fail(`faixa ${input.fromTrack} sem release para promover.`);
+    }
+    const fraction = input.initialRollout ?? 1;
+    const status = fraction < 1 ? "inProgress" : "completed";
+    const releaseNotes = input.notesByLocale ? Object.entries(input.notesByLocale).map(([language, text2]) => ({ language, text: text2 })) : target.releaseNotes;
+    const newRelease = {
+      versionCodes: target.versionCodes,
+      status,
+      releaseNotes,
+      ...status === "inProgress" ? { userFraction: fraction } : {}
+    };
+    await client.put(`/applications/${input.packageName}/edits/${editId}/tracks/${input.toTrack}`, {
+      track: input.toTrack,
+      releases: [newRelease]
+    });
+    return newRelease;
+  });
+}
+async function setRollout(client, packageName, track, target) {
+  return withEdit(client, packageName, async (editId) => {
+    const current = await client.get(`/applications/${packageName}/edits/${editId}/tracks/${track}`);
+    const releases = current.releases ?? [];
+    const active = releases.find((release) => release.status === "inProgress") ?? releases[releases.length - 1];
+    if (!active) fail(`faixa ${track} sem release em rollout.`);
+    if (target === "complete") {
+      active.status = "completed";
+      delete active.userFraction;
+    } else if (target === "halt") {
+      active.status = "halted";
+    } else {
+      if (target <= 0 || target > 1) fail(`--to precisa ser um valor entre 0 e 1 (ou complete/halt).`);
+      active.status = "inProgress";
+      active.userFraction = target;
+    }
+    await client.put(`/applications/${packageName}/edits/${editId}/tracks/${track}`, { track, releases });
+    return active;
+  });
+}
+async function getTrackStatus(client, packageName, track) {
+  return withReadOnlyEdit(
+    client,
+    packageName,
+    (editId) => client.get(`/applications/${packageName}/edits/${editId}/tracks/${track}`)
+  );
+}
+
+// src/doctor/run.ts
+init_run();
+
+// src/git/policy.ts
+init_run();
+function git(ctx, args, { allowFail = false } = {}) {
+  const result = ctx.run("git", args, { cwd: ctx.repoRoot, inherit: false });
+  if (!allowFail) requireSuccess(result, `git ${args.join(" ")}`);
+  return result;
+}
+function gitPorcelain(ctx) {
+  return git(ctx, ["status", "--porcelain"]).stdout;
+}
+function isWorkingTreeClean(ctx, ignoreDirs = [".release/"]) {
+  const dirty = gitPorcelain(ctx).split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0).filter((line) => !ignoreDirs.some((dir) => line.endsWith(` ${dir}`) || line.includes(` ${dir}`)));
+  return dirty.length === 0;
+}
+function dirtyFiles(ctx, ignoreDirs = [".release/"]) {
+  return gitPorcelain(ctx).split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0).filter((line) => !ignoreDirs.some((dir) => line.endsWith(` ${dir}`) || line.includes(` ${dir}`)));
+}
+function currentBranch(ctx) {
+  return git(ctx, ["rev-parse", "--abbrev-ref", "HEAD"]).stdout.trim();
+}
+function headSha(ctx) {
+  return git(ctx, ["rev-parse", "HEAD"]).stdout.trim();
+}
+function remoteSha(ctx, remote, branch) {
+  const result = git(ctx, ["rev-parse", `${remote}/${branch}`], { allowFail: true });
+  if (result.status !== 0) return null;
+  return result.stdout.trim();
+}
+function tagShaFormatted(ctx, tagFormat, version) {
+  const tag = renderTag(tagFormat, version);
+  const result = git(ctx, ["rev-parse", `${tag}^{commit}`], { allowFail: true });
+  if (result.status !== 0) return null;
+  return result.stdout.trim();
+}
+function lastTagMatching(ctx, tagFormat) {
+  const pattern = tagGlob(tagFormat);
+  const result = git(ctx, ["tag", "--list", pattern, "--sort=-creatordate"], { allowFail: true });
+  const [first] = (result.stdout || "").split("\n").map((line) => line.trim()).filter(Boolean);
+  return first ?? null;
+}
+function aheadBehind(ctx, remote, branch) {
+  const upstream = git(ctx, ["rev-parse", "--abbrev-ref", `${branch}@{upstream}`], { allowFail: true });
+  if (upstream.status !== 0) return null;
+  const counts = git(ctx, ["rev-list", "--left-right", "--count", `HEAD...${remote}/${branch}`], {
+    allowFail: true
+  });
+  if (counts.status !== 0) return null;
+  const [ahead = "0", behind = "0"] = counts.stdout.trim().split(/\s+/);
+  return { ahead: Number(ahead), behind: Number(behind) };
+}
+function renderTag(tagFormat, version) {
+  return tagFormat.replace("{version}", version);
+}
+function tagGlob(tagFormat) {
+  return tagFormat.replace("{version}", "*");
+}
+function checkGitPolicy(ctx, policy, { version, isProtectedChannel }) {
+  const checks = [];
+  const branch = currentBranch(ctx);
+  if (policy.requireClean) {
+    const dirty = dirtyFiles(ctx);
+    if (dirty.length) {
+      checks.push({ name: "git-clean", status: "fail", message: `working tree suja:
+${dirty.join("\n")}` });
+    } else {
+      checks.push({ name: "git-clean", status: "pass", message: "working tree limpa" });
+    }
+  }
+  if (isProtectedChannel) {
+    if (branch !== policy.releaseBranch) {
+      checks.push({
+        name: "git-branch",
+        status: "fail",
+        message: `canal protegido exige branch ${policy.releaseBranch} (atual: ${branch}).`
+      });
+    } else {
+      checks.push({ name: "git-branch", status: "pass", message: `branch ${branch}` });
+    }
+    const head = headSha(ctx);
+    const expectedTag = renderTag(policy.tagFormat, version);
+    const tagSha = tagShaFormatted(ctx, policy.tagFormat, version);
+    if (!tagSha) {
+      checks.push({ name: "git-tag", status: "fail", message: `tag ${expectedTag} n\xE3o existe (vers\xE3o atual: ${version}).` });
+    } else if (tagSha !== head) {
+      checks.push({
+        name: "git-tag",
+        status: "fail",
+        message: `tag ${expectedTag} (${tagSha.slice(0, 8)}) n\xE3o aponta para HEAD (${head.slice(0, 8)}).`
+      });
+    } else {
+      checks.push({ name: "git-tag", status: "pass", message: `${expectedTag} == HEAD` });
+    }
+    if (policy.requireSyncedWithRemote) {
+      const remote = remoteSha(ctx, policy.remote, policy.releaseBranch);
+      if (!remote) {
+        checks.push({
+          name: "git-sync",
+          status: "fail",
+          message: `${policy.remote}/${policy.releaseBranch} ausente. Rode git fetch ${policy.remote} ${policy.releaseBranch}.`
+        });
+      } else if (remote !== head) {
+        checks.push({
+          name: "git-sync",
+          status: "fail",
+          message: `HEAD (${head.slice(0, 8)}) \u2260 ${policy.remote}/${policy.releaseBranch} (${remote.slice(0, 8)}).`
+        });
+      } else {
+        checks.push({ name: "git-sync", status: "pass", message: `HEAD == ${policy.remote}/${policy.releaseBranch}` });
+      }
+    }
+    return checks;
+  }
+  if (policy.requireSyncedWithRemote) {
+    const status = aheadBehind(ctx, policy.remote, branch);
+    if (!status) {
+      checks.push({ name: "git-sync", status: "fail", message: `branch ${branch} sem upstream. Rode git push -u.` });
+    } else if (status.behind > 0) {
+      checks.push({ name: "git-sync", status: "fail", message: `branch atrasada ${status.behind} commit(s) em rela\xE7\xE3o ao upstream.` });
+    } else if (status.ahead > 0) {
+      checks.push({ name: "git-sync", status: "fail", message: `branch adiantada ${status.ahead} commit(s) \u2014 fa\xE7a push antes de buildar.` });
+    } else {
+      checks.push({ name: "git-sync", status: "pass", message: "sincronizada com o upstream" });
+    }
+  }
+  return checks;
+}
+
+// src/project/version.ts
+init_run();
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+import semver from "semver";
+function loadVersionFile(appDir, source) {
+  const path = join4(appDir, source);
+  if (!existsSync4(path)) fail(`${source} n\xE3o encontrado em ${appDir}.`);
+  const raw = readFileSync4(path, "utf8");
+  const json = JSON.parse(raw);
+  if (source === "app.json") {
+    return {
+      path,
+      json,
+      get: () => {
+        const expo = json.expo;
+        const version = expo?.version;
+        if (typeof version !== "string") fail(`app.json n\xE3o tem expo.version.`);
+        return version;
+      },
+      set: (next) => {
+        const expo = json.expo ?? {};
+        expo.version = next;
+        json.expo = expo;
+      }
+    };
+  }
+  return {
+    path,
+    json,
+    get: () => {
+      const version = json.version;
+      if (typeof version !== "string") fail(`package.json n\xE3o tem "version".`);
+      return version;
+    },
+    set: (next) => {
+      json.version = next;
+    }
+  };
+}
+function readAppVersion(appDir, config) {
+  return loadVersionFile(appDir, config.version.source).get();
+}
+function nextVersion(current, bump) {
+  if (bump === "patch" || bump === "minor" || bump === "major") {
+    const next = semver.inc(current, bump);
+    if (!next) fail(`n\xE3o foi poss\xEDvel incrementar "${bump}" a partir de ${current}.`);
+    return next;
+  }
+  if (!semver.valid(bump)) fail(`vers\xE3o inv\xE1lida: "${bump}". Use patch | minor | major | x.y.z.`);
+  if (semver.lte(bump, current)) {
+    fail(`${bump} n\xE3o \xE9 maior que a vers\xE3o atual (${current}).`);
+  }
+  return bump;
+}
+function writeAppVersion(appDir, config, next) {
+  const file = loadVersionFile(appDir, config.version.source);
+  file.set(next);
+  writeFileSync3(file.path, `${JSON.stringify(file.json, null, "	")}
+`);
+  return file.path;
+}
+
+// src/doctor/checks.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+
+// src/doctor/toolchain.ts
+function parseVersion(input) {
+  const match = String(input ?? "").replace(/^v/i, "").match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!match) return null;
+  return { major: Number(match[1]), minor: Number(match[2] || 0), patch: Number(match[3] || 0) };
+}
+function cmpVersion(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) return 0;
+  if (pa.major !== pb.major) return pa.major - pb.major;
+  if (pa.minor !== pb.minor) return pa.minor - pb.minor;
+  return pa.patch - pb.patch;
+}
+function collectToolchain(ctx) {
+  const capture = (command, args, pick) => {
+    const result = ctx.run(command, args, { inherit: false });
+    if (result.status !== 0) return null;
+    return pick(`${result.stdout}
+${result.stderr}`);
+  };
+  const firstMatch = (text2, re) => text2.match(re)?.[1] ?? null;
+  return {
+    easCli: capture("eas", ["--version"], (t) => firstMatch(t, /eas-cli\/(\d+\.\d+\.\d+)/)),
+    node: capture("node", ["-v"], (t) => firstMatch(t, /v?(\d+\.\d+\.\d+)/)),
+    yarn: capture("yarn", ["-v"], (t) => firstMatch(t, /(\d+\.\d+\.\d+)/)),
+    jdk: capture("java", ["-version"], (t) => firstMatch(t, /version "(\d+(?:\.\d+\.\d+)?)/)),
+    xcode: capture("xcodebuild", ["-version"], (t) => firstMatch(t, /Xcode (\d+\.\d+)/)),
+    xcodeBuild: capture("xcodebuild", ["-version"], (t) => firstMatch(t, /Build version (\S+)/)),
+    cocoapods: capture("pod", ["--version"], (t) => firstMatch(t, /(\d+\.\d+\.\d+)/)),
+    ndkHome: ctx.env.ANDROID_NDK_HOME || null,
+    host: `${process.platform}-${process.arch}`
+  };
+}
+
+// src/doctor/checks.ts
+var EXPO_PUBLIC_PREFIX = "EXPO_PUBLIC_";
+function check(name, status, message) {
+  return { name, status, message };
+}
+function assertShellClean(ctx, checks) {
+  const leaked = Object.keys(ctx.env).filter((key) => key.startsWith(EXPO_PUBLIC_PREFIX) && ctx.env[key]);
+  if (leaked.length) {
+    checks.push(
+      check(
+        "shell-env",
+        "fail",
+        `shell tem ${leaked.join(", ")} exportado. Em build local isso vence as env vars do EAS. Unset antes de continuar.`
+      )
+    );
+    return;
+  }
+  checks.push(check("shell-env", "pass", "nenhum EXPO_PUBLIC_* no shell"));
+}
+function assertSentry(ctx, checks, channel) {
+  if (channel?.sentryUploadDisabled) {
+    checks.push(check("sentry", "pass", "canal desliga o upload de sourcemap; token n\xE3o \xE9 exigido."));
+    return;
+  }
+  const inShell = Boolean(ctx.env.SENTRY_AUTH_TOKEN);
+  if (!channel && !inShell) {
+    checks.push(check("sentry", "skip", "passe --channel para verificar SENTRY_AUTH_TOKEN no environment EAS."));
+    return;
+  }
+  if (inShell) {
+    checks.push(
+      check(
+        "sentry",
+        "warn",
+        "SENTRY_AUTH_TOKEN est\xE1 no shell e, em build local, vence o token do EAS. Prefira unset e deixe o environment EAS (Sensitive) injetar."
+      )
+    );
+    return;
+  }
+  const environment = channel?.easEnvironment;
+  if (environment && easEnvListHasKey(ctx, environment, "SENTRY_AUTH_TOKEN")) {
+    checks.push(check("sentry", "pass", `SENTRY_AUTH_TOKEN no environment EAS ${environment}.`));
+    return;
+  }
+  checks.push(
+    check(
+      "sentry",
+      "fail",
+      `SENTRY_AUTH_TOKEN ausente no shell e no environment EAS ${environment || "(defina easEnvironment no canal)"}.`
+    )
+  );
+}
+function assertEasAuth(ctx, checks, easOwner) {
+  const result = easWhoami(ctx);
+  if (ctx.dryRun) {
+    checks.push(check("eas-auth", "pass", "[dry-run] eas whoami"));
+    return;
+  }
+  if (!result.ok) {
+    checks.push(check("eas-auth", "fail", `eas whoami falhou. Rode \`eas login\` ou defina EXPO_TOKEN.
+${result.raw}`));
+    return;
+  }
+  if (easOwner && !result.raw.includes(easOwner)) {
+    checks.push(check("eas-auth", "fail", `eas whoami n\xE3o listou a conta ${easOwner}.`));
+    return;
+  }
+  checks.push(check("eas-auth", "pass", `autenticado${result.account ? ` como ${result.account}` : ""}`));
+}
+function assertToolchain(ctx, checks, config, { platform, allowToolchainDrift }) {
+  const baseline = config.toolchain;
+  const actual = collectToolchain(ctx);
+  const drift = [];
+  const compare = (name, spec, value, { platformOnly } = {}) => {
+    if (!spec) {
+      checks.push(check(`toolchain-${name}`, "skip", "sem baseline configurado"));
+      return;
+    }
+    if (platformOnly && platform && platform !== platformOnly) {
+      checks.push(check(`toolchain-${name}`, "skip", `n\xE3o exigido para --platform ${platform}`));
+      return;
+    }
+    if (!value) {
+      checks.push(check(`toolchain-${name}`, "fail", `${name} n\xE3o encontrado no PATH.`));
+      return;
+    }
+    if (spec.min && cmpVersion(value, spec.min) < 0) {
+      checks.push(check(`toolchain-${name}`, "fail", `${name} ${value} < m\xEDnimo ${spec.min}.`));
+      return;
+    }
+    if (spec.tested && cmpVersion(value, spec.tested) > 0) {
+      drift.push(`${name} ${value} > testado ${spec.tested}`);
+      checks.push(
+        check(
+          `toolchain-${name}`,
+          allowToolchainDrift ? "warn" : "fail",
+          `${name} ${value} est\xE1 acima do testado (${spec.tested}). Passe --allow-toolchain-drift para continuar.`
+        )
+      );
+      return;
+    }
+    checks.push(check(`toolchain-${name}`, "pass", `${name} ${value}`));
+  };
+  compare("eas-cli", baseline.easCli, actual.easCli);
+  compare("node", baseline.node, actual.node);
+  compare("jdk", baseline.jdk, actual.jdk, { platformOnly: "android" });
+  compare("xcode", baseline.xcode, actual.xcode, { platformOnly: "ios" });
+  compare("cocoapods", baseline.cocoapods, actual.cocoapods, { platformOnly: "ios" });
+  if (!platform || platform === "android") {
+    if (!ctx.env.JAVA_HOME) {
+      checks.push(check("java-home", "fail", "JAVA_HOME n\xE3o est\xE1 definido."));
+    } else {
+      checks.push(check("java-home", "pass", ctx.env.JAVA_HOME));
+    }
+    if (!ctx.env.ANDROID_HOME && !ctx.env.ANDROID_SDK_ROOT) {
+      checks.push(check("android-sdk", "fail", "ANDROID_HOME / ANDROID_SDK_ROOT ausente."));
+    } else {
+      checks.push(check("android-sdk", "pass", ctx.env.ANDROID_HOME || ctx.env.ANDROID_SDK_ROOT || ""));
+    }
+  }
+  if (platform === "ios" && process.platform !== "darwin") {
+    checks.push(check("platform-ios", "fail", "build local de iOS s\xF3 funciona no macOS. Use --cloud ou remova --platform ios."));
+  } else if (platform === "android" && process.platform === "win32") {
+    checks.push(
+      check(
+        "platform-android",
+        "warn",
+        "build local de Android no Windows n\xE3o \xE9 suportado pelo EAS fora do WSL2. Use --cloud ou rode dentro do WSL2."
+      )
+    );
+  }
+  return { actual, drift, toolchainDrift: drift.length > 0 };
+}
+function assertLockfileClean(ctx, checks) {
+  const pm = detectPackageManager(ctx.repoRoot);
+  const lockfile = { yarn: "yarn.lock", pnpm: "pnpm-lock.yaml", npm: "package-lock.json" }[pm];
+  const diff = ctx.run("git", ["diff", "--quiet", "HEAD", "--", lockfile], { cwd: ctx.repoRoot, inherit: false });
+  if (diff.status !== 0) {
+    checks.push(check("lockfile", "fail", `${lockfile} diverge do HEAD. Commit ou restaure antes do build (lockfile congelado).`));
+    return;
+  }
+  checks.push(check("lockfile", "pass", `${lockfile} igual ao HEAD`));
+}
+function assertRemoteVersion(ctx, checks, { platform, channel }) {
+  const remote = projectRemoteVersion(ctx, { platform, buildProfile: channel.buildProfile });
+  if (remote.dryRun) {
+    checks.push(check("remote-version", "pass", "[dry-run] eas build:version:get"));
+    return;
+  }
+  const projection = expectedBuildNumber(remote, { autoIncrement: channel.autoIncrement, platform });
+  if (!channel.autoIncrement) {
+    checks.push(
+      check(
+        "remote-version",
+        "pass",
+        `${projection.key} remoto atual: ${projection.current} (autoIncrement desligado; este build reutiliza o n\xFAmero).`
+      )
+    );
+    return;
+  }
+  checks.push(
+    check(
+      "remote-version",
+      "pass",
+      `${projection.key} remoto atual: ${projection.current} \u2192 esperado neste build: ${projection.expected} (s\xF3 \xE9 reservado quando o EAS iniciar o build).`
+    )
+  );
+}
+function assertFingerprint(ctx, checks, { channel, deep, buildId }) {
+  const environment = channel.easEnvironment;
+  if (!environment) {
+    checks.push(check("fingerprint", "skip", "canal sem easEnvironment configurado."));
+    return;
+  }
+  if (!deep) {
+    checks.push(check("fingerprint", "pass", `compara\xE7\xE3o contra build da nuvem s\xF3 em --deep (environment ${environment}).`));
+    return;
+  }
+  if (ctx.dryRun) {
+    checks.push(check("fingerprint", "pass", `[dry-run] eas fingerprint:generate --environment ${environment}`));
+    return;
+  }
+  const generated = easFingerprintGenerate(ctx, environment);
+  if (generated.status !== 0) {
+    checks.push(check("fingerprint", "fail", `eas fingerprint:generate falhou.
+${generated.stderr || generated.stdout}`));
+    return;
+  }
+  if (!buildId) {
+    checks.push(
+      check(
+        "fingerprint",
+        "pass",
+        `fingerprint local gerado. Para comparar com a nuvem: eas fingerprint:compare --build-id <id> --environment ${environment}`
+      )
+    );
+    return;
+  }
+  const compared = easFingerprintCompare(ctx, environment, buildId);
+  if (compared.status !== 0) {
+    checks.push(check("fingerprint", "fail", `eas fingerprint:compare falhou.
+${compared.stderr || compared.stdout}`));
+    return;
+  }
+  checks.push(check("fingerprint", "pass", `fingerprint local vs build ${buildId}`));
+}
+function assertExpoDoctor(ctx, checks, config) {
+  if (!config.doctor.expoDoctor) {
+    checks.push(check("expo-doctor", "skip", "desligado em doctor.expoDoctor"));
+    return;
+  }
+  if (ctx.dryRun) {
+    checks.push(check("expo-doctor", "pass", "[dry-run] npx expo-doctor"));
+    return;
+  }
+  const result = ctx.run("npx", ["expo-doctor"], { cwd: ctx.appDir, inherit: false });
+  if (result.status !== 0) {
+    const detail = (result.stdout || result.stderr || "").trim();
+    checks.push(
+      check("expo-doctor", "fail", `expo-doctor saiu com c\xF3digo ${result.status}. Atualize as depend\xEAncias com \`npx expo install\`.${detail ? `
+${detail}` : ""}`)
+    );
+    return;
+  }
+  checks.push(check("expo-doctor", "pass", "expo-doctor ok"));
+}
+function assertEasJsonExists(ctx) {
+  if (!existsSync5(join5(ctx.appDir, "eas.json"))) {
+    throw new Error(`eas.json n\xE3o encontrado em ${ctx.appDir}. Rode \`eas init\` ou \`release-kit init\`.`);
+  }
+}
+
+// src/doctor/run.ts
+function runDoctor(ctx, config, opts) {
+  assertEasJsonExists(ctx);
+  const channel = opts.channel ? channelOf(config, opts.channel) : null;
+  if (opts.platform && !config.platforms.includes(opts.platform)) {
+    fail(`--platform ${opts.platform} n\xE3o est\xE1 em config.platforms (${config.platforms.join(", ")}).`);
+  }
+  const checks = [];
+  const version = readAppVersion(ctx.appDir, config);
+  checks.push(...checkGitPolicy(ctx, config.git, { version, isProtectedChannel: Boolean(channel?.protected) }));
+  assertShellClean(ctx, checks);
+  if (config.doctor.sentry) {
+    assertSentry(ctx, checks, channel);
+  } else {
+    checks.push({ name: "sentry", status: "skip", message: "desligado em doctor.sentry" });
+  }
+  assertEasAuth(ctx, checks, config.easOwner);
+  const toolchain = assertToolchain(ctx, checks, config, {
+    platform: opts.platform,
+    allowToolchainDrift: opts.allowToolchainDrift
+  });
+  assertLockfileClean(ctx, checks);
+  if (channel && opts.platform) {
+    assertRemoteVersion(ctx, checks, { platform: opts.platform, channel });
+    assertFingerprint(ctx, checks, { channel, deep: opts.deep, buildId: opts.buildId });
+  } else {
+    checks.push({ name: "remote-version", status: "skip", message: "passe --channel e --platform para consultar versionCode/buildNumber" });
+    checks.push({ name: "fingerprint", status: "skip", message: "passe --channel para avaliar runtimeVersion" });
+  }
+  assertExpoDoctor(ctx, checks, config);
+  const failed = checks.filter((item) => item.status === "fail");
+  return {
+    ok: failed.length === 0,
+    checks,
+    toolchainDrift: toolchain.toolchainDrift
+  };
+}
+function printDoctorReport(report, ctx) {
+  for (const item of report.checks) {
+    const mark = item.status === "pass" ? "\u2713" : item.status === "skip" ? "\xB7" : item.status === "warn" ? "!" : "\u2717";
+    ctx.log.info(`${mark} ${item.name}: ${item.message}`);
+  }
+}
+function requireDoctorPass(report) {
+  if (report.ok) return;
+  const failed = report.checks.filter((item) => item.status === "fail");
+  const summary = failed.map((item) => `- ${item.name}: ${item.message}`).join("\n");
+  fail(`doctor falhou:
+${summary}`);
+}
+
+// src/cli/init.ts
+function cancel2(message = "Setup cancelado.") {
+  p.cancel(message);
+  process.exit(1);
+}
+async function runInitWizard() {
+  p.intro(pc2.bold("release-kit init"));
+  const repoRoot = process.cwd().includes(".git") ? process.cwd() : findGitRootOrCwd();
+  const ctxBase = buildContext({});
+  const slug = basenameSlug(ctxBase.repoRoot);
+  const packageManager = detectPackageManager(ctxBase.repoRoot);
+  const detectedAppDir = detectAppDir(ctxBase.repoRoot);
+  const appDirRelative = detectedAppDir ?? await promptText("Diret\xF3rio do app Expo (relativo \xE0 raiz do repo)", ".");
+  const appDir = resolve2(ctxBase.repoRoot, appDirRelative);
+  if (!existsSync6(join6(appDir, "app.json"))) {
+    cancel2(`app.json n\xE3o encontrado em ${appDir}. Rode este comando na raiz de um projeto Expo, ou informe o diret\xF3rio certo.`);
+  }
+  p.log.success(`projeto: ${packageManager}, appDir=${appDirRelative}`);
+  const ctx = { ...ctxBase, appDir };
+  assertEasCliAvailable(ctx);
+  p.log.success("eas-cli encontrado no PATH");
+  warnPlatformLimits();
+  await ensureEasLogin(ctx);
+  const easJson = readEasJson(appDir);
+  if (!easJson) cancel2(`eas.json n\xE3o encontrado em ${appDirRelative}. Rode \`eas init\` primeiro ou aponte para o appDir certo.`);
+  const platforms = await promptPlatforms();
+  const channels = await defineChannels(ctx, easJson, platforms);
+  const envUpdates = {};
+  if (platforms.includes("ios")) {
+    await runAppleCredentialsStep(ctx, slug, channels, envUpdates);
+  }
+  if (platforms.includes("android")) {
+    await runGoogleCredentialsStep(slug, channels, envUpdates);
+  }
+  if (Object.keys(envUpdates).length > 0) {
+    const sync = await p.confirm({
+      message: "Configurar essas credenciais tamb\xE9m no EAS (env vars/credentials), pra build/submit na nuvem e CI funcionarem sem prompt?"
+    });
+    if (sync === true) {
+      p.log.info("Rode manualmente por enquanto: `eas credentials` (ASC key / Play SA) e `eas env:create` para as demais env vars. Automa\xE7\xE3o completa fica para uma vers\xE3o futura do release-kit.");
+    }
+  }
+  const locales = await promptLocales();
+  const config = releaseKitConfigSchema.parse({
+    appDir: appDirRelative,
+    platforms,
+    locales,
+    channels
+  });
+  writeConfig(ctx.repoRoot, config);
+  if (Object.keys(envUpdates).length > 0) writeEnvFile(ctx.repoRoot, envUpdates);
+  ensureGitignoreEntries(ctx.repoRoot);
+  mkdirSync2(join6(appDir, config.notesDir), { recursive: true });
+  addReleaseScript(ctx.repoRoot, packageManager);
+  p.log.success(`escrito: release-kit.config.json, .env.release, ${config.notesDir}/`);
+  const finalCtx = { ...ctx, releaseDir: join6(appDir, ".release"), env: { ...process.env, ...readEnvFile(ctx.repoRoot) } };
+  try {
+    const report = runDoctor(finalCtx, config, {});
+    printDoctorReport(report, finalCtx);
+  } catch (error) {
+    p.log.warn(`doctor encontrou pend\xEAncias: ${error.message}`);
+  }
+  p.outro("Setup conclu\xEDdo. Pr\xF3ximo passo: `release-kit doctor --channel <canal> --platform <plataforma>`.");
+}
+function findGitRootOrCwd() {
+  return process.cwd();
+}
+function basenameSlug(repoRoot) {
+  return repoRoot.split("/").filter(Boolean).pop() ?? "release-kit-project";
+}
+async function promptText(message, initialValue) {
+  const value = await p.text({ message, initialValue });
+  if (p.isCancel(value)) cancel2();
+  return value;
+}
+function warnPlatformLimits() {
+  if (process.platform === "win32") {
+    p.log.warn("Windows: build local de iOS n\xE3o \xE9 suportado (precisa de macOS) e build local de Android exige WSL2. Use --cloud nesses casos.");
+  } else if (process.platform === "linux") {
+    p.log.warn("Linux: build local de iOS n\xE3o \xE9 suportado (precisa de macOS). Android funciona normalmente.");
+  }
+}
+async function ensureEasLogin(ctx) {
+  const whoami = easWhoami(ctx);
+  if (whoami.ok) {
+    p.log.success(`eas: autenticado${whoami.account ? ` como ${whoami.account}` : ""}`);
+    return;
+  }
+  const choice = await p.select({
+    message: "N\xE3o autenticado no EAS. Como prefere entrar?",
+    options: [
+      { value: "login", label: "eas login (abre o fluxo interativo do eas-cli)" },
+      { value: "token", label: "Colar um EXPO_TOKEN" }
+    ]
+  });
+  if (p.isCancel(choice)) cancel2();
+  if (choice === "login") {
+    ctx.run("eas", ["login"], { inherit: true });
+  } else {
+    const token = await promptText("EXPO_TOKEN");
+    process.env.EXPO_TOKEN = token;
+  }
+  const retry = easWhoami(ctx);
+  if (!retry.ok) cancel2("Ainda n\xE3o autenticado no EAS. Rode `release-kit init` de novo depois de `eas login`.");
+  p.log.success(`eas: autenticado${retry.account ? ` como ${retry.account}` : ""}`);
+  const easJson = readEasJson(ctx.appDir);
+  if (!easJson) {
+    const doInit = await p.confirm({ message: "eas.json n\xE3o encontrado. Rodar `eas init` agora?" });
+    if (doInit === true) {
+      ctx.run("eas", ["init", "--non-interactive"], { cwd: ctx.appDir, inherit: true });
+    }
+  }
+}
+async function promptPlatforms() {
+  const selected = await p.multiselect({
+    message: "Quais plataformas este projeto publica?",
+    options: [
+      { value: "android", label: "Android (Google Play)" },
+      { value: "ios", label: "iOS (App Store)" }
+    ],
+    initialValues: ["android", "ios"]
+  });
+  if (p.isCancel(selected)) cancel2();
+  return selected;
+}
+async function promptLocales() {
+  const raw = await p.text({ message: "Locales das notas de loja, separados por v\xEDrgula", initialValue: "pt-BR" });
+  if (p.isCancel(raw)) cancel2();
+  return raw.split(",").map((l) => l.trim()).filter(Boolean);
+}
+async function defineChannels(ctx, easJson, platforms) {
+  const build = easJson.build ?? {};
+  const profileNames = Object.keys(build).filter((name) => name !== "development");
+  p.log.info(`build profiles encontrados no eas.json: ${profileNames.join(", ") || "(nenhum)"}`);
+  const channels = {};
+  for (const name of profileNames) {
+    const use = await p.confirm({ message: `Criar o canal "${name}" a partir deste build profile?`, initialValue: true });
+    if (p.isCancel(use) || !use) continue;
+    const isProtected = await p.confirm({ message: `"${name}" \xE9 um canal protegido (produ\xE7\xE3o \u2014 gate fail-closed)?`, initialValue: name === "production" });
+    if (p.isCancel(isProtected)) cancel2();
+    const goesToStore = await p.confirm({ message: `"${name}" envia \xE0 loja (submit)?`, initialValue: true });
+    if (p.isCancel(goesToStore)) cancel2();
+    const channel = {
+      protected: isProtected,
+      store: goesToStore,
+      buildProfile: name,
+      submitProfile: name,
+      env: {}
+    };
+    if (goesToStore) {
+      for (const platform of platforms) {
+        const envForConfig = await tryResolveEnv(ctx, platform, name);
+        if (platform === "ios") {
+          const bundleId = await promptText(`bundleId iOS para "${name}"`, envForConfig?.ios?.bundleIdentifier);
+          channel.ios = { bundleId, phasedRelease: isProtected, automaticRelease: false };
+        }
+        if (platform === "android") {
+          const packageName = await promptText(`package Android para "${name}"`, envForConfig?.android?.package);
+          channel.android = { package: packageName, testTrack: "internal", productionTrack: isProtected ? "production" : "internal", initialRollout: isProtected ? 0.1 : 1 };
+        }
+      }
+    }
+    channels[name] = channelSchema.parse(channel);
+  }
+  if (Object.keys(channels).length === 0) cancel2("Nenhum canal configurado \u2014 o kit precisa de ao menos um.");
+  return channels;
+}
+async function tryResolveEnv(ctx, platform, profileName) {
+  try {
+    return resolveExpoConfig(ctx, { APP_VARIANT: profileName });
+  } catch {
+    return null;
+  }
+}
+async function runAppleCredentialsStep(ctx, slug, channels, envUpdates) {
+  p.log.step("App Store Connect API Key");
+  p.log.info('Crie em https://appstoreconnect.apple.com/access/integrations/api \u2014 role "App Manager" (ou "Admin").');
+  const keyId = await promptText("ASC_KEY_ID (Key ID)");
+  const issuerId = await promptText("ASC_ISSUER_ID (Issuer ID)");
+  const keyPathRaw = await promptText("Caminho do arquivo .p8 baixado");
+  const keyPath = resolve2(keyPathRaw);
+  if (!existsSync6(keyPath)) cancel2(`Arquivo n\xE3o encontrado: ${keyPath}`);
+  const privateKeyPem = readFileSync5(keyPath, "utf8");
+  const client = new AppStoreConnectClient({ credentials: { keyId, issuerId, privateKeyPem } });
+  const spinner2 = p.spinner();
+  spinner2.start("Validando chave contra a App Store Connect API");
+  try {
+    for (const [name, channel] of Object.entries(channels)) {
+      if (!channel.ios) continue;
+      const app = await findAppByBundleId(client, channel.ios.bundleId);
+      if (!app) {
+        spinner2.stop(`Chave v\xE1lida, mas nenhum app com bundleId ${channel.ios.bundleId} encontrado (canal "${name}").`, 1);
+        const proceed = await p.confirm({ message: "Continuar assim mesmo? (o app pode ainda n\xE3o existir no App Store Connect)" });
+        if (p.isCancel(proceed) || !proceed) cancel2();
+        spinner2.start("Continuando");
+      } else {
+        channel.ios.ascAppId = app.id;
+      }
+    }
+    spinner2.stop("App Store Connect: chave validada.");
+  } catch (error) {
+    spinner2.stop(`Falha ao validar a chave: ${error.message}`, 1);
+    cancel2();
+  }
+  const dest = storeCredentialFile(slug, keyPath, `AuthKey_${keyId}.p8`);
+  envUpdates.ASC_KEY_ID = keyId;
+  envUpdates.ASC_ISSUER_ID = issuerId;
+  envUpdates.ASC_KEY_PATH = dest;
+  p.log.success(`.p8 copiada para ${dest} (fora do reposit\xF3rio).`);
+}
+async function runGoogleCredentialsStep(slug, channels, envUpdates) {
+  p.log.step("Google Play service account");
+  p.log.info("Crie em Google Cloud Console \u2192 IAM \u2192 Service Accounts, e conceda acesso em Play Console \u2192 Utilizadores e permiss\xF5es.");
+  const jsonPathRaw = await promptText("Caminho do JSON da service account");
+  const jsonPath = resolve2(jsonPathRaw);
+  if (!existsSync6(jsonPath)) cancel2(`Arquivo n\xE3o encontrado: ${jsonPath}`);
+  const account = parseServiceAccountJson(readFileSync5(jsonPath, "utf8"));
+  const client = new AndroidPublisherClient({ account });
+  const spinner2 = p.spinner();
+  spinner2.start("Validando acesso \xE0 Android Publisher API");
+  try {
+    for (const [name, channel] of Object.entries(channels)) {
+      if (!channel.android) continue;
+      try {
+        await validatePlayAccess(client, channel.android.package);
+      } catch (error) {
+        spinner2.stop(`Falha ao acessar o package ${channel.android.package} (canal "${name}"): ${error.message}`, 1);
+        p.log.warn("Causas comuns: app ainda n\xE3o criado na Play, primeiro AAB nunca enviado manualmente, ou a service account sem permiss\xE3o no Play Console.");
+        const proceed = await p.confirm({ message: "Continuar assim mesmo?" });
+        if (p.isCancel(proceed) || !proceed) cancel2();
+        spinner2.start("Continuando");
+      }
+    }
+    spinner2.stop("Google Play: acesso validado.");
+  } catch (error) {
+    spinner2.stop(`Falha: ${error.message}`, 1);
+    cancel2();
+  }
+  const dest = storeCredentialFile(slug, jsonPath, "play-service-account.json");
+  envUpdates.GOOGLE_PLAY_JSON_KEY = dest;
+  p.log.success(`JSON copiado para ${dest} (fora do reposit\xF3rio).`);
+}
+function ensureGitignoreEntries(repoRoot) {
+  const path = join6(repoRoot, ".gitignore");
+  const entries = [".env.release", ".release/"];
+  const current = existsSync6(path) ? readFileSync5(path, "utf8") : "";
+  const missing = entries.filter((entry) => !current.includes(entry));
+  if (missing.length === 0) return;
+  writeFileSync4(path, `${current}${current.endsWith("\n") || current === "" ? "" : "\n"}${missing.join("\n")}
+`);
+}
+function addReleaseScript(repoRoot, packageManager) {
+  const path = join6(repoRoot, "package.json");
+  if (!existsSync6(path)) return;
+  const json = JSON.parse(readFileSync5(path, "utf8"));
+  json.scripts = json.scripts ?? {};
+  if (!json.scripts.release) {
+    json.scripts.release = "release-kit";
+    writeFileSync4(path, `${JSON.stringify(json, null, "	")}
+`);
+  }
+  void packageManager;
+}
+
+// src/cli/credentials.ts
+import * as p2 from "@clack/prompts";
+import pc3 from "picocolors";
+init_store();
+async function runCredentialsCommand(scope) {
+  p2.intro(pc3.bold(`release-kit credentials ${scope ?? ""}`));
+  const base = buildContext({});
+  const config = loadConfig(base.repoRoot);
+  const ctx = withAppDir(base, config);
+  const slug = ctx.repoRoot.split("/").filter(Boolean).pop() ?? "release-kit-project";
+  const envUpdates = {};
+  if (!scope || scope === "expo") {
+    await ensureEasLogin(ctx);
+  }
+  if (!scope || scope === "apple") {
+    if (config.platforms.includes("ios")) await runAppleCredentialsStep(ctx, slug, config.channels, envUpdates);
+    else p2.log.warn("config.platforms n\xE3o inclui ios \u2014 nada a validar.");
+  }
+  if (!scope || scope === "google") {
+    if (config.platforms.includes("android")) await runGoogleCredentialsStep(slug, config.channels, envUpdates);
+    else p2.log.warn("config.platforms n\xE3o inclui android \u2014 nada a validar.");
+  }
+  if (scope === "sync") {
+    p2.log.info("Rode `eas credentials` (ASC key / Play SA) e `eas env:create` para sincronizar com builds na nuvem.");
+  }
+  if (Object.keys(envUpdates).length > 0) {
+    writeEnvFile(ctx.repoRoot, envUpdates);
+    writeConfig(ctx.repoRoot, config);
+    p2.log.success(".env.release e release-kit.config.json atualizados.");
+  }
+  p2.outro("Credenciais atualizadas.");
+}
+
+// src/cli/menu.ts
+import * as p3 from "@clack/prompts";
+import pc4 from "picocolors";
+
+// src/release/version.ts
+init_run();
+import { relative } from "path";
+function bumpVersion(ctx, config, opts) {
+  if (!isWorkingTreeClean(ctx)) {
+    fail("working tree suja. Commit ou descarte as mudan\xE7as antes de rodar `release-kit version`.");
+  }
+  const current = readAppVersion(ctx.appDir, config);
+  const next = nextVersion(current, opts.bump);
+  const tag = renderTag(config.git.tagFormat, next);
+  if (ctx.dryRun) {
+    ctx.log.info(`[dry-run] ${current} \u2192 ${next} (tag ${tag})`);
+    return { from: current, to: next, tag, dryRun: true };
+  }
+  const path = writeAppVersion(ctx.appDir, config, next);
+  const relPath = relative(ctx.repoRoot, path);
+  git(ctx, ["add", relPath]);
+  git(ctx, ["commit", "-m", `chore(release): ${tag}`]);
+  git(ctx, ["tag", tag]);
+  ctx.log.success(`${current} \u2192 ${next} (commit + tag ${tag})`);
+  if (opts.push) {
+    requireSuccess(git(ctx, ["push", config.git.remote, config.git.releaseBranch]), "git push");
+    requireSuccess(git(ctx, ["push", config.git.remote, tag]), "git push tag");
+    ctx.log.success(`push ${config.git.remote} ${config.git.releaseBranch} + tag ${tag}`);
+  }
+  return { from: current, to: next, tag };
+}
+
+// src/release/notes.ts
+import { existsSync as existsSync8 } from "fs";
+
+// src/git/commits.ts
+var CONVENTIONAL_RE = /^(\w+)(?:\(([^)]+)\))?!?:\s*(.+)$/;
+function parseSubject(subject) {
+  const match = subject.match(CONVENTIONAL_RE);
+  if (!match) return { type: null, scope: null, description: subject };
+  const [, type, scope, description] = match;
+  return { type: type ?? null, scope: scope ?? null, description: description ?? subject };
+}
+function commitsSinceLastTag(ctx, tagFormat) {
+  const lastTag = lastTagMatching(ctx, tagFormat);
+  const range = lastTag ? `${lastTag}..HEAD` : "HEAD";
+  const result = git(ctx, ["log", range, "--pretty=format:%h %s"], { allowFail: true });
+  if (result.status !== 0) return [];
+  return result.stdout.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const [sha, ...rest] = line.split(" ");
+    const subject = rest.join(" ");
+    const parsed = parseSubject(subject);
+    return { sha: sha ?? "", subject, ...parsed };
+  });
+}
+var USER_FACING_TYPES = /* @__PURE__ */ new Set(["feat", "fix"]);
+function userFacingCommits(commits) {
+  return commits.filter((commit) => commit.type && USER_FACING_TYPES.has(commit.type));
+}
+
+// src/notes/draft.ts
+function draftNotes(commits, version) {
+  const facing = userFacingCommits(commits);
+  if (facing.length === 0) {
+    return `Novidades da vers\xE3o ${version}
+
+(sem commits feat/fix desde a \xFAltima tag \u2014 escreva as notas manualmente)
+`;
+  }
+  const features = facing.filter((c) => c.type === "feat");
+  const fixes = facing.filter((c) => c.type === "fix");
+  const lines = [`Novidades da vers\xE3o ${version}`, ""];
+  if (features.length) {
+    lines.push("Novidades:");
+    for (const commit of features) lines.push(`- ${capitalize(commit.description)}`);
+    lines.push("");
+  }
+  if (fixes.length) {
+    lines.push("Corre\xE7\xF5es:");
+    for (const commit of fixes) lines.push(`- ${capitalize(commit.description)}`);
+    lines.push("");
+  }
+  lines.push("# Revise este rascunho antes de publicar \u2014 ele vem direto dos commits (feat/fix) e n\xE3o foi reescrito em linguagem de usu\xE1rio.");
+  return lines.join("\n");
+}
+function capitalize(text2) {
+  if (!text2) return text2;
+  return text2[0].toUpperCase() + text2.slice(1);
+}
+
+// src/notes/editor.ts
+init_run();
+function defaultEditor() {
+  if (process.platform === "win32") return "notepad";
+  return "nano";
+}
+function openInEditor(ctx, path) {
+  const editor = ctx.env.EDITOR || ctx.env.VISUAL || defaultEditor();
+  const [command, ...args] = editor.split(" ");
+  if (!command) return;
+  requireSuccess(ctx.run(command, [...args, path], { inherit: true }), `${editor} ${path}`);
+}
+
+// src/notes/paths.ts
+init_run();
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
+function notesDirFor(appDir, notesDir, version) {
+  return join7(appDir, notesDir, version);
+}
+function notesFilePath(appDir, notesDir, version, locale, target) {
+  return join7(notesDirFor(appDir, notesDir, version), `${locale}.${target}.txt`);
+}
+function readNotesFile(path) {
+  if (!existsSync7(path)) fail(`Notas n\xE3o encontradas: ${path}. Rode \`release-kit notes\` primeiro.`);
+  const text2 = readFileSync6(path, "utf8").trim();
+  if (!text2) fail(`Notas vazias em ${path}.`);
+  return text2;
+}
+function writeNotesFile(path, text2) {
+  mkdirSync3(join7(path, ".."), { recursive: true });
+  writeFileSync5(path, `${text2.trim()}
+`);
+}
+
+// src/release/notes.ts
+function targetsFor(config) {
+  const targets = [];
+  if (config.platforms.includes("ios")) targets.push("ios");
+  if (config.platforms.includes("android")) targets.push("play");
+  return targets;
+}
+function draftAndEditNotes(ctx, config, opts) {
+  const version = opts.version ?? readAppVersion(ctx.appDir, config);
+  const commits = commitsSinceLastTag(ctx, config.git.tagFormat);
+  const targets = targetsFor(config);
+  const files = [];
+  for (const locale of config.locales) {
+    for (const target of targets) {
+      const path = notesFilePath(ctx.appDir, config.notesDir, version, locale, target);
+      const isNew = !existsSync8(path);
+      if (isNew) {
+        writeNotesFile(path, draftNotes(commits, version));
+        ctx.log.step(`rascunho criado: ${path}`);
+      }
+      if (!opts.skipEditor && (isNew || opts.edit)) {
+        openInEditor(ctx, path);
+      }
+      const text2 = readNotesFile(path);
+      assertNotesWithinLimit(text2, target, locale);
+      files.push({ path, target, locale });
+    }
+  }
+  return { version, files };
+}
+
+// src/release/build.ts
+init_run();
+import { copyFileSync as copyFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync5, unlinkSync } from "fs";
+import { dirname, join as join9, resolve as resolve3 } from "path";
+
+// src/eas/profiles.ts
+init_run();
+function resolveBuildProfileChain(easJson, profileName) {
+  const build = easJson.build ?? {};
+  const profile = build[profileName];
+  if (!profile) fail(`build profile "${profileName}" n\xE3o existe no eas.json.`);
+  const chain = [profile];
+  let cursor = profile;
+  const seen = /* @__PURE__ */ new Set([profileName]);
+  while (cursor?.extends) {
+    const parentName = cursor.extends;
+    if (seen.has(parentName)) break;
+    seen.add(parentName);
+    const parent = build[parentName];
+    if (!parent) break;
+    chain.push(parent);
+    cursor = parent;
+  }
+  const merged = {};
+  for (const step of chain.slice().reverse()) {
+    Object.assign(merged, step);
+    if (step.android) merged.android = { ...merged.android, ...step.android };
+    if (step.ios) merged.ios = { ...merged.ios, ...step.ios };
+  }
+  return merged;
+}
+function androidBuildTypeExt(easJson, profileName) {
+  const resolved = resolveBuildProfileChain(easJson, profileName);
+  return resolved.android?.buildType === "apk" ? "apk" : "aab";
+}
+
+// src/release/gate.ts
+init_run();
+function assertChannelOptIn(ctx, config, channel, opts) {
+  if (!channel.protected) return;
+  if (opts.iKnowThisIsProduction) return;
+  const version = readAppVersion(ctx.appDir, config);
+  if (opts.confirmVersion && opts.confirmVersion.trim() === version) return;
+  fail(
+    `canal protegido: passe --i-know-this-is-production (n\xE3o-interativo) ou confirme digitando a vers\xE3o exata (${version}). \`release-kit\` sem argumentos nunca resolve para um canal protegido.`
+  );
+}
+async function confirmProtectedChannelVersion(ctx, config, channelName) {
+  const channel = channelOf(config, channelName);
+  if (!channel.protected) return "";
+  const version = readAppVersion(ctx.appDir, config);
+  if (!ctx.confirm) return "";
+  ctx.log.warn(`canal "${channelName}" \xE9 protegido \u2014 gera bin\xE1rio/OTA de produ\xE7\xE3o.`);
+  const answer = await ctx.confirm(`Digite a vers\xE3o exatamente (${version}) para continuar: `);
+  return String(answer || "").trim();
+}
+
+// src/release/metadata.ts
+init_run();
+import { createHash } from "crypto";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync, writeFileSync as writeFileSync6 } from "fs";
+import { join as join8 } from "path";
+function sha256File(path) {
+  return createHash("sha256").update(readFileSync7(path)).digest("hex");
+}
+function gitInfo(ctx) {
+  const sha = git(ctx, ["rev-parse", "HEAD"]).stdout.trim();
+  const branch = git(ctx, ["rev-parse", "--abbrev-ref", "HEAD"]).stdout.trim();
+  const tagResult = git(ctx, ["tag", "--points-at", "HEAD"], { allowFail: true });
+  const tag = (tagResult.stdout || "").split("\n").map((line) => line.trim()).find((line) => /^v\d/.test(line)) || "";
+  return { sha, branch, tag };
+}
+function writeMetadata(dir, payload) {
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync6(join8(dir, "metadata.json"), `${JSON.stringify(payload, null, 2)}
+`);
+  return payload;
+}
+function findLatestMetadata(releaseDir, { channel, platform } = {}) {
+  if (!existsSync9(releaseDir)) fail(`Nenhum artefato em ${releaseDir}. Rode \`release-kit build\` primeiro.`);
+  const entries = readdirSync2(releaseDir).map((name) => {
+    const dir = join8(releaseDir, name);
+    const metaPath = join8(dir, "metadata.json");
+    if (!statSync(dir).isDirectory() || !existsSync9(metaPath)) return null;
+    const metadata = JSON.parse(readFileSync7(metaPath, "utf8"));
+    if (platform && metadata.platform !== platform) return null;
+    if (channel && metadata.channel !== channel) return null;
+    return { dir, metaPath, metadata, createdAt: metadata.createdAt || "" };
+  }).filter((entry) => entry !== null).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  const [first] = entries;
+  if (!first) {
+    fail(`Nenhum metadata.json${platform ? ` para ${platform}` : ""}${channel ? ` (canal ${channel})` : ""} em ${releaseDir}.`);
+  }
+  return first;
+}
+
+// src/release/build.ts
+function artifactExt(ctx, platform, buildProfile) {
+  if (platform === "ios") return "ipa";
+  const easJson = readEasJson(ctx.appDir);
+  if (!easJson) fail(`eas.json n\xE3o encontrado em ${ctx.appDir}.`);
+  return androidBuildTypeExt(easJson, buildProfile);
+}
+function buildRelease(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  if (!config.platforms.includes(opts.platform)) {
+    fail(`--platform ${opts.platform} n\xE3o est\xE1 em config.platforms.`);
+  }
+  const ext = artifactExt(ctx, opts.platform, channel.buildProfile);
+  const staging = opts.output ? resolve3(ctx.repoRoot, opts.output) : join9(ctx.releaseDir, `_building-${opts.platform}-${opts.channel}.${ext}`);
+  const local = !opts.cloud;
+  if (ctx.dryRun) {
+    const env = channel.env;
+    const command = formatCommand("eas", ["build", "-p", opts.platform, "--profile", channel.buildProfile, ...local ? ["--local"] : [], "--output", staging], env);
+    ctx.log.info(`[dry-run] cd ${ctx.appDir} && ${command}`);
+    return { dryRun: true, command, staging };
+  }
+  mkdirSync5(dirname(staging), { recursive: true });
+  ctx.log.step(`eas build ${local ? "--local" : "(cloud)"} (${opts.platform}/${opts.channel})`);
+  requireSuccess(
+    easBuild(ctx, { platform: opts.platform, buildProfile: channel.buildProfile, local, output: local ? staging : void 0, env: channel.env }),
+    "eas build"
+  );
+  if (local && !existsSync10(staging)) fail(`Build concluiu sem artefato em ${staging}.`);
+  const remote = projectRemoteVersion(ctx, { platform: opts.platform, buildProfile: channel.buildProfile });
+  const version = readAppVersion(ctx.appDir, config);
+  const versionCode = remote.versionCode;
+  const buildNumber = opts.platform === "ios" ? remote.buildNumber : remote.versionCode;
+  const git2 = gitInfo(ctx);
+  const dirName = `${opts.platform}-${opts.channel}-${version}-${buildNumber || "unknown"}`;
+  const finalDir = join9(ctx.releaseDir, dirName);
+  mkdirSync5(finalDir, { recursive: true });
+  const finalPath = local ? join9(finalDir, `app.${ext}`) : "";
+  if (local && resolve3(staging) !== resolve3(finalPath)) {
+    copyFileSync2(staging, finalPath);
+    if (staging.includes("_building-")) {
+      try {
+        unlinkSync(staging);
+      } catch {
+      }
+    }
+  }
+  const metadata = writeMetadata(finalDir, {
+    platform: opts.platform,
+    channel: opts.channel,
+    buildProfile: channel.buildProfile,
+    version,
+    buildNumber,
+    versionCode,
+    artifactPath: finalPath,
+    sha256: local && existsSync10(finalPath) ? sha256File(finalPath) : "",
+    commitSha: git2.sha,
+    branch: git2.branch,
+    tag: git2.tag,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    toolchain: collectToolchain(ctx),
+    toolchainDrift: Boolean(opts.toolchainDrift)
+  });
+  if (local) {
+    ctx.log.success(`artefato ${finalPath}`);
+  } else {
+    ctx.log.success("build enviado ao EAS Build Cloud \u2014 use `eas build:list` para acompanhar e baixar o artefato.");
+  }
+  ctx.log.success(`metadata ${join9(finalDir, "metadata.json")}`);
+  return { artifactPath: finalPath, metadata };
+}
+
+// src/release/submit.ts
+init_run();
+import { existsSync as existsSync11 } from "fs";
+import { resolve as resolve4 } from "path";
+function inferPlatformFromArtifact(artifactPath) {
+  const lower = artifactPath.toLowerCase();
+  if (lower.endsWith(".apk")) {
+    fail("Submit Android exige AAB. O profile de sideload n\xE3o vai \xE0 loja; gere o bin\xE1rio com um profile de release/production.");
+  }
+  if (lower.endsWith(".aab")) return "android";
+  if (lower.endsWith(".ipa")) return "ios";
+  fail("submit --path exige um arquivo .aab ou .ipa.");
+}
+function submitRelease(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  if (!channel.store) {
+    fail(`canal "${opts.channel}" n\xE3o envia \xE0 loja (store: false).`);
+  }
+  const submitProfile = channel.submitProfile ?? channel.buildProfile;
+  let artifactPath;
+  let platform;
+  if (opts.path) {
+    artifactPath = resolve4(ctx.repoRoot, opts.path);
+    if (!existsSync11(artifactPath)) fail(`Artefato n\xE3o encontrado: ${artifactPath}.`);
+    platform = inferPlatformFromArtifact(artifactPath);
+    if (opts.platform && opts.platform !== platform) {
+      fail(`--platform ${opts.platform} n\xE3o corresponde ao arquivo (${platform}).`);
+    }
+  } else {
+    const entry = findLatestMetadata(ctx.releaseDir, { channel: opts.channel, platform: opts.platform });
+    const metadata = entry.metadata;
+    artifactPath = metadata.artifactPath;
+    platform = metadata.platform;
+    if (!artifactPath || !existsSync11(artifactPath)) {
+      fail(`Artefato n\xE3o encontrado: ${artifactPath || "(ausente no metadata)"}. Builds na nuvem n\xE3o t\xEAm artefato local \u2014 use --path ap\xF3s baixar.`);
+    }
+  }
+  if (platform === "android" && !artifactPath.toLowerCase().endsWith(".aab")) {
+    fail("Submit Android exige AAB.");
+  }
+  if (ctx.dryRun) {
+    const command = formatCommand("eas", ["submit", "-p", platform, "--profile", submitProfile, "--path", artifactPath], channel.env);
+    ctx.log.info(`[dry-run] cd ${ctx.appDir} && ${command}`);
+    return { dryRun: true, command, submitProfile, artifactPath };
+  }
+  ctx.log.step(`eas submit --path (${platform}/${submitProfile})`);
+  requireSuccess(easSubmit(ctx, { platform, submitProfile, path: artifactPath, env: channel.env }), "eas submit");
+  return { submitProfile, artifactPath };
+}
+
+// src/release/ship.ts
+init_run();
+function shipRelease(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  if (!channel.store) {
+    fail(`canal "${opts.channel}" n\xE3o envia \xE0 loja (store: false). Use \`release-kit build\` direto para gerar o artefato de sideload.`);
+  }
+  let toolchainDrift = opts.toolchainDrift;
+  if (!opts.skipDoctor) {
+    const report = runDoctor(ctx, config, {
+      channel: opts.channel,
+      platform: opts.platform,
+      allowToolchainDrift: opts.allowToolchainDrift
+    });
+    requireDoctorPass(report);
+    toolchainDrift = report.toolchainDrift;
+  }
+  const built = buildRelease(ctx, config, { ...opts, toolchainDrift });
+  if (ctx.dryRun) return { dryRun: true, artifactPath: built.artifactPath };
+  const submitted = submitRelease(ctx, config, {
+    channel: opts.channel,
+    platform: opts.platform,
+    latest: true,
+    iKnowThisIsProduction: opts.iKnowThisIsProduction,
+    confirmVersion: opts.confirmVersion
+  });
+  return { artifactPath: built.artifactPath, submit: submitted };
+}
+
+// src/release/promote.ts
+init_run();
+
+// src/stores/credentials.ts
+init_run();
+init_store();
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
+function createAppleClient(env) {
+  const keyId = env.ASC_KEY_ID;
+  const issuerId = env.ASC_ISSUER_ID;
+  if (!keyId || !issuerId) {
+    fail("Credenciais App Store Connect ausentes: ASC_KEY_ID, ASC_ISSUER_ID. Rode `release-kit credentials apple`.");
+  }
+  const resolved = resolveFileCredential(env, "ASC_KEY_PATH", "ASC_KEY_P8_CONTENT", "AuthKey.p8");
+  if (!resolved) {
+    fail("Credencial ASC_KEY_PATH (ou ASC_KEY_P8_CONTENT em CI) ausente. Rode `release-kit credentials apple`.");
+  }
+  if (!existsSync12(resolved.path)) fail(`ASC_KEY_PATH n\xE3o existe: ${resolved.path}`);
+  const privateKeyPem = readFileSync8(resolved.path, "utf8");
+  const client = new AppStoreConnectClient({ credentials: { keyId, issuerId, privateKeyPem } });
+  return Object.assign(client, { cleanup: resolved.cleanup });
+}
+function createGoogleClient(env) {
+  const resolved = resolveFileCredential(env, "GOOGLE_PLAY_JSON_KEY", "GOOGLE_PLAY_JSON_CONTENT", "play-service-account.json");
+  if (!resolved) {
+    fail(
+      "Credencial GOOGLE_PLAY_JSON_KEY (ou GOOGLE_PLAY_JSON_CONTENT em CI) ausente. Rode `release-kit credentials google`."
+    );
+  }
+  if (!existsSync12(resolved.path)) fail(`GOOGLE_PLAY_JSON_KEY n\xE3o existe: ${resolved.path}`);
+  const account = parseServiceAccountJson(readFileSync8(resolved.path, "utf8"));
+  const client = new AndroidPublisherClient({ account });
+  return Object.assign(client, { cleanup: resolved.cleanup });
+}
+
+// src/stores/apple/review.ts
+init_run();
+var IN_PROGRESS_STATES = /* @__PURE__ */ new Set(["READY_FOR_REVIEW", "WAITING_FOR_REVIEW", "IN_REVIEW", "PROCESSING"]);
+var TERMINAL_STATES = /* @__PURE__ */ new Set(["COMPLETE", "CANCELED"]);
+async function submitForReview(client, input) {
+  const app = await requireAppByBundleId(client, input.bundleId);
+  const inProgress = await findInProgressReviewSubmission(client, app.id);
+  if (inProgress) {
+    return {
+      appId: app.id,
+      appStoreVersionId: "",
+      buildId: "",
+      submissionId: inProgress.id,
+      state: inProgress.attributes.state,
+      alreadyInProgress: true
+    };
+  }
+  const version = await ensureAppStoreVersion(client, app.id, input.versionString);
+  if (input.copyright && !version.attributes.copyright) {
+    await client.patch(`/appStoreVersions/${version.id}`, {
+      data: { id: version.id, type: "appStoreVersions", attributes: { copyright: input.copyright } }
+    });
+  }
+  await client.patch(`/appStoreVersions/${version.id}`, {
+    data: {
+      id: version.id,
+      type: "appStoreVersions",
+      attributes: { releaseType: input.automaticRelease ? "AFTER_APPROVAL" : "MANUAL" }
+    }
+  });
+  const build = await findValidBuild(client, app.id, input.versionString);
+  if (!build) fail(`Nenhum build VALID no TestFlight para a vers\xE3o ${input.versionString}.`);
+  await client.request("POST", `/appStoreVersions/${version.id}/relationships/build`, {
+    data: { id: build.id, type: "builds" }
+  });
+  if (input.phasedRelease) {
+    await client.post("/appStoreVersionPhasedReleases", {
+      data: {
+        type: "appStoreVersionPhasedReleases",
+        relationships: { appStoreVersion: { data: { id: version.id, type: "appStoreVersions" } } }
+      }
+    });
+  }
+  for (const [locale, whatsNew] of Object.entries(input.whatsNewByLocale)) {
+    const localization = await findLocalization(client, version.id, locale);
+    if (!localization) fail(`Localization ${locale} ausente na vers\xE3o ${input.versionString} do App Store Connect.`);
+    await client.patch(`/appStoreVersionLocalizations/${localization.id}`, {
+      data: { id: localization.id, type: "appStoreVersionLocalizations", attributes: { whatsNew } }
+    });
+  }
+  const submission = await createReviewSubmission(client, app.id);
+  await client.post("/reviewSubmissionItems", {
+    data: {
+      type: "reviewSubmissionItems",
+      relationships: {
+        reviewSubmission: { data: { id: submission.id, type: "reviewSubmissions" } },
+        appStoreVersion: { data: { id: version.id, type: "appStoreVersions" } }
+      }
+    }
+  });
+  const submitted = await client.patch(`/reviewSubmissions/${submission.id}`, {
+    data: { id: submission.id, type: "reviewSubmissions", attributes: { submitted: true } }
+  });
+  return {
+    appId: app.id,
+    appStoreVersionId: version.id,
+    buildId: build.id,
+    submissionId: submission.id,
+    state: submitted.data.attributes.state,
+    alreadyInProgress: false
+  };
+}
+async function getIosStatus(client, bundleId, versionString) {
+  const app = await requireAppByBundleId(client, bundleId);
+  const version = await findAppStoreVersion(client, app.id, versionString);
+  const inProgress = await findInProgressReviewSubmission(client, app.id);
+  return {
+    appId: app.id,
+    versionString,
+    appStoreState: version?.attributes.appStoreState ?? null,
+    reviewSubmissionState: inProgress?.attributes.state ?? null
+  };
+}
+async function findInProgressReviewSubmission(client, appId) {
+  const result = await client.get(
+    `/apps/${appId}/reviewSubmissions?filter[platform]=IOS`
+  );
+  const active = result.data.find(
+    (item) => IN_PROGRESS_STATES.has(item.attributes.state) && !TERMINAL_STATES.has(item.attributes.state)
+  );
+  return active ?? null;
+}
+async function ensureAppStoreVersion(client, appId, versionString) {
+  const existing = await findAppStoreVersion(client, appId, versionString);
+  if (existing) return existing;
+  const created = await client.post("/appStoreVersions", {
+    data: {
+      type: "appStoreVersions",
+      attributes: { platform: "IOS", versionString },
+      relationships: { app: { data: { id: appId, type: "apps" } } }
+    }
+  });
+  return { id: created.data.id, attributes: created.data.attributes };
+}
+async function findAppStoreVersion(client, appId, versionString) {
+  const result = await client.get(
+    `/apps/${appId}/appStoreVersions?filter[versionString]=${encodeURIComponent(versionString)}&filter[platform]=IOS`
+  );
+  const [version] = result.data;
+  return version ? { id: version.id, attributes: version.attributes } : null;
+}
+async function findValidBuild(client, appId, versionString) {
+  const result = await client.get(
+    `/builds?filter[app]=${appId}&filter[preReleaseVersion.version]=${encodeURIComponent(versionString)}&sort=-uploadedDate&limit=20`
+  );
+  const valid = result.data.find((item) => item.attributes.processingState === "VALID");
+  const build = valid ?? result.data[0];
+  return build ? { id: build.id, attributes: build.attributes } : null;
+}
+async function findLocalization(client, versionId, locale) {
+  const result = await client.get(
+    `/appStoreVersions/${versionId}/appStoreVersionLocalizations`
+  );
+  const match = result.data.find((item) => item.attributes.locale === locale);
+  return match ? { id: match.id, attributes: match.attributes } : null;
+}
+async function createReviewSubmission(client, appId) {
+  const created = await client.post("/reviewSubmissions", {
+    data: {
+      type: "reviewSubmissions",
+      attributes: { platform: "IOS" },
+      relationships: { app: { data: { id: appId, type: "apps" } } }
+    }
+  });
+  return { id: created.data.id, attributes: created.data.attributes };
+}
+
+// src/release/promote.ts
+function notesByLocale(ctx, config, version, target) {
+  const result = {};
+  for (const locale of config.locales) {
+    const path = notesFilePath(ctx.appDir, config.notesDir, version, locale, target);
+    result[locale] = readNotesFile(path);
+  }
+  return result;
+}
+async function promoteRelease2(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  const version = readAppVersion(ctx.appDir, config);
+  const result = {};
+  const wantsAndroid = (!opts.platform || opts.platform === "android") && channel.android;
+  const wantsIos = (!opts.platform || opts.platform === "ios") && channel.ios;
+  if (!wantsAndroid && !wantsIos) fail("nenhuma plataforma configurada no canal para promover.");
+  if (ctx.dryRun) {
+    if (wantsAndroid) ctx.log.info(`[dry-run] Play: promover ${channel.android.testTrack} \u2192 ${channel.android.productionTrack} (${channel.android.package})`);
+    if (wantsIos) ctx.log.info(`[dry-run] Apple: criar Review Submission para ${channel.ios.bundleId} v${version}`);
+    return result;
+  }
+  if (wantsAndroid) {
+    const android = channel.android;
+    const google = createGoogleClient(ctx.env);
+    try {
+      const notes = notesByLocale(ctx, config, version, "play");
+      ctx.log.step(`Play: promovendo ${android.testTrack} \u2192 ${android.productionTrack}`);
+      const release = await promoteRelease(google, {
+        packageName: android.package,
+        fromTrack: android.testTrack,
+        toTrack: android.productionTrack,
+        notesByLocale: notes,
+        initialRollout: android.initialRollout
+      });
+      ctx.log.success(`Play: ${android.productionTrack} status=${release.status} versionCodes=${(release.versionCodes ?? []).join(",")}`);
+      result.android = { versionCodes: release.versionCodes, status: release.status };
+    } finally {
+      google.cleanup();
+    }
+  }
+  if (wantsIos) {
+    const ios = channel.ios;
+    const apple = createAppleClient(ctx.env);
+    try {
+      const notes = notesByLocale(ctx, config, version, "ios");
+      ctx.log.step(`Apple: enviando Review Submission para ${ios.bundleId} v${version}`);
+      const submission = await submitForReview(apple, {
+        bundleId: ios.bundleId,
+        versionString: version,
+        whatsNewByLocale: notes,
+        automaticRelease: ios.automaticRelease,
+        phasedRelease: ios.phasedRelease,
+        copyright: ios.copyright
+      });
+      if (submission.alreadyInProgress) {
+        ctx.log.warn(`Apple: j\xE1 existe submission em an\xE1lise (${submission.submissionId}, state=${submission.state}).`);
+      } else {
+        ctx.log.success(`Apple: submission ${submission.submissionId} enviada (state=${submission.state}).`);
+      }
+      result.ios = { submissionId: submission.submissionId, state: submission.state, alreadyInProgress: submission.alreadyInProgress };
+    } finally {
+      apple.cleanup();
+    }
+  }
+  return result;
+}
+
+// src/release/rollout.ts
+init_run();
+async function rolloutRelease(ctx, config, opts) {
+  if (opts.platform !== "android") {
+    fail("rollout percentual s\xF3 \xE9 suportado para Android nesta vers\xE3o. iOS: acompanhe o phased release no App Store Connect.");
+  }
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  if (!channel.android) fail(`canal "${opts.channel}" n\xE3o tem configura\xE7\xE3o android.`);
+  if (ctx.dryRun) {
+    ctx.log.info(`[dry-run] Play: ${channel.android.productionTrack} \u2192 ${opts.to}`);
+    return { dryRun: true };
+  }
+  const google = createGoogleClient(ctx.env);
+  try {
+    const release = await setRollout(google, channel.android.package, channel.android.productionTrack, opts.to);
+    ctx.log.success(`Play: ${channel.android.productionTrack} agora ${release.status}${release.userFraction ? ` (${Math.round(release.userFraction * 100)}%)` : ""}`);
+    return release;
+  } finally {
+    google.cleanup();
+  }
+}
+
+// src/release/status.ts
+async function statusOf(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  const version = readAppVersion(ctx.appDir, config);
+  const result = { version };
+  if (channel.android) {
+    const google = createGoogleClient(ctx.env);
+    try {
+      const track = await getTrackStatus(google, channel.android.package, channel.android.productionTrack);
+      result.android = {
+        track: channel.android.productionTrack,
+        releases: (track.releases ?? []).map((release) => ({
+          status: release.status,
+          versionCodes: release.versionCodes,
+          userFraction: release.userFraction
+        }))
+      };
+    } finally {
+      google.cleanup();
+    }
+  }
+  if (channel.ios) {
+    const apple = createAppleClient(ctx.env);
+    try {
+      const status = await getIosStatus(apple, channel.ios.bundleId, version);
+      result.ios = { appStoreState: status.appStoreState, reviewSubmissionState: status.reviewSubmissionState };
+    } finally {
+      apple.cleanup();
+    }
+  }
+  return result;
+}
+function printStatus(ctx, status) {
+  ctx.log.info(`vers\xE3o: ${status.version}`);
+  if (status.android) {
+    ctx.log.info(`Play (${status.android.track}):`);
+    for (const release of status.android.releases) {
+      const fraction = release.userFraction ? ` (${Math.round(release.userFraction * 100)}%)` : "";
+      ctx.log.info(`  - ${release.status}${fraction} \u2014 versionCodes: ${(release.versionCodes ?? []).join(", ")}`);
+    }
+  }
+  if (status.ios) {
+    ctx.log.info(`App Store: appStoreState=${status.ios.appStoreState ?? "(sem vers\xE3o edit\xE1vel)"} reviewSubmission=${status.ios.reviewSubmissionState ?? "(nenhuma em andamento)"}`);
+  }
+}
+
+// src/release/update.ts
+init_run();
+function updateRelease(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  if (!channel.ota) {
+    fail(`canal "${opts.channel}" n\xE3o tem "ota.channel" configurado.`);
+  }
+  if (ctx.dryRun) {
+    const command = formatCommand("eas", ["update", "--channel", channel.ota.channel, "--message", opts.message ?? "(sem mensagem)"], channel.env);
+    ctx.log.info(`[dry-run] cd ${ctx.appDir} && ${command}`);
+    return { dryRun: true, command, channel: channel.ota.channel };
+  }
+  ctx.log.step(`eas update (channel ${channel.ota.channel})`);
+  requireSuccess(
+    easUpdate(ctx, { channel: channel.ota.channel, message: opts.message, platform: opts.platform, env: channel.env }),
+    "eas update"
+  );
+  return { channel: channel.ota.channel };
+}
+
+// src/cli/commands.ts
+init_run();
+function requirePlatform(flags) {
+  if (flags.platform !== "android" && flags.platform !== "ios") {
+    fail("--platform \xE9 obrigat\xF3rio (android|ios).");
+  }
+  return flags.platform;
+}
+function requireChannel(flags) {
+  if (!flags.channel) fail("--channel \xE9 obrigat\xF3rio.");
+  return flags.channel;
+}
+function runDoctorCommand(flags) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  const report = runDoctor(ctx, config, {
+    channel: flags.channel,
+    platform: flags.platform,
+    deep: flags.deep,
+    buildId: flags.buildId,
+    allowToolchainDrift: flags.allowToolchainDrift
+  });
+  if (!ctx.json) printDoctorReport(report, ctx);
+  if (!flags.dryRun) requireDoctorPass(report);
+  return report;
+}
+function runVersionCommand(flags, bump) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  return bumpVersion(ctx, config, { bump, push: flags.push });
+}
+function runNotesCommand(flags) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  return draftAndEditNotes(ctx, config, { version: flags.version, edit: flags.edit, skipEditor: flags.skipEditor });
+}
+function runBuildCommand(flags) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  const channel = requireChannel(flags);
+  const platform = requirePlatform(flags);
+  return buildRelease(ctx, config, {
+    channel,
+    platform,
+    cloud: flags.cloud,
+    output: flags.output,
+    iKnowThisIsProduction: flags.iKnowThisIsProduction,
+    confirmVersion: flags.confirmVersion
+  });
+}
+function runSubmitCommand(flags) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  const channel = requireChannel(flags);
+  if (!flags.latest && !flags.path) fail("`submit` exige --latest ou --path <aab|ipa>.");
+  return submitRelease(ctx, config, {
+    channel,
+    platform: flags.platform,
+    latest: flags.latest,
+    path: flags.path,
+    iKnowThisIsProduction: flags.iKnowThisIsProduction,
+    confirmVersion: flags.confirmVersion
+  });
+}
+function runShipCommand(flags) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  const channel = requireChannel(flags);
+  const platform = requirePlatform(flags);
+  return shipRelease(ctx, config, {
+    channel,
+    platform,
+    cloud: flags.cloud,
+    output: flags.output,
+    skipDoctor: flags.skipDoctor,
+    allowToolchainDrift: flags.allowToolchainDrift,
+    iKnowThisIsProduction: flags.iKnowThisIsProduction,
+    confirmVersion: flags.confirmVersion
+  });
+}
+function runPromoteCommand(flags) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  const channel = requireChannel(flags);
+  return promoteRelease2(ctx, config, {
+    channel,
+    platform: flags.platform,
+    iKnowThisIsProduction: flags.iKnowThisIsProduction,
+    confirmVersion: flags.confirmVersion
+  });
+}
+function runRolloutCommand(flags) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  const channel = requireChannel(flags);
+  const platform = requirePlatform(flags);
+  if (!flags.to) fail("`rollout` exige --to <0-1|complete|halt>.");
+  const to = flags.to === "complete" || flags.to === "halt" ? flags.to : Number(flags.to);
+  return rolloutRelease(ctx, config, {
+    channel,
+    platform,
+    to,
+    iKnowThisIsProduction: flags.iKnowThisIsProduction,
+    confirmVersion: flags.confirmVersion
+  });
+}
+async function runStatusCommand(flags) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  const channel = requireChannel(flags);
+  const status = await statusOf(ctx, config, { channel });
+  if (!ctx.json) printStatus(ctx, status);
+  return status;
+}
+function runUpdateCommand(flags) {
+  const { ctx, config } = loadContextAndConfig(flags);
+  const channel = requireChannel(flags);
+  return updateRelease(ctx, config, {
+    channel,
+    message: flags.message,
+    platform: flags.platform ?? "all",
+    iKnowThisIsProduction: flags.iKnowThisIsProduction,
+    confirmVersion: flags.confirmVersion
+  });
+}
+
+// src/cli/menu.ts
+async function runInteractiveMenu() {
+  p3.intro(pc4.bold("release-kit"));
+  const { ctx, config } = loadContextAndConfig({});
+  const version = readAppVersion(ctx.appDir, config);
+  p3.log.info(`vers\xE3o atual: ${version} \xB7 canais: ${Object.keys(config.channels).join(", ")}`);
+  const action = await p3.select({
+    message: "O que voc\xEA quer fazer?",
+    options: [
+      { value: "doctor", label: "doctor \u2014 preflight" },
+      { value: "version", label: "version \u2014 bump + tag" },
+      { value: "notes", label: "notes \u2014 rascunhar/editar notas de vers\xE3o" },
+      { value: "build", label: "build \u2014 gerar o bin\xE1rio" },
+      { value: "submit", label: "submit \u2014 enviar \xE0 faixa de teste" },
+      { value: "ship", label: "ship \u2014 doctor + build + submit" },
+      { value: "status", label: "status \u2014 ver review/rollout" },
+      { value: "update", label: "update \u2014 OTA" },
+      { value: "promote", label: "promote \u2014 produ\xE7\xE3o (App Review / Play production)" },
+      { value: "exit", label: "sa\xEDda" }
+    ]
+  });
+  if (p3.isCancel(action) || action === "exit") {
+    p3.outro("Nada feito.");
+    return;
+  }
+  const channelNames = Object.keys(config.channels);
+  const channel = await p3.select({
+    message: "Canal",
+    options: channelNames.map((name) => ({ value: name, label: `${name}${config.channels[name].protected ? " (protegido)" : ""}` }))
+  });
+  if (p3.isCancel(channel)) return;
+  const flags = { channel };
+  if (["build", "submit", "ship", "update"].includes(action)) {
+    if (config.platforms.length > 1) {
+      const platform = await p3.select({
+        message: "Plataforma",
+        options: config.platforms.map((pl) => ({ value: pl, label: pl }))
+      });
+      if (p3.isCancel(platform)) return;
+      flags.platform = platform;
+    } else {
+      flags.platform = config.platforms[0];
+    }
+  }
+  const selectedChannel = channelOf(config, channel);
+  if (selectedChannel.protected) {
+    const typed = await confirmProtectedChannelVersion(ctx, config, channel);
+    flags.confirmVersion = typed;
+  }
+  try {
+    switch (action) {
+      case "doctor":
+        runDoctorCommand(flags);
+        break;
+      case "version": {
+        const bump = await p3.select({ message: "Bump", options: [{ value: "patch", label: "patch" }, { value: "minor", label: "minor" }, { value: "major", label: "major" }] });
+        if (p3.isCancel(bump)) return;
+        runVersionCommand(flags, bump);
+        break;
+      }
+      case "notes":
+        runNotesCommand(flags);
+        break;
+      case "build":
+        runBuildCommand(flags);
+        break;
+      case "submit":
+        runSubmitCommand({ ...flags, latest: true });
+        break;
+      case "ship":
+        runShipCommand(flags);
+        break;
+      case "status":
+        await runStatusCommand(flags);
+        break;
+      case "update":
+        runUpdateCommand(flags);
+        break;
+      case "promote":
+        await runPromoteCommand(flags);
+        break;
+    }
+    p3.outro("Feito.");
+  } catch (error) {
+    p3.log.error(error.message);
+    p3.outro("Falhou.");
+    process.exitCode = 1;
+  }
+}
+
+// src/cli/ci.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { join as join10 } from "path";
+import * as p4 from "@clack/prompts";
+import pc5 from "picocolors";
+var WORKFLOW_TEMPLATE = `name: Release kit
+
+on:
+  workflow_dispatch:
+    inputs:
+      channel:
+        description: "Canal (ver release-kit.config.json)"
+        required: true
+        default: "release"
+      platform:
+        description: "android | ios"
+        required: true
+        default: "android"
+
+jobs:
+  ship:
+    name: doctor + build (cloud) + submit (faixa de teste)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm install -g eas-cli @htgabriel/release-kit
+      - name: doctor
+        run: release-kit doctor --channel \${{ inputs.channel }} --platform \${{ inputs.platform }} --json
+        env:
+          EXPO_TOKEN: \${{ secrets.EXPO_TOKEN }}
+      - name: ship (build cloud + submit)
+        run: release-kit ship --channel \${{ inputs.channel }} --platform \${{ inputs.platform }} --cloud --json
+        env:
+          EXPO_TOKEN: \${{ secrets.EXPO_TOKEN }}
+          ASC_KEY_ID: \${{ secrets.ASC_KEY_ID }}
+          ASC_ISSUER_ID: \${{ secrets.ASC_ISSUER_ID }}
+          ASC_KEY_P8_CONTENT: \${{ secrets.ASC_KEY_P8_CONTENT }}
+          GOOGLE_PLAY_JSON_CONTENT: \${{ secrets.GOOGLE_PLAY_JSON_CONTENT }}
+
+  # Canal protegido nunca roda autom\xE1tico \u2014 precisa de workflow_dispatch
+  # manual + Environment com reviewers no reposit\xF3rio (Settings \u2192 Environments).
+  promote:
+    name: promote (produ\xE7\xE3o \u2014 requer approval do Environment)
+    runs-on: ubuntu-latest
+    environment: production
+    if: inputs.channel == 'production'
+    needs: [ship]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm install -g eas-cli @htgabriel/release-kit
+      - run: release-kit promote --channel \${{ inputs.channel }} --i-know-this-is-production --json
+        env:
+          EXPO_TOKEN: \${{ secrets.EXPO_TOKEN }}
+          ASC_KEY_ID: \${{ secrets.ASC_KEY_ID }}
+          ASC_ISSUER_ID: \${{ secrets.ASC_ISSUER_ID }}
+          ASC_KEY_P8_CONTENT: \${{ secrets.ASC_KEY_P8_CONTENT }}
+          GOOGLE_PLAY_JSON_CONTENT: \${{ secrets.GOOGLE_PLAY_JSON_CONTENT }}
+`;
+var REQUIRED_SECRETS = ["EXPO_TOKEN", "ASC_KEY_ID", "ASC_ISSUER_ID", "ASC_KEY_P8_CONTENT", "GOOGLE_PLAY_JSON_CONTENT"];
+async function runCiInitCommand(target) {
+  if (target && target !== "github") {
+    p4.log.error(`alvo de CI desconhecido: "${target}". S\xF3 "github" \xE9 suportado nesta vers\xE3o.`);
+    process.exitCode = 1;
+    return;
+  }
+  p4.intro(pc5.bold("release-kit ci init github"));
+  const ctx = buildContext({});
+  loadConfig(ctx.repoRoot);
+  const dir = join10(ctx.repoRoot, ".github", "workflows");
+  mkdirSync6(dir, { recursive: true });
+  const path = join10(dir, "release-kit.yml");
+  if (existsSync13(path)) {
+    const overwrite = await p4.confirm({ message: `${path} j\xE1 existe. Sobrescrever?` });
+    if (p4.isCancel(overwrite) || !overwrite) {
+      p4.outro("Nada feito.");
+      return;
+    }
+  }
+  writeFileSync7(path, WORKFLOW_TEMPLATE);
+  p4.log.success(`escrito: .github/workflows/release-kit.yml`);
+  p4.log.info("Cadastre os secrets do reposit\xF3rio (Settings \u2192 Secrets and variables \u2192 Actions):");
+  for (const secret of REQUIRED_SECRETS) p4.log.info(`  - ${secret}`);
+  p4.log.info('E crie o Environment "production" com reviewers obrigat\xF3rios (Settings \u2192 Environments) \u2014 \xE9 o que impede o job `promote` de rodar sem aprova\xE7\xE3o humana.');
+  const setNow = await p4.confirm({ message: "Tentar cadastrar os secrets agora via `gh secret set`? (l\xEA de .env.release, ignora o que n\xE3o tiver)" });
+  if (setNow === true) {
+    await setSecretsFromEnv(ctx.repoRoot);
+  }
+  p4.outro("CI configurado.");
+}
+async function setSecretsFromEnv(repoRoot) {
+  const { readEnvFile: readEnvFile2 } = await Promise.resolve().then(() => (init_store(), store_exports));
+  const env = readEnvFile2(repoRoot);
+  const { defaultRun: defaultRun2 } = await Promise.resolve().then(() => (init_run(), run_exports));
+  const mapping = {
+    ASC_KEY_ID: env.ASC_KEY_ID,
+    ASC_ISSUER_ID: env.ASC_ISSUER_ID
+  };
+  for (const [key, value] of Object.entries(mapping)) {
+    if (!value) continue;
+    defaultRun2("gh", ["secret", "set", key, "--body", value], { cwd: repoRoot });
+    p4.log.success(`gh secret set ${key}`);
+  }
+  if (env.ASC_KEY_PATH) {
+    const { readFileSync: readFileSync9 } = await import("fs");
+    defaultRun2("gh", ["secret", "set", "ASC_KEY_P8_CONTENT", "--body", readFileSync9(env.ASC_KEY_PATH, "utf8")], { cwd: repoRoot });
+    p4.log.success("gh secret set ASC_KEY_P8_CONTENT");
+  }
+  if (env.GOOGLE_PLAY_JSON_KEY) {
+    const { readFileSync: readFileSync9 } = await import("fs");
+    defaultRun2("gh", ["secret", "set", "GOOGLE_PLAY_JSON_CONTENT", "--body", readFileSync9(env.GOOGLE_PLAY_JSON_KEY, "utf8")], { cwd: repoRoot });
+    p4.log.success("gh secret set GOOGLE_PLAY_JSON_CONTENT");
+  }
+  p4.log.warn("EXPO_TOKEN n\xE3o \xE9 lido do .env.release \u2014 cadastre manualmente (`gh secret set EXPO_TOKEN`).");
+}
+
+// src/cli/index.ts
+init_run();
+var HELP = `release-kit \u2014 orquestra\xE7\xE3o de release para apps Expo/EAS
+
+Uso:
+  release-kit                              menu interativo (s\xF3 com TTY)
+  release-kit init                         wizard de setup (credenciais, canais, config)
+  release-kit credentials [expo|apple|google|sync]
+  release-kit doctor [--channel] [--platform] [--deep]
+  release-kit version <patch|minor|major|x.y.z> [--push]
+  release-kit notes [--version] [--edit]
+  release-kit build --channel <c> --platform <android|ios> [--cloud]
+  release-kit submit --channel <c> [--latest|--path <arquivo>]
+  release-kit ship --channel <c> --platform <android|ios>
+  release-kit promote --channel <c> [--platform]
+  release-kit rollout --channel <c> --platform android --to <0-1|complete|halt>
+  release-kit status --channel <c>
+  release-kit update --channel <c> [--message]
+  release-kit ci init github
+
+Canais com "protected: true" (produ\xE7\xE3o) exigem --i-know-this-is-production
+(n\xE3o-interativo) ou --confirm-version <vers\xE3o exata>. Sem isso, nenhum
+comando toca um canal protegido.
+
+Flags globais: --dry-run --json --verbose --non-interactive
+`;
+async function main(argv = process.argv.slice(2)) {
+  const { command, positionals, flags } = parseCliArgs(argv);
+  if (flags.help && command) {
+    console.log(HELP);
+    return;
+  }
+  if (!command) {
+    if (flags.help) {
+      console.log(HELP);
+      return;
+    }
+    if (process.stdin.isTTY && !flags.nonInteractive) {
+      await runInteractiveMenu();
+      return;
+    }
+    console.log(HELP);
+    return;
+  }
+  let result;
+  switch (command) {
+    case "init":
+      await runInitWizard();
+      return;
+    case "credentials":
+      await runCredentialsCommand(positionals[0]);
+      return;
+    case "ci":
+      if (positionals[0] !== "init") throw new ReleaseKitError("uso: release-kit ci init github");
+      await runCiInitCommand(positionals[1]);
+      return;
+    case "doctor":
+      result = runDoctorCommand(flags);
+      break;
+    case "version": {
+      const bump = positionals[0];
+      if (!bump) throw new ReleaseKitError("uso: release-kit version <patch|minor|major|x.y.z>");
+      result = runVersionCommand(flags, bump);
+      break;
+    }
+    case "notes":
+      result = runNotesCommand(flags);
+      break;
+    case "build":
+      result = runBuildCommand(flags);
+      break;
+    case "submit":
+      result = runSubmitCommand(flags);
+      break;
+    case "ship":
+      result = runShipCommand(flags);
+      break;
+    case "promote":
+      result = await runPromoteCommand(flags);
+      break;
+    case "rollout":
+      result = await runRolloutCommand(flags);
+      break;
+    case "status":
+      result = await runStatusCommand(flags);
+      break;
+    case "update":
+      result = runUpdateCommand(flags);
+      break;
+    default:
+      throw new ReleaseKitError(`comando desconhecido: ${command}. Rode \`release-kit --help\`.`);
+  }
+  if (flags.json && result !== void 0) {
+    console.log(JSON.stringify(result, null, 2));
+  }
+}
+var invokedDirectly = process.argv[1]?.endsWith("cli/index.js") || process.argv[1]?.endsWith("release-kit");
+if (invokedDirectly) {
+  main().catch((error) => {
+    if (error instanceof ReleaseKitError) {
+      console.error(error.message);
+      process.exit(error.code);
+    }
+    console.error(error);
+    process.exit(1);
+  });
+}
+export {
+  main
+};
+//# sourceMappingURL=index.js.map