kasy-cli 1.31.5 → 1.31.7

package/bin/kasy.js

@@ -602,7 +602,22 @@ function buildProgram(language) {
         ],
       });
       if (sub === 'configure') await runCodemagicConfigure('.', { language });
-      else if (sub === 'release') await runCodemagicRelease('.', { language });
+      else if (sub === 'release') {
+        const platform = await ui.select({
+          message: t('cli.command.codemagic.release.platformPick'),
+          options: [
+            { value: 'both', label: t('cli.command.codemagic.release.platform.both') },
+            { value: 'ios', label: t('cli.command.codemagic.release.platform.ios') },
+            { value: 'android', label: t('cli.command.codemagic.release.platform.android') },
+          ],
+        });
+        if (typeof platform === 'string') {
+          const relOpts = { language };
+          if (platform === 'ios') relOpts.ios = true;
+          else if (platform === 'android') relOpts.android = true;
+          await runCodemagicRelease('.', relOpts);
+        }
+      }
       else if (sub === 'status') {
         const buildId = await ui.text({
           message: 'Build ID',
@@ -625,9 +640,11 @@ function buildProgram(language) {
     codemagicCmd
       .command('release')
       .argument('[directory]', 'Project folder (default: current directory)', '.')
+      .option('--ios', t('cli.command.codemagic.release.iosOption'))
+      .option('--android', t('cli.command.codemagic.release.androidOption'))
       .description(t('cli.command.codemagic.release.description'))
-      .action(async (directory) => {
-        await runCodemagicRelease(directory, { language });
+      .action(async (directory, opts) => {
+        await runCodemagicRelease(directory, { language, ios: opts.ios, android: opts.android });
       }),
     t
   );

package/docs/cli-reference.md

@@ -121,15 +121,17 @@ Atalho: `make release-ios`
 
 ---
 
-### `kasy codemagic` — Release iOS (nuvem)
+### `kasy codemagic` — Release iOS/Android (nuvem)
 
-Dispara build iOS no Codemagic (ideal sem Mac).
+Dispara build **iOS e Android** no Codemagic (ideal sem Mac), levando as chaves do `.env` no disparo.
 
 ```bash
-kasy add ci                  # cria codemagic.yaml (se necessário)
-kasy codemagic configure     # token API + app/workflow ID
-kasy codemagic release       # inicia build na nuvem
-kasy codemagic status <id>   # status do build
+kasy add ci                       # entrega o codemagic.yaml (se necessário)
+kasy codemagic configure          # token API → valida e lista seus apps → branch
+kasy codemagic release            # iOS + Android na nuvem
+kasy codemagic release --ios      # só iOS
+kasy codemagic release --android  # só Android
+kasy codemagic status <id>        # status do build
 ```
 
 Documentação: `docs/codemagic-release.md` (idioma da CLI)

package/lib/commands/codemagic.js

@@ -11,18 +11,39 @@ const {
   codemagicReleaseDocPath,
   writeCodemagicEnv,
   validateCodemagicSetup,
+  loadProjectEnv,
+  listApps,
+  workflowIdFor,
+  resolveReleaseVars,
   triggerBuild,
   getBuildStatus,
   URL_CODEMAGIC_APPS,
   URL_CODEMAGIC_API,
 } = require('../utils/codemagic-release');
 
+// Human label per platform (proper nouns — same across locales).
+const PLATFORM_LABEL = { ios: 'iOS', android: 'Android' };
+
 async function assertProject(projectDir, t) {
   if (!(await isKasyFlutterProject(projectDir))) {
     throw new Error(t('codemagic.error.notProject'));
   }
 }
 
+/**
+ * Decide which platforms to release. Explicit flags win; with no flag we build
+ * both. Returns an ordered list like ['ios', 'android'].
+ */
+function platformsFromOptions(options) {
+  const wantIos = !!options.ios;
+  const wantAndroid = !!options.android;
+  if (!wantIos && !wantAndroid) return ['ios', 'android'];
+  const platforms = [];
+  if (wantIos) platforms.push('ios');
+  if (wantAndroid) platforms.push('android');
+  return platforms;
+}
+
 async function runConfigure(directory, options = {}) {
   const lang = options.language || detectDefaultLanguage();
   const t = createTranslator(lang);
@@ -35,39 +56,62 @@ async function runConfigure(directory, options = {}) {
   ui.log.message(kleur.dim(`${t('codemagic.configure.doc')}: ${codemagicReleaseDocPath(lang)}`));
   ui.log.warn(t('codemagic.configure.checklist'));
 
-  ui.log.info(t('codemagic.configure.openingLinks'));
-  openUrl(URL_CODEMAGIC_API);
-  openUrl(URL_CODEMAGIC_APPS);
-
   const cancel = () => { ui.cancel(t('codemagic.configure.cancelled')); process.exit(0); };
   const required = (v) => (v && String(v).trim().length > 0 ? undefined : t('codemagic.configure.q.required'));
 
-  const token = await ui.password({
+  // 1. API token — open the settings page so the user can copy it.
+  ui.log.info(t('codemagic.configure.openingToken'));
+  openUrl(URL_CODEMAGIC_API);
+  const tokenRaw = await ui.password({
     message: t('codemagic.configure.q.token'),
     validate: required,
     onCancel: cancel,
   });
-  const appId = await ui.text({
-    message: t('codemagic.configure.q.appId'),
-    validate: required,
-    onCancel: cancel,
-  });
-  const workflowId = await ui.text({
-    message: t('codemagic.configure.q.workflowId'),
-    initialValue: 'ios-workflow',
-    onCancel: cancel,
-  });
-  const branch = await ui.text({
+  const token = String(tokenRaw).trim();
+
+  // 2. Validate the token by listing the user's apps.
+  const spinner = ui.spinner();
+  spinner.start(t('codemagic.configure.validating'));
+  let apps;
+  try {
+    apps = await listApps(token);
+    spinner.stop(t('codemagic.configure.validated'));
+  } catch (err) {
+    spinner.stop(`${t('codemagic.configure.tokenInvalid')} (${err.message})`, 2);
+    process.exitCode = 1;
+    return;
+  }
+
+  // 3. Pick the app (or guide the user to connect a repo first).
+  let appId;
+  if (!apps.length) {
+    ui.log.warn(t('codemagic.configure.noApps'));
+    openUrl(URL_CODEMAGIC_APPS);
+    const manual = await ui.text({
+      message: t('codemagic.configure.q.appId'),
+      validate: required,
+      onCancel: cancel,
+    });
+    appId = String(manual).trim();
+  } else {
+    appId = await ui.select({
+      message: t('codemagic.configure.pickApp'),
+      options: apps.map((a) => ({ value: a.id, label: a.name, hint: a.id })),
+    });
+    if (typeof appId === 'symbol') cancel();
+  }
+
+  // 4. Branch that triggers the build.
+  const branchRaw = await ui.text({
     message: t('codemagic.configure.q.branch'),
     initialValue: 'main',
     onCancel: cancel,
   });
 
   await writeCodemagicEnv(projectDir, {
-    token: String(token).trim(),
-    appId: String(appId).trim(),
-    workflowId: String(workflowId).trim() || 'ios-workflow',
-    branch: String(branch).trim() || 'main',
+    token,
+    appId,
+    branch: String(branchRaw).trim() || 'main',
   });
 
   ui.log.success(t('codemagic.configure.success'));
@@ -87,44 +131,64 @@ async function runRelease(directory, options = {}) {
     if (validation.issues.includes('missing_yaml')) {
       ui.log.message(kleur.dim(t('codemagic.error.addCi')));
     }
-    if (validation.issues.includes('missing_env')) {
+    if (validation.issues.includes('missing_env') || validation.issues.includes('missing_token') || validation.issues.includes('missing_app_id')) {
       ui.log.message(kleur.dim(t('codemagic.error.runConfigure')));
     }
     process.exitCode = 1;
     return;
   }
 
-  const googleScheme = await validateGoogleIosUrlScheme(projectDir);
-  if (!googleScheme.ok) {
-    printCompactHeader(t);
-    ui.log.error(t('codemagic.error.googleUrlScheme'));
-    ui.log.message(kleur.dim(googleScheme.error));
-    ui.log.info(t('ios.error.googleUrlSchemeHint'));
-    process.exitCode = 1;
-    return;
+  const platforms = platformsFromOptions(options);
+
+  // iOS builds need the Google Sign-In URL scheme to be in sync.
+  if (platforms.includes('ios')) {
+    const googleScheme = await validateGoogleIosUrlScheme(projectDir);
+    if (!googleScheme.ok) {
+      printCompactHeader(t);
+      ui.log.error(t('codemagic.error.googleUrlScheme'));
+      ui.log.message(kleur.dim(googleScheme.error));
+      ui.log.info(t('ios.error.googleUrlSchemeHint'));
+      process.exitCode = 1;
+      return;
+    }
   }
 
   printCompactHeader(t);
   ui.intro(t('codemagic.release.title'));
 
-  const spinner = ui.spinner();
-  spinner.start(t('codemagic.release.spin'));
-  try {
-    const result = await triggerBuild(projectDir, validation.env);
-    spinner.stop(t('codemagic.release.spinDone'));
-    const buildId = result.buildId || result._id;
-    if (buildId) {
-      ui.log.success(t('codemagic.release.triggered'));
-      ui.log.info(`Build ID: ${kleur.cyan(buildId)}`);
-      ui.log.message(kleur.dim(`https://codemagic.io/builds/${buildId}`));
-      ui.outro('');
-    } else {
-      ui.outro(t('codemagic.release.triggered'));
+  // Read the project's keys and carry them with the build.
+  const projectEnv = await loadProjectEnv(projectDir);
+  const variables = resolveReleaseVars(projectEnv);
+
+  if (platforms.includes('ios') && !variables.RC_IOS_PROD_KEY) {
+    ui.log.warn(t('codemagic.release.noIosKey'));
+  }
+  if (platforms.includes('android') && !variables.RC_ANDROID_PROD_KEY) {
+    ui.log.warn(t('codemagic.release.noAndroidKey'));
+  }
+
+  let anyFailed = false;
+  for (const platform of platforms) {
+    const label = PLATFORM_LABEL[platform];
+    const workflowId = workflowIdFor(validation.env, platform);
+    const spinner = ui.spinner();
+    spinner.start(t('codemagic.release.spinPlatform', { platform: label }));
+    try {
+      const result = await triggerBuild(validation.env, { workflowId, variables });
+      const buildId = result.buildId || result._id;
+      spinner.stop(t('codemagic.release.triggeredPlatform', { platform: label }));
+      if (buildId) {
+        ui.log.info(`Build ID: ${kleur.cyan(buildId)}`);
+        ui.log.message(kleur.dim(`https://codemagic.io/app/${validation.env.CODEMAGIC_APP_ID}/build/${buildId}`));
+      }
+    } catch (err) {
+      anyFailed = true;
+      spinner.stop(`${label}: ${err.message}`, 2);
     }
-  } catch (err) {
-    spinner.stop(err.message, 2);
-    process.exitCode = 1;
   }
+
+  if (anyFailed) process.exitCode = 1;
+  ui.outro('');
 }
 
 async function runStatus(buildId, directory, options = {}) {
@@ -168,4 +232,5 @@ module.exports = {
   runConfigure,
   runRelease,
   runStatus,
+  platformsFromOptions,
 };

package/lib/commands/new.js

@@ -1733,6 +1733,11 @@ async function runNew(directory, { language: langHint = null, backend: backendHi
   // generation step once choices are made. The success card at the end shows
   // the full summary. Cancel any time with Ctrl+C.
 
+  // Windows: disable native assets before the generator runs pub get / builds,
+  // so a username with a space (C:\Users\John Silva) doesn't break the
+  // objective_c hook compile. No-op elsewhere, idempotent, best-effort.
+  require('../utils/env-tools').disableNativeAssetsWindows();
+
   // ── Generate ────────────────────────────────────────────────────────────
   // Quick: single rolling line that mutates message. Advanced: stack each step.
   const stepper = ui.makeQuickStepper({ color: paintLime });

package/lib/commands/reset.js

@@ -7,9 +7,7 @@ const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
 const { printCompactHeader } = require('../utils/brand');
 const { readBundleId, readPackageName } = require('../utils/mobile-identity');
 const { spawnFlutterWithSpinner } = require('../utils/flutter-run');
-const { augmentedEnv } = require('../utils/env-tools');
-
-const isWindows = process.platform === 'win32';
+const { spawnSyncFlutter, disableNativeAssetsWindows } = require('../utils/env-tools');
 
 function runCmd(cmd, args) {
   const res = spawnSync(cmd, args, { encoding: 'utf8' });
@@ -21,11 +19,9 @@ function runCmd(cmd, args) {
 }
 
 async function listFlutterDevices(projectDir) {
-  const res = spawnSync('flutter', ['devices', '--machine'], {
+  const res = spawnSyncFlutter(['devices', '--machine'], {
     cwd: projectDir,
     encoding: 'utf8',
-    env: augmentedEnv(),
-    shell: isWindows,
   });
   if (res.status !== 0) return [];
   try {
@@ -268,6 +264,10 @@ async function runReset(directory, options = {}) {
     throw new Error(t('reset.error.notFlutterProject'));
   }
 
+  // Windows: disable native assets before the reinstall rebuild so a username
+  // with a space doesn't break the objective_c hook compile. No-op elsewhere.
+  disableNativeAssetsWindows();
+
   printCompactHeader(t);
   ui.intro(t('reset.title'));
 

package/lib/commands/run.js

@@ -1,25 +1,20 @@
 const path = require('node:path');
-const { spawnSync } = require('node:child_process');
 const fs = require('fs-extra');
 const kleur = require('kleur');
 const ui = require('../utils/ui');
 const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
 const { printCompactHeader, paintLime } = require('../utils/brand');
 const { spawnFlutterWithSpinner } = require('../utils/flutter-run');
-const { augmentedEnv } = require('../utils/env-tools');
-
-const isWindows = process.platform === 'win32';
+const { spawnSyncFlutter, disableNativeAssetsWindows } = require('../utils/env-tools');
 
 function listFlutterDevices(projectDir) {
-  // Same as `kasy run`'s launcher: expose a freshly-installed Flutter SDK via
-  // augmentedEnv() (the terminal's PATH may not have it yet), and use a shell on
-  // Windows so the flutter.bat is found. Without this, a machine that just ran
-  // `kasy new` reports "Flutter not found" here even though Flutter is installed.
-  const res = spawnSync('flutter', ['devices', '--machine'], {
+  // Shared flutter spawner: exposes a freshly-installed SDK on PATH (the terminal
+  // may not have it yet right after `kasy new`) and handles the Windows flutter.bat
+  // without tripping Node's shell+args deprecation warning. Without it, a machine
+  // that just ran `kasy new` reports "Flutter not found" here.
+  const res = spawnSyncFlutter(['devices', '--machine'], {
     cwd: projectDir,
     encoding: 'utf8',
-    env: augmentedEnv(),
-    shell: isWindows,
   });
   if (res.status !== 0) return [];
   try {
@@ -254,6 +249,11 @@ async function runRun(directory, options = {}) {
     throw new Error(t('run.error.notFlutterProject'));
   }
 
+  // Windows: turn off native assets before building so a username with a space
+  // (C:\Users\John Silva) doesn't break the objective_c hook compile. No-op on
+  // macOS/Linux, idempotent, and best-effort — see disableNativeAssetsWindows.
+  disableNativeAssetsWindows();
+
   // Resolve device flag. If none of the platform shortcuts or -d is set,
   // ask the user when more than one device is available — `flutter run`
   // bails out with "More than one device connected" otherwise.

package/lib/scaffold/engine.js

@@ -27,12 +27,14 @@ const ALWAYS_EXCLUDE = new Set([
   '.cursor',
   '.idea',
   '.claude',       // AI assistant instructions — not for the client
-  // CI/CD configs — delivered only when the user selects the 'ci' module
-  // (these files live in features/ci/ and are applied as a feature patch)
+  // GitHub/GitLab CI pipelines are not shipped to generated projects yet.
   '.github',
   '.gitlab',
   '.gitlab-ci.yml',
-  'codemagic.yaml',
+  // NOTE: codemagic.yaml is intentionally NOT excluded here. It ships in the
+  // base template and generate.js removes it unless the 'ci' module is
+  // selected (see the "Phase B" gating). This is what lets `kasy codemagic`
+  // work in a generated project.
 ]);
 
 // File basenames that should NEVER be copied, regardless of directory depth

package/lib/scaffold/generate.js

@@ -236,6 +236,13 @@ async function generateProject(targetDir, backend, options, hooks = {}) {
     // Remove directories of modules that were NOT selected
     await removeModuleDirs(targetDir, modules);
 
+    // codemagic.yaml ships in the base template (so `kasy codemagic` works out
+    // of the box). It belongs to the 'ci' module — strip it when ci was not
+    // selected, mirroring how the other optional modules are gated above.
+    if (!modules.includes('ci')) {
+      await fs.remove(path.join(targetDir, 'codemagic.yaml'));
+    }
+
     // Write no-op analytics_api.dart if analytics not selected
     if (!modules.includes('analytics')) {
       await writeNoOpAnalyticsApi(targetDir, packageName);

package/lib/utils/codemagic-release.js

@@ -8,18 +8,22 @@ const CODEMAGIC_ENV_REL = path.join('.kasy', 'codemagic.env');
 const CODEMAGIC_API = 'https://api.codemagic.io';
 
 const URL_CODEMAGIC_APPS = 'https://codemagic.io/apps';
-const URL_CODEMAGIC_API = 'https://codemagic.io/settings/integrations';
+// Codemagic API token lives in the account settings → Integrations page.
+const URL_CODEMAGIC_API = 'https://codemagic.io/settings';
+
+// Default workflow ids defined in the codemagic.yaml shipped by the `ci` feature.
+const DEFAULT_IOS_WORKFLOW = 'ios-workflow';
+const DEFAULT_ANDROID_WORKFLOW = 'android-workflow';
 
 function codemagicReleaseDocPath() {
   return 'docs/codemagic-release.md';
 }
 
-async function loadCodemagicEnv(projectDir) {
-  const envPath = path.join(projectDir, CODEMAGIC_ENV_REL);
-  if (!(await fs.pathExists(envPath))) {
-    return null;
-  }
-  const content = await fs.readFile(envPath, 'utf8');
+/**
+ * Parse a simple KEY=VALUE env file into an object. Ignores blanks/comments.
+ * Values keep everything after the first '=' (so URLs with ':' survive).
+ */
+function parseEnvContent(content) {
   const env = {};
   for (const line of content.split('\n')) {
     const trimmed = line.trim();
@@ -31,12 +35,32 @@ async function loadCodemagicEnv(projectDir) {
   return env;
 }
 
-async function writeCodemagicEnv(projectDir, { token, appId, workflowId, branch }) {
+async function loadCodemagicEnv(projectDir) {
+  const envPath = path.join(projectDir, CODEMAGIC_ENV_REL);
+  if (!(await fs.pathExists(envPath))) {
+    return null;
+  }
+  return parseEnvContent(await fs.readFile(envPath, 'utf8'));
+}
+
+/**
+ * Read the project's runtime `.env` (the app's config). Returns {} when absent.
+ */
+async function loadProjectEnv(projectDir) {
+  const envPath = path.join(projectDir, '.env');
+  if (!(await fs.pathExists(envPath))) {
+    return {};
+  }
+  return parseEnvContent(await fs.readFile(envPath, 'utf8'));
+}
+
+async function writeCodemagicEnv(projectDir, { token, appId, iosWorkflowId, androidWorkflowId, branch }) {
   const lines = [
     '# Generated by kasy codemagic configure — do not commit',
     `CODEMAGIC_API_TOKEN=${token}`,
     `CODEMAGIC_APP_ID=${appId}`,
-    `CODEMAGIC_WORKFLOW_ID=${workflowId || 'ios-workflow'}`,
+    `CODEMAGIC_IOS_WORKFLOW_ID=${iosWorkflowId || DEFAULT_IOS_WORKFLOW}`,
+    `CODEMAGIC_ANDROID_WORKFLOW_ID=${androidWorkflowId || DEFAULT_ANDROID_WORKFLOW}`,
     `CODEMAGIC_BRANCH=${branch || 'main'}`,
     '',
   ];
@@ -83,12 +107,92 @@ function httpsJson(method, urlPath, token, body) {
   });
 }
 
-async function triggerBuild(projectDir, env) {
+/**
+ * List the Codemagic applications the token can access.
+ * Returns [{ id, name }] so the configure wizard can let the user pick one
+ * instead of pasting a raw Mongo id.
+ */
+async function listApps(token) {
+  const result = await httpsJson('GET', '/apps', token);
+  const apps = Array.isArray(result) ? result : (result.applications || []);
+  return apps
+    .map((a) => ({ id: a._id || a.id, name: a.appName || a.name || a.repository?.name || '(unnamed app)' }))
+    .filter((a) => a.id);
+}
+
+/**
+ * Resolve which workflow id to trigger for a platform, honoring custom ids
+ * saved at configure time and falling back to the shipped defaults. The legacy
+ * single CODEMAGIC_WORKFLOW_ID (older configs) is treated as the iOS workflow.
+ */
+function workflowIdFor(env, platform) {
+  if (platform === 'android') {
+    return env.CODEMAGIC_ANDROID_WORKFLOW_ID || DEFAULT_ANDROID_WORKFLOW;
+  }
+  return env.CODEMAGIC_IOS_WORKFLOW_ID || env.CODEMAGIC_WORKFLOW_ID || DEFAULT_IOS_WORKFLOW;
+}
+
+/**
+ * Build the environment variables to inject at trigger time, read from the
+ * project's `.env`. These travel with the build so the cloud has the SAME
+ * production keys you use locally — the user does not have to fill the
+ * Codemagic variable groups by hand.
+ *
+ * RevenueCat SDK keys (appl_/goog_/test_) are public keys, safe to send this
+ * way. Real secrets (keystore, App Store key, service account) stay in the
+ * dashboard and are NOT sent here.
+ */
+function resolveReleaseVars(projectEnv) {
+  const vars = { ENV: 'prod' };
+
+  const passthrough = [
+    'BACKEND_URL',
+    'RC_TEST_KEY',
+    'RC_IOS_PROD_KEY',
+    'RC_ANDROID_PROD_KEY',
+    'MIXPANEL_TOKEN',
+    'SENTRY_DSN',
+  ];
+  for (const key of passthrough) {
+    const value = projectEnv[key];
+    if (value && value.trim()) vars[key] = value.trim();
+  }
+
+  // LLM chat endpoint may be named either way across template versions; the app
+  // reads AI_CHAT_ENDPOINT.
+  const endpoint = projectEnv.AI_CHAT_ENDPOINT || projectEnv.LLM_CHAT_ENDPOINT;
+  if (endpoint && endpoint.trim()) vars.AI_CHAT_ENDPOINT = endpoint.trim();
+
+  // Legacy single-key projects (pre test/prod split): promote a non-test key
+  // into the prod slot so release builds still get a real key.
+  if (!vars.RC_IOS_PROD_KEY && projectEnv.RC_IOS_API_KEY && !projectEnv.RC_IOS_API_KEY.startsWith('test_')) {
+    vars.RC_IOS_PROD_KEY = projectEnv.RC_IOS_API_KEY.trim();
+  }
+  if (!vars.RC_ANDROID_PROD_KEY && projectEnv.RC_ANDROID_API_KEY && !projectEnv.RC_ANDROID_API_KEY.startsWith('test_')) {
+    vars.RC_ANDROID_PROD_KEY = projectEnv.RC_ANDROID_API_KEY.trim();
+  }
+
+  // Numeric App Store id → APP_ID, used by the iOS workflow for build numbering.
+  if (projectEnv.APP_STORE_ID && projectEnv.APP_STORE_ID.trim()) {
+    vars.APP_ID = projectEnv.APP_STORE_ID.trim();
+  }
+
+  return vars;
+}
+
+/**
+ * Trigger one build. `variables` is injected via the build's environment so the
+ * cloud build carries the project's production keys.
+ */
+async function triggerBuild(env, { workflowId, branch, variables }) {
   const body = {
     appId: env.CODEMAGIC_APP_ID,
-    workflowId: env.CODEMAGIC_WORKFLOW_ID,
-    branch: env.CODEMAGIC_BRANCH || 'main',
+    workflowId,
+    branch: branch || env.CODEMAGIC_BRANCH || 'main',
   };
+  if (variables && Object.keys(variables).length > 0) {
+    body.environment = { variables };
+  }
   return httpsJson('POST', '/builds', env.CODEMAGIC_API_TOKEN, body);
 }
 
@@ -109,7 +213,6 @@ async function validateCodemagicSetup(projectDir) {
   }
   if (!env.CODEMAGIC_API_TOKEN) issues.push('missing_token');
   if (!env.CODEMAGIC_APP_ID) issues.push('missing_app_id');
-  if (!env.CODEMAGIC_WORKFLOW_ID) issues.push('missing_workflow');
   return { ok: issues.length === 0, issues, env };
 }
 
@@ -118,9 +221,15 @@ module.exports = {
   CODEMAGIC_API,
   URL_CODEMAGIC_APPS,
   URL_CODEMAGIC_API,
+  DEFAULT_IOS_WORKFLOW,
+  DEFAULT_ANDROID_WORKFLOW,
   codemagicReleaseDocPath,
   loadCodemagicEnv,
+  loadProjectEnv,
   writeCodemagicEnv,
+  listApps,
+  workflowIdFor,
+  resolveReleaseVars,
   triggerBuild,
   getBuildStatus,
   validateCodemagicSetup,