@daemux/store-automator 0.10.8 → 0.10.10

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "App Store & Google Play automation for Flutter apps",
-    "version": "0.10.8"
+    "version": "0.10.10"
   },
   "plugins": [
     {
       "name": "store-automator",
       "source": "./plugins/store-automator",
       "description": "3 agents for app store publishing: reviewer, meta-creator, media-designer",
-      "version": "0.10.8",
+      "version": "0.10.10",
       "keywords": [
         "flutter",
         "app-store",

package/bin/cli.mjs

@@ -23,7 +23,32 @@ const valueFlags = {
   '--cloudflare-token=': 'cloudflareToken',
   '--cloudflare-account-id=': 'cloudflareAccountId',
   '--bundle-id=': 'bundleId',
+  '--app-name=': 'appName',
+  '--key-id=': 'keyId',
+  '--issuer-id=': 'issuerId',
+  '--keystore-password=': 'keystorePassword',
+  '--sku=': 'sku',
+  '--apple-id=': 'appleId',
+  '--primary-category=': 'primaryCategory',
+  '--secondary-category=': 'secondaryCategory',
+  '--price-tier=': 'priceTier',
+  '--submit-for-review=': 'submitForReview',
+  '--automatic-release=': 'automaticRelease',
+  '--track=': 'track',
+  '--rollout-fraction=': 'rolloutFraction',
+  '--in-app-update-priority=': 'inAppUpdatePriority',
+  '--domain=': 'domain',
+  '--cf-project-name=': 'cfProjectName',
+  '--tagline=': 'tagline',
+  '--primary-color=': 'primaryColor',
+  '--secondary-color=': 'secondaryColor',
+  '--company-name=': 'companyName',
+  '--contact-email=': 'contactEmail',
+  '--support-email=': 'supportEmail',
+  '--jurisdiction=': 'jurisdiction',
+  '--languages=': 'languages',
   '--match-deploy-key=': 'matchDeployKey',
+  '--match-deploy-key-path=': 'matchDeployKeyPath',
   '--match-git-url=': 'matchGitUrl',
 };
 
@@ -60,8 +85,44 @@ Options:
   -v, --version                  Show version number
   -h, --help                     Show help
 
-App Configuration:
+App Identity:
+  --app-name=NAME                App display name
   --bundle-id=ID                 Bundle ID / Package Name (e.g., com.company.app)
+  --sku=SKU                      App Store Connect SKU
+  --apple-id=EMAIL               Apple Developer Account Email
+
+Credentials:
+  --key-id=ID                    App Store Connect Key ID
+  --issuer-id=ID                 App Store Connect Issuer ID
+  --keystore-password=PASS       Android keystore password
+  --match-deploy-key-path=PATH   Path to Match deploy key
+  --match-git-url=URL            Match certificates Git URL (SSH)
+
+iOS Store Settings:
+  --primary-category=CAT         iOS primary category (e.g., UTILITIES)
+  --secondary-category=CAT       iOS secondary category
+  --price-tier=N                 iOS price tier (0 = free)
+  --submit-for-review=BOOL       Auto-submit for review (true/false)
+  --automatic-release=BOOL       Auto-release after approval (true/false)
+
+Android Store Settings:
+  --track=TRACK                  Android release track (internal/alpha/beta/production)
+  --rollout-fraction=N           Rollout fraction (0.0-1.0)
+  --in-app-update-priority=N     In-app update priority (0-5)
+
+Web Settings:
+  --domain=DOMAIN                Web domain (e.g., myapp-pages.pages.dev)
+  --cf-project-name=NAME         Cloudflare Pages project name
+  --tagline=TEXT                  App tagline
+  --primary-color=HEX            Primary color (e.g., #2563EB)
+  --secondary-color=HEX          Secondary color
+  --company-name=NAME            Company name
+  --contact-email=EMAIL          Contact email
+  --support-email=EMAIL          Support email
+  --jurisdiction=TEXT             Legal jurisdiction
+
+Languages:
+  --languages=LANGS              Comma-separated language codes (e.g., en-US,de-DE)
 
 MCP Token Flags (skip interactive prompts):
   --stitch-key=KEY               Stitch MCP API key
@@ -74,17 +135,9 @@ GitHub Actions CI mode:
   --match-git-url=URL            Git URL for Match certificates repo
 
 Examples:
-  npx @daemux/store-automator                          Install for project
-  npx @daemux/store-automator -g                       Install globally
-  npx @daemux/store-automator -u                       Uninstall from project
-  npx @daemux/store-automator -g -u                    Uninstall globally
-
-GitHub Actions install:
-  npx @daemux/store-automator --github-actions --bundle-id=ID --match-deploy-key=PATH --match-git-url=URL
-
-Non-interactive install:
-  npx @daemux/store-automator --bundle-id=ID --stitch-key=KEY
-  npx @daemux/store-automator --cloudflare-token=TOKEN --cloudflare-account-id=ID`);
+  npx @daemux/store-automator
+  npx @daemux/store-automator --app-name="My App" --bundle-id=com.company.app
+  npx @daemux/store-automator --github-actions --bundle-id=ID --match-deploy-key=PATH --match-git-url=URL`);
       process.exit(0);
     case '-v':
     case '--version':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.8",
+  "version": "0.10.10",
   "description": "Full App Store & Google Play automation for Flutter apps with Claude Code agents",
   "type": "module",
   "bin": {

package/plugins/store-automator/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "store-automator",
-  "version": "0.10.8",
+  "version": "0.10.10",
   "description": "App Store & Google Play automation agents for Flutter app publishing",
   "author": {
     "name": "Daemux"

package/src/ci-config.mjs

@@ -2,51 +2,196 @@ import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 
 const CI_CONFIG_FILE = 'ci.config.yaml';
+
 const FIELD_PATTERNS = {
-  bundle_id: /^(\s*bundle_id:\s*)"[^"]*"/m,
-  package_name: /^(\s*package_name:\s*)"[^"]*"/m,
-  deploy_key_path: /^(\s*deploy_key_path:\s*)"[^"]*"/m,
-  git_url: /^(\s*git_url:\s*)"[^"]*"/m,
+  'app.name': { regex: /^(  name: ).*$/m, replacement: (v) => `  name: "${v}"` },
+  'app.bundle_id': { regex: /^(  bundle_id: ).*$/m, replacement: (v) => `  bundle_id: "${v}"` },
+  'app.package_name': { regex: /^(  package_name: ).*$/m, replacement: (v) => `  package_name: "${v}"` },
+  'app.sku': { regex: /^(  sku: ).*$/m, replacement: (v) => `  sku: "${v}"` },
+  'app.apple_id': { regex: /^(  apple_id: ).*$/m, replacement: (v) => `  apple_id: "${v}"` },
+  'credentials.apple.key_id': {
+    regex: /^(    key_id: ).*$/m, replacement: (v) => `    key_id: "${v}"`,
+  },
+  'credentials.apple.issuer_id': {
+    regex: /^(    issuer_id: ).*$/m, replacement: (v) => `    issuer_id: "${v}"`,
+  },
+  'credentials.android.keystore_password': {
+    regex: /^(    keystore_password: ).*$/m, replacement: (v) => `    keystore_password: "${v}"`,
+  },
+  'ios.primary_category': {
+    regex: /^(  primary_category: ).*$/m, replacement: (v) => `  primary_category: "${v}"`,
+  },
+  'ios.secondary_category': {
+    regex: /^(  secondary_category: ).*$/m, replacement: (v) => `  secondary_category: "${v}"`,
+  },
+  'ios.price_tier': { regex: /^(  price_tier: ).*$/m, replacement: (v) => `  price_tier: ${v}` },
+  'ios.submit_for_review': {
+    regex: /^(  submit_for_review: ).*$/m, replacement: (v) => `  submit_for_review: ${v}`,
+  },
+  'ios.automatic_release': {
+    regex: /^(  automatic_release: ).*$/m, replacement: (v) => `  automatic_release: ${v}`,
+  },
+  'android.track': { regex: /^(  track: ).*$/m, replacement: (v) => `  track: "${v}"` },
+  'android.rollout_fraction': {
+    regex: /^(  rollout_fraction: ).*$/m, replacement: (v) => `  rollout_fraction: "${v}"`,
+  },
+  'android.in_app_update_priority': {
+    regex: /^(  in_app_update_priority: ).*$/m, replacement: (v) => `  in_app_update_priority: ${v}`,
+  },
+  'web.domain': { regex: /^(  domain: ).*$/m, replacement: (v) => `  domain: "${v}"` },
+  'web.cloudflare_project_name': {
+    regex: /^(  cloudflare_project_name: ).*$/m, replacement: (v) => `  cloudflare_project_name: "${v}"`,
+  },
+  'web.tagline': { regex: /^(  tagline: ).*$/m, replacement: (v) => `  tagline: "${v}"` },
+  'web.primary_color': {
+    regex: /^(  primary_color: ).*$/m, replacement: (v) => `  primary_color: "${v}"`,
+  },
+  'web.secondary_color': {
+    regex: /^(  secondary_color: ).*$/m, replacement: (v) => `  secondary_color: "${v}"`,
+  },
+  'web.company_name': {
+    regex: /^(  company_name: ).*$/m, replacement: (v) => `  company_name: "${v}"`,
+  },
+  'web.contact_email': {
+    regex: /^(  contact_email: ).*$/m, replacement: (v) => `  contact_email: "${v}"`,
+  },
+  'web.support_email': {
+    regex: /^(  support_email: ).*$/m, replacement: (v) => `  support_email: "${v}"`,
+  },
+  'web.jurisdiction': {
+    regex: /^(  jurisdiction: ).*$/m, replacement: (v) => `  jurisdiction: "${v}"`,
+  },
+  'web.app_store_url': {
+    regex: /^(  app_store_url: ).*$/m, replacement: (v) => `  app_store_url: "${v}"`,
+  },
+  'web.google_play_url': {
+    regex: /^(  google_play_url: ).*$/m, replacement: (v) => `  google_play_url: "${v}"`,
+  },
 };
 
-function writeCiField(projectDir, field, value) {
-  const configPath = join(projectDir, CI_CONFIG_FILE);
-  if (!existsSync(configPath)) return false;
+function extractFieldValue(content, regex) {
+  const match = content.match(regex);
+  if (!match) return undefined;
+  const line = match[0];
+  const colonIdx = line.indexOf(':');
+  if (colonIdx < 0) return undefined;
+  const raw = line.slice(colonIdx + 1).trim();
+  if (raw.length >= 2 && raw[0] === '"' && raw[raw.length - 1] === '"') return raw.slice(1, -1);
+  return raw;
+}
 
-  try {
-    const pattern = FIELD_PATTERNS[field];
-    const content = readFileSync(configPath, 'utf8');
-    if (!pattern.test(content)) return false;
+export function isPlaceholder(value) {
+  if (value === undefined || value === null || value === '') return true;
+  const s = String(value);
+  if (s.startsWith('REPLACE_WITH_')) return true;
+  if (s.startsWith('yourapp')) return true;
+  if (s.startsWith('com.yourcompany.')) return true;
+  if (s === 'your@email.com') return true;
+  return false;
+}
 
-    const safeValue = value.replace(/\$/g, '$$$$');
-    const updated = content.replace(pattern, `$1"${safeValue}"`);
-    if (updated === content) return false;
+export function readCiConfig(projectDir) {
+  const configPath = join(projectDir, CI_CONFIG_FILE);
+  if (!existsSync(configPath)) return {};
+  const content = readFileSync(configPath, 'utf-8');
+  const config = {};
+  for (const [key, { regex }] of Object.entries(FIELD_PATTERNS)) {
+    const val = extractFieldValue(content, regex);
+    if (val !== undefined) config[key] = val;
+  }
+  config['metadata.languages'] = extractLanguages(content);
+  return config;
+}
 
-    writeFileSync(configPath, updated, 'utf8');
-    return true;
-  } catch {
-    return false;
+function extractLanguages(content) {
+  const lines = content.split('\n');
+  const langIdx = lines.findIndex((l) => /^\s*languages:\s*$/.test(l));
+  if (langIdx < 0) return [];
+  const langs = [];
+  for (let i = langIdx + 1; i < lines.length; i++) {
+    const match = lines[i].match(/^\s+-\s+(.+)$/);
+    if (!match) break;
+    langs.push(match[1].trim());
+  }
+  return langs;
+}
+
+export function writeCiFields(projectDir, fields) {
+  const configPath = join(projectDir, CI_CONFIG_FILE);
+  if (!existsSync(configPath)) return false;
+  let content = readFileSync(configPath, 'utf-8');
+  let changed = false;
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === undefined || value === null) continue;
+    const pattern = FIELD_PATTERNS[key];
+    if (!pattern) continue;
+    const safeValue = String(value).replace(/\$/g, '$$$$');
+    const updated = content.replace(pattern.regex, pattern.replacement(safeValue));
+    if (updated !== content) {
+      content = updated;
+      changed = true;
+    }
   }
+  if (changed) writeFileSync(configPath, content, 'utf-8');
+  return changed;
+}
+
+export function writeCiLanguages(projectDir, languagesStr) {
+  const configPath = join(projectDir, CI_CONFIG_FILE);
+  if (!existsSync(configPath)) return false;
+  const langs = languagesStr
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (langs.length === 0) return false;
+
+  const yamlLines = langs.map((l) => `    - ${l}`).join('\n');
+  const content = readFileSync(configPath, 'utf-8');
+  const updated = content.replace(
+    /^(  languages:\s*)\n(?:\s+-\s+.+\n?)*/m,
+    `$1\n${yamlLines}\n`
+  );
+  if (updated === content) return false;
+  writeFileSync(configPath, updated, 'utf-8');
+  return true;
 }
 
 export function writeCiBundleId(projectDir, bundleId) {
-  return writeCiField(projectDir, 'bundle_id', bundleId);
+  return writeCiFields(projectDir, {
+    'app.bundle_id': bundleId,
+  });
 }
 
 export function writeCiPackageName(projectDir, packageName) {
-  return writeCiField(projectDir, 'package_name', packageName);
+  return writeCiFields(projectDir, {
+    'app.package_name': packageName,
+  });
 }
 
 export function writeMatchConfig(projectDir, { deployKeyPath, gitUrl }) {
-  const wrote1 = writeCiField(projectDir, 'deploy_key_path', deployKeyPath);
-  const wrote2 = writeCiField(projectDir, 'git_url', gitUrl);
-  return wrote1 || wrote2;
+  const configPath = join(projectDir, CI_CONFIG_FILE);
+  if (!existsSync(configPath)) return false;
+  let content = readFileSync(configPath, 'utf-8');
+  let changed = false;
+
+  const dpRegex = /^(\s*deploy_key_path:\s*)"[^"]*"/m;
+  const guRegex = /^(\s*git_url:\s*)"[^"]*"/m;
+
+  if (deployKeyPath && dpRegex.test(content)) {
+    content = content.replace(dpRegex, `$1"${deployKeyPath}"`);
+    changed = true;
+  }
+  if (gitUrl && guRegex.test(content)) {
+    content = content.replace(guRegex, `$1"${gitUrl}"`);
+    changed = true;
+  }
+  if (changed) writeFileSync(configPath, content, 'utf-8');
+  return changed;
 }
 
 export function readFlutterRoot(projectDir) {
   const configPath = join(projectDir, CI_CONFIG_FILE);
   if (!existsSync(configPath)) return '.';
-
   try {
     const content = readFileSync(configPath, 'utf8');
     const match = content.match(/^flutter_root:\s*"([^"]*)"/m);

package/src/guide.mjs

@@ -0,0 +1,82 @@
+import { createInterface } from 'node:readline';
+import { existsSync } from 'node:fs';
+
+const BOLD = '\x1b[1m';
+const CYAN = '\x1b[36m';
+const YELLOW = '\x1b[33m';
+const GREEN = '\x1b[32m';
+const RESET = '\x1b[0m';
+
+function isNonInteractive() {
+  return Boolean(process.env.npm_config_yes) || process.argv.includes('--postinstall');
+}
+
+export function printGuide(title, steps) {
+  console.log('');
+  console.log(`${BOLD}${CYAN}=== ${title} ===${RESET}`);
+  console.log('');
+  for (let i = 0; i < steps.length; i++) {
+    console.log(`  ${i + 1}. ${steps[i]}`);
+  }
+  console.log('');
+}
+
+export function askConfirmation(rl, question) {
+  if (isNonInteractive()) return Promise.resolve('skip');
+
+  return new Promise((resolve) => {
+    rl.question(`${question} (y/n/skip): `, (answer) => {
+      const val = answer.trim().toLowerCase();
+      if (val === 'y' || val === 'yes') return resolve('yes');
+      if (val === 's' || val === 'skip') return resolve('skip');
+      resolve('no');
+    });
+  });
+}
+
+export function verifyFileExists(filePath, description) {
+  if (existsSync(filePath)) {
+    console.log(`${GREEN}  Found: ${description} (${filePath})${RESET}`);
+    return true;
+  }
+  console.log(`${YELLOW}  Warning: ${description} not found at ${filePath}${RESET}`);
+  return false;
+}
+
+export async function runGuide(rl, guide) {
+  printGuide(guide.title, guide.steps);
+
+  if (guide.verifyPath) {
+    verifyFileExists(guide.verifyPath, guide.verifyDescription || guide.verifyPath);
+  }
+
+  if (guide.confirmQuestion) {
+    const answer = await askConfirmation(rl, guide.confirmQuestion);
+    if (answer === 'no') {
+      console.log(`${YELLOW}  Skipped. You can complete this step later.${RESET}`);
+    }
+    return answer;
+  }
+
+  return 'yes';
+}
+
+export function askQuestion(rl, question, defaultValue) {
+  if (isNonInteractive()) return Promise.resolve(defaultValue || '');
+
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+export function isPlaceholder(value) {
+  if (value === undefined || value === null || value === '') return true;
+  const s = String(value);
+  if (s.startsWith('REPLACE_WITH_')) return true;
+  if (s.startsWith('yourapp')) return true;
+  if (s.startsWith('com.yourcompany.')) return true;
+  return false;
+}

package/src/install.mjs

@@ -8,10 +8,10 @@ import {
   getPackageDir, exec, ensureDir, ensureFile, readJson, writeJson,
 } from './utils.mjs';
 import { injectEnvVars, injectStatusLine } from './settings.mjs';
-import { promptForTokens } from './prompt.mjs';
+import { promptAll } from './prompt.mjs';
 import { getMcpServers, writeMcpJson } from './mcp-setup.mjs';
 import { installClaudeMd, installCiTemplates, installFirebaseTemplates } from './templates.mjs';
-import { writeCiBundleId, writeCiPackageName } from './ci-config.mjs';
+import { readCiConfig, writeCiFields, writeCiLanguages, isPlaceholder } from './ci-config.mjs';
 import { installGitHubActionsPath } from './install-paths.mjs';
 
 function checkClaudeCli() {
@@ -94,13 +94,66 @@ function printSummary(scope, oldVersion, newVersion) {
   }
 }
 
-function printNextSteps() {
+function mapPromptsToCiFields(prompted) {
+  return {
+    'app.name': prompted.appName,
+    'app.bundle_id': prompted.bundleId,
+    'app.package_name': prompted.packageName,
+    'app.sku': prompted.sku,
+    'app.apple_id': prompted.appleId,
+    'credentials.apple.key_id': prompted.keyId,
+    'credentials.apple.issuer_id': prompted.issuerId,
+    'credentials.android.keystore_password': prompted.keystorePassword,
+    'ios.primary_category': prompted.primaryCategory,
+    'ios.secondary_category': prompted.secondaryCategory,
+    'ios.price_tier': prompted.priceTier,
+    'ios.submit_for_review': prompted.submitForReview,
+    'ios.automatic_release': prompted.automaticRelease,
+    'android.track': prompted.track,
+    'android.rollout_fraction': prompted.rolloutFraction,
+    'android.in_app_update_priority': prompted.inAppUpdatePriority,
+    'web.domain': prompted.domain,
+    'web.cloudflare_project_name': prompted.cfProjectName,
+    'web.tagline': prompted.tagline,
+    'web.primary_color': prompted.primaryColor,
+    'web.secondary_color': prompted.secondaryColor,
+    'web.company_name': prompted.companyName,
+    'web.contact_email': prompted.contactEmail,
+    'web.support_email': prompted.supportEmail,
+    'web.jurisdiction': prompted.jurisdiction,
+  };
+}
+
+function printNextSteps(prompted) {
+  const missing = [];
+
+  if (isPlaceholder(prompted.bundleId)) {
+    missing.push('Set bundle ID in ci.config.yaml');
+  }
+  if (isPlaceholder(prompted.keyId)) {
+    missing.push('Add App Store Connect credentials (key_id, issuer_id, AuthKey.p8)');
+  }
+  if (!existsSync(join(process.cwd(), 'creds', 'play-service-account.json'))) {
+    missing.push('Add creds/play-service-account.json for Google Play');
+  }
+  if (isPlaceholder(prompted.matchGitUrl)) {
+    missing.push('Configure Match code signing (match_git_url, deploy key)');
+  }
+
   console.log('');
-  console.log('Next steps:');
-  console.log('  1. Fill ci.config.yaml with credentials');
-  console.log('  2. Add creds/AuthKey.p8 and creds/play-service-account.json');
-  console.log('  3. Set MATCH_PASSWORD secret in GitHub repository settings');
-  console.log('  4. Start Claude Code');
+  if (missing.length === 0) {
+    console.log('All configuration complete! Start Claude Code.');
+  } else {
+    console.log('Next steps:');
+    for (let i = 0; i < missing.length; i++) {
+      console.log(`  ${i + 1}. ${missing[i]}`);
+    }
+    console.log(`  ${missing.length + 1}. Start Claude Code`);
+  }
+}
+
+function isNonInteractive() {
+  return Boolean(process.env.npm_config_yes) || process.argv.includes('--postinstall');
 }
 
 export async function runInstall(scope, isPostinstall = false, cliTokens = {}) {
@@ -109,21 +162,11 @@ export async function runInstall(scope, isPostinstall = false, cliTokens = {}) {
   console.log('Installing/updating Daemux Store Automator...');
 
   const isGitHubActions = Boolean(cliTokens.githubActions);
-
-  const tokens = isGitHubActions
-    ? { bundleId: cliTokens.bundleId ?? '' }
-    : await promptForTokens(cliTokens);
-
   const projectDir = process.cwd();
-
-  if (!isGitHubActions) {
-    const servers = getMcpServers(tokens);
-    writeMcpJson(projectDir, servers);
-  }
-
   const oldVersion = readMarketplaceVersion();
   const packageDir = getPackageDir();
 
+  // 1. Copy plugin files + register marketplace
   copyPluginFiles(packageDir);
   clearCache();
   registerMarketplace();
@@ -131,21 +174,51 @@ export async function runInstall(scope, isPostinstall = false, cliTokens = {}) {
 
   const newVersion = readMarketplaceVersion('unknown');
 
+  // 2. Install CI templates (creates ci.config.yaml if missing)
+  installCiTemplates(projectDir, packageDir);
+  installFirebaseTemplates(projectDir, packageDir);
+
+  // 3. Read current ci.config.yaml values
+  const currentConfig = readCiConfig(projectDir);
+
+  // 4. Run interactive prompts (or use CLI flags / skip in non-interactive)
+  let prompted;
+  if (isGitHubActions) {
+    prompted = { bundleId: cliTokens.bundleId ?? '' };
+  } else if (isNonInteractive()) {
+    prompted = { ...cliTokens };
+  } else {
+    prompted = await promptAll(cliTokens, currentConfig, projectDir);
+  }
+
+  // 5. Write all prompted values to ci.config.yaml
+  const ciFields = mapPromptsToCiFields(prompted);
+  const wrote = writeCiFields(projectDir, ciFields);
+  if (wrote) console.log('Configuration written to ci.config.yaml');
+
+  // 6. Handle languages separately
+  if (prompted.languages) {
+    const langStr = Array.isArray(prompted.languages)
+      ? prompted.languages.join(',')
+      : prompted.languages;
+    if (writeCiLanguages(projectDir, langStr)) {
+      console.log('Languages updated in ci.config.yaml');
+    }
+  }
+
+  // 7. Configure MCP, CLAUDE.md, settings
+  if (!isGitHubActions) {
+    const servers = getMcpServers(prompted);
+    writeMcpJson(projectDir, servers);
+  }
+
   const baseDir = scope === 'user'
     ? join(homedir(), '.claude')
     : join(process.cwd(), '.claude');
 
   ensureDir(baseDir);
 
-  installClaudeMd(join(baseDir, 'CLAUDE.md'), packageDir);
-  installCiTemplates(projectDir, packageDir);
-  installFirebaseTemplates(projectDir, packageDir);
-
-  if (tokens.bundleId) {
-    const written = writeCiBundleId(projectDir, tokens.bundleId);
-    if (written) console.log(`Bundle ID set in ci.config.yaml: ${tokens.bundleId}`);
-    writeCiPackageName(projectDir, tokens.bundleId);
-  }
+  installClaudeMd(join(baseDir, 'CLAUDE.md'), packageDir, prompted.appName);
 
   installGitHubActionsPath(projectDir, packageDir, cliTokens);
 
@@ -155,6 +228,19 @@ export async function runInstall(scope, isPostinstall = false, cliTokens = {}) {
   injectEnvVars(settingsPath);
   injectStatusLine(settingsPath);
 
+  // 8. Run post-install guides (interactive only)
+  if (!isGitHubActions && !isNonInteractive()) {
+    const { createInterface } = await import('node:readline');
+    const { runPostInstallGuides } = await import('./prompts/store-settings.mjs');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      await runPostInstallGuides(rl);
+    } finally {
+      rl.close();
+    }
+  }
+
+  // 9. Summary + dynamic next steps
   printSummary(scope, oldVersion, newVersion);
-  printNextSteps();
+  printNextSteps(prompted);
 }

package/src/prompt.mjs

@@ -1,30 +1,79 @@
 import { createInterface } from 'node:readline';
+import { promptAppIdentity } from './prompts/app-identity.mjs';
+import { promptCredentials } from './prompts/credentials.mjs';
+import { promptStoreSettings, promptWebSettings } from './prompts/store-settings.mjs';
+import { askQuestion } from './guide.mjs';
 
 function isInteractive() {
   return Boolean(process.stdin.isTTY);
 }
 
-function ask(rl, question) {
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      resolve(answer.trim());
-    });
-  });
+function isNonInteractive() {
+  return Boolean(process.env.npm_config_yes) || process.argv.includes('--postinstall');
 }
 
-function allTokensProvided(cliTokens) {
+function allPromptsProvided(cliFlags) {
   return (
-    cliTokens.stitchApiKey !== undefined &&
-    cliTokens.cloudflareToken !== undefined &&
-    cliTokens.cloudflareAccountId !== undefined
+    cliFlags.bundleId !== undefined &&
+    cliFlags.stitchApiKey !== undefined &&
+    cliFlags.cloudflareToken !== undefined &&
+    cliFlags.cloudflareAccountId !== undefined
   );
 }
 
-function allPromptsProvided(cliTokens) {
-  return (
-    cliTokens.bundleId !== undefined &&
-    allTokensProvided(cliTokens)
+async function promptMcpTokens(rl, cliFlags, currentConfig) {
+  const result = {
+    stitchApiKey: cliFlags.stitchApiKey ?? '',
+    cloudflareToken: cliFlags.cloudflareToken ?? '',
+    cloudflareAccountId: cliFlags.cloudflareAccountId ?? '',
+  };
+
+  const allProvided = (
+    cliFlags.stitchApiKey !== undefined &&
+    cliFlags.cloudflareToken !== undefined &&
+    cliFlags.cloudflareAccountId !== undefined
   );
+
+  if (allProvided) return result;
+
+  console.log('Press Enter to skip any token you do not have yet.');
+  console.log('');
+
+  if (cliFlags.stitchApiKey === undefined) {
+    result.stitchApiKey = await askQuestion(rl, 'Stitch MCP API Key', currentConfig.stitchApiKey || '');
+  }
+
+  if (cliFlags.cloudflareToken === undefined) {
+    result.cloudflareToken = await askQuestion(rl, 'Cloudflare API Token', currentConfig.cloudflareToken || '');
+  }
+
+  if (result.cloudflareToken && cliFlags.cloudflareAccountId === undefined) {
+    result.cloudflareAccountId = await askQuestion(
+      rl, 'Cloudflare Account ID', currentConfig.cloudflareAccountId || ''
+    );
+  }
+
+  return result;
+}
+
+export async function promptAll(rl, cliFlags, currentConfig, projectDir) {
+  console.log('');
+  console.log('\x1b[1m\x1b[36m=== Store Automator — Interactive Setup ===\x1b[0m');
+
+  const identity = await promptAppIdentity(rl, cliFlags, currentConfig);
+
+  const credentials = await promptCredentials(rl, cliFlags, currentConfig, projectDir);
+
+  const storeSettings = await promptStoreSettings(rl, cliFlags, currentConfig);
+
+  const webSettings = await promptWebSettings(rl, cliFlags, currentConfig);
+
+  console.log('');
+  console.log('\x1b[1m\x1b[36m=== MCP Tokens (Optional) ===\x1b[0m');
+  console.log('');
+  const mcpTokens = await promptMcpTokens(rl, cliFlags, currentConfig);
+
+  return { ...identity, ...credentials, ...storeSettings, ...webSettings, ...mcpTokens };
 }
 
 export async function promptForTokens(cliTokens = {}) {
@@ -40,61 +89,23 @@ export async function promptForTokens(cliTokens = {}) {
     return result;
   }
 
-  if (!isInteractive()) {
+  if (!isInteractive() || isNonInteractive()) {
     console.log('Non-interactive terminal detected, skipping prompts.');
     console.log('Run "npx store-automator" manually to configure.');
     return result;
   }
 
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  console.log('');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
 
   try {
-    if (cliTokens.bundleId === undefined) {
-      console.log('App Configuration');
-      console.log('');
-      result.bundleId = await ask(
-        rl,
-        'Bundle ID / Package Name (e.g., com.company.app): '
-      );
-      console.log('');
-    }
-
-    if (allTokensProvided(cliTokens)) {
-      console.log('All MCP tokens provided via CLI flags.');
-      return result;
-    }
-
-    console.log('MCP Server Configuration');
-    console.log('Press Enter to skip any token you do not have yet.');
-    console.log('');
-
-    if (cliTokens.stitchApiKey === undefined) {
-      result.stitchApiKey = await ask(
-        rl,
-        'Stitch MCP API Key (STITCH_API_KEY value): '
-      );
-    }
-
-    if (cliTokens.cloudflareToken === undefined) {
-      result.cloudflareToken = await ask(
-        rl,
-        'Cloudflare API Token: '
-      );
-    }
-
-    if (result.cloudflareToken && cliTokens.cloudflareAccountId === undefined) {
-      result.cloudflareAccountId = await ask(
-        rl,
-        'Cloudflare Account ID: '
-      );
-    }
-
-    return result;
+    const all = await promptAll(rl, cliTokens, {}, process.cwd());
+    return {
+      ...all,
+      bundleId: all.bundleId || result.bundleId,
+      stitchApiKey: all.stitchApiKey || result.stitchApiKey,
+      cloudflareToken: all.cloudflareToken || result.cloudflareToken,
+      cloudflareAccountId: all.cloudflareAccountId || result.cloudflareAccountId,
+    };
   } finally {
     rl.close();
   }

package/src/prompts/app-identity.mjs

@@ -0,0 +1,66 @@
+import { askQuestion, isPlaceholder } from '../guide.mjs';
+
+const FIELDS = [
+  {
+    key: 'appName',
+    label: 'App Name (display name)',
+    configKey: 'app.name',
+    flag: 'appName',
+  },
+  {
+    key: 'bundleId',
+    label: 'Bundle ID (e.g. com.company.app)',
+    configKey: 'bundle_id',
+    flag: 'bundleId',
+  },
+  {
+    key: 'packageName',
+    label: 'Android Package Name',
+    configKey: 'android.package_name',
+    flag: 'packageName',
+  },
+  {
+    key: 'sku',
+    label: 'App Store Connect SKU',
+    configKey: 'ios.sku',
+    flag: 'sku',
+  },
+  {
+    key: 'appleId',
+    label: 'Apple Developer Account Email',
+    configKey: 'ios.apple_id',
+    flag: 'appleId',
+  },
+];
+
+function getDefault(key, cliFlags, currentConfig) {
+  if (cliFlags[key] !== undefined) return cliFlags[key];
+  const configVal = currentConfig[key];
+  if (!isPlaceholder(configVal)) return configVal;
+  return '';
+}
+
+export async function promptAppIdentity(rl, cliFlags, currentConfig) {
+  console.log('');
+  console.log('\x1b[1m\x1b[36m=== App Identity ===\x1b[0m');
+  console.log('');
+
+  const result = {};
+
+  for (const field of FIELDS) {
+    const flagVal = cliFlags[field.flag];
+    if (flagVal !== undefined) {
+      result[field.key] = flagVal;
+      continue;
+    }
+
+    const defaultVal = getDefault(field.key, cliFlags, currentConfig);
+    result[field.key] = await askQuestion(rl, field.label, defaultVal);
+  }
+
+  if (!result.packageName && result.bundleId) {
+    result.packageName = result.bundleId;
+  }
+
+  return result;
+}

package/src/prompts/credentials.mjs

@@ -0,0 +1,122 @@
+import { join } from 'node:path';
+import { runGuide, askQuestion, isPlaceholder } from '../guide.mjs';
+
+function getDefault(key, cliFlags, currentConfig) {
+  if (cliFlags[key] !== undefined) return cliFlags[key];
+  const configVal = currentConfig[key];
+  if (!isPlaceholder(configVal)) return configVal;
+  return '';
+}
+
+async function promptAppStoreApiKey(rl, cliFlags, currentConfig, projectDir) {
+  await runGuide(rl, {
+    title: 'Create App Store Connect API Key',
+    steps: [
+      'Log in to App Store Connect (appstoreconnect.apple.com)',
+      'Go to Users and Access -> Integrations -> Team Keys',
+      'Click + to generate a new key with "App Manager" role',
+      'Download the .p8 file',
+      `Save to creds/AuthKey.p8 in your project`,
+    ],
+    verifyPath: join(projectDir, 'creds', 'AuthKey.p8'),
+    verifyDescription: 'App Store Connect API Key (.p8)',
+    confirmQuestion: 'Have you created and saved the API key?',
+  });
+
+  const keyId = await askQuestion(
+    rl,
+    'App Store Connect Key ID',
+    getDefault('keyId', cliFlags, currentConfig)
+  );
+
+  const issuerId = await askQuestion(
+    rl,
+    'App Store Connect Issuer ID',
+    getDefault('issuerId', cliFlags, currentConfig)
+  );
+
+  return { keyId, issuerId };
+}
+
+async function promptPlayServiceAccount(rl, projectDir) {
+  await runGuide(rl, {
+    title: 'Create Google Play Service Account',
+    steps: [
+      'Go to Google Play Console -> Setup -> API access',
+      'Create a service account or link existing one',
+      'Grant "Release manager" permission to the service account',
+      'Download the JSON key file',
+      'Save to creds/play-service-account.json in your project',
+    ],
+    verifyPath: join(projectDir, 'creds', 'play-service-account.json'),
+    verifyDescription: 'Google Play Service Account JSON',
+    confirmQuestion: 'Have you set up the service account?',
+  });
+}
+
+async function promptAndroidKeystore(rl, cliFlags, currentConfig) {
+  await runGuide(rl, {
+    title: 'Set up Android Keystore',
+    steps: [
+      'If you don\'t have a keystore, run:',
+      '  keytool -genkey -v -keystore creds/upload-keystore.jks \\',
+      '    -keyalg RSA -keysize 2048 -validity 10000',
+      'Keep the keystore file safe — you cannot replace it once uploaded to Google Play',
+    ],
+    confirmQuestion: 'Have you created or located your Android keystore?',
+  });
+
+  const keystorePassword = await askQuestion(
+    rl,
+    'Keystore password',
+    getDefault('keystorePassword', cliFlags, currentConfig)
+  );
+
+  return keystorePassword;
+}
+
+async function promptMatchSigning(rl, cliFlags, currentConfig) {
+  await runGuide(rl, {
+    title: 'Set up Match Code Signing',
+    steps: [
+      'Create a PRIVATE Git repository for certificates (e.g. github.com/yourorg/certificates)',
+      'Generate an SSH deploy key: ssh-keygen -t ed25519 -f creds/match_deploy_key',
+      'Add the public key as a deploy key to the certificates repo (with write access)',
+    ],
+    confirmQuestion: 'Have you set up the certificates repository and deploy key?',
+  });
+
+  const matchDeployKeyPath = await askQuestion(
+    rl,
+    'Path to Match deploy key',
+    getDefault('matchDeployKeyPath', cliFlags, currentConfig) || 'creds/match_deploy_key'
+  );
+
+  const matchGitUrl = await askQuestion(
+    rl,
+    'Match certificates Git URL (SSH)',
+    getDefault('matchGitUrl', cliFlags, currentConfig)
+  );
+
+  return { matchDeployKeyPath, matchGitUrl };
+}
+
+export async function promptCredentials(rl, cliFlags, currentConfig, projectDir) {
+  console.log('');
+  console.log('\x1b[1m\x1b[36m=== Credentials Setup ===\x1b[0m');
+  console.log('');
+
+  const { keyId, issuerId } = await promptAppStoreApiKey(
+    rl, cliFlags, currentConfig, projectDir
+  );
+
+  await promptPlayServiceAccount(rl, projectDir);
+
+  const keystorePassword = await promptAndroidKeystore(rl, cliFlags, currentConfig);
+
+  const { matchDeployKeyPath, matchGitUrl } = await promptMatchSigning(
+    rl, cliFlags, currentConfig
+  );
+
+  return { keyId, issuerId, keystorePassword, matchDeployKeyPath, matchGitUrl };
+}

package/src/prompts/store-settings.mjs

@@ -0,0 +1,185 @@
+import { runGuide, askQuestion, isPlaceholder } from '../guide.mjs';
+
+function getDefault(key, cliFlags, currentConfig) {
+  if (cliFlags[key] !== undefined) return cliFlags[key];
+  const configVal = currentConfig[key];
+  if (!isPlaceholder(configVal)) return configVal;
+  return '';
+}
+
+function getDefaultWithFallback(key, cliFlags, currentConfig, fallback) {
+  const val = getDefault(key, cliFlags, currentConfig);
+  return val !== '' ? val : fallback;
+}
+
+async function promptIosSettings(rl, cliFlags, currentConfig) {
+  await runGuide(rl, {
+    title: 'Create App in App Store Connect',
+    steps: [
+      'Go to App Store Connect -> My Apps -> +',
+      'Select your Bundle ID',
+      'Fill in app name and primary language',
+      'Save the app',
+    ],
+    confirmQuestion: 'Have you created the app in App Store Connect?',
+  });
+
+  const primaryCategory = await askQuestion(
+    rl,
+    'iOS Primary Category (e.g. GAMES, UTILITIES)',
+    getDefault('primaryCategory', cliFlags, currentConfig)
+  );
+
+  const secondaryCategory = await askQuestion(
+    rl,
+    'iOS Secondary Category (optional)',
+    getDefault('secondaryCategory', cliFlags, currentConfig)
+  );
+
+  const priceTier = await askQuestion(
+    rl,
+    'iOS Price Tier',
+    getDefaultWithFallback('priceTier', cliFlags, currentConfig, '0')
+  );
+
+  const submitForReview = await askQuestion(
+    rl,
+    'Auto-submit for review? (true/false)',
+    getDefaultWithFallback('submitForReview', cliFlags, currentConfig, 'true')
+  );
+
+  const automaticRelease = await askQuestion(
+    rl,
+    'Automatic release after approval? (true/false)',
+    getDefaultWithFallback('automaticRelease', cliFlags, currentConfig, 'true')
+  );
+
+  return {
+    primaryCategory,
+    secondaryCategory,
+    priceTier: Number(priceTier) || 0,
+    submitForReview: submitForReview === 'true',
+    automaticRelease: automaticRelease === 'true',
+  };
+}
+
+async function promptAndroidSettings(rl, cliFlags, currentConfig) {
+  await runGuide(rl, {
+    title: 'Create App in Google Play Console',
+    steps: [
+      'Go to Google Play Console -> All apps -> Create app',
+      'Enter app name and default language',
+      'Select app type (App) and free/paid',
+      'Complete the declarations and create',
+    ],
+    confirmQuestion: 'Have you created the app in Google Play Console?',
+  });
+
+  const track = await askQuestion(
+    rl,
+    'Android release track (internal/alpha/beta/production)',
+    getDefaultWithFallback('track', cliFlags, currentConfig, 'internal')
+  );
+
+  const rolloutFraction = await askQuestion(
+    rl,
+    'Rollout fraction (0.0 - 1.0)',
+    getDefaultWithFallback('rolloutFraction', cliFlags, currentConfig, '1.0')
+  );
+
+  const inAppUpdatePriority = await askQuestion(
+    rl,
+    'In-app update priority (0-5)',
+    getDefaultWithFallback('inAppUpdatePriority', cliFlags, currentConfig, '3')
+  );
+
+  return {
+    track,
+    rolloutFraction: Number(rolloutFraction) || 1.0,
+    inAppUpdatePriority: Number(inAppUpdatePriority) || 3,
+  };
+}
+
+async function promptMetadataSettings(rl, cliFlags, currentConfig) {
+  const languages = await askQuestion(
+    rl,
+    'Metadata languages (comma-separated, e.g. en-US,de-DE)',
+    getDefaultWithFallback('languages', cliFlags, currentConfig, 'en-US')
+  );
+
+  return { languages: languages.split(',').map((l) => l.trim()).filter(Boolean) };
+}
+
+export async function promptStoreSettings(rl, cliFlags, currentConfig) {
+  console.log('');
+  console.log('\x1b[1m\x1b[36m=== Store Settings ===\x1b[0m');
+  console.log('');
+
+  const ios = await promptIosSettings(rl, cliFlags, currentConfig);
+  const android = await promptAndroidSettings(rl, cliFlags, currentConfig);
+  const metadata = await promptMetadataSettings(rl, cliFlags, currentConfig);
+
+  return { ...ios, ...android, ...metadata };
+}
+
+export async function promptWebSettings(rl, cliFlags, currentConfig) {
+  console.log('');
+  console.log('\x1b[1m\x1b[36m=== Web Settings ===\x1b[0m');
+  console.log('');
+
+  const fields = [
+    { key: 'domain', label: 'Domain (e.g. example.com)' },
+    { key: 'cfProjectName', label: 'Cloudflare Pages project name' },
+    { key: 'tagline', label: 'App tagline' },
+    { key: 'primaryColor', label: 'Primary color (hex, e.g. #4A90D9)' },
+    { key: 'secondaryColor', label: 'Secondary color (hex)' },
+    { key: 'companyName', label: 'Company name' },
+    { key: 'contactEmail', label: 'Contact email' },
+    { key: 'supportEmail', label: 'Support email' },
+    { key: 'jurisdiction', label: 'Legal jurisdiction (e.g. Delaware, USA)' },
+  ];
+
+  const result = {};
+  for (const field of fields) {
+    result[field.key] = await askQuestion(
+      rl,
+      field.label,
+      getDefault(field.key, cliFlags, currentConfig)
+    );
+  }
+  return result;
+}
+
+export async function runPostInstallGuides(rl) {
+  await runGuide(rl, {
+    title: 'Create Private GitHub Repository',
+    steps: [
+      'Go to github.com/new',
+      'Create a PRIVATE repository',
+      'Push your project to the repository',
+    ],
+    confirmQuestion: 'Have you created the GitHub repository?',
+  });
+
+  await runGuide(rl, {
+    title: 'Set GitHub Actions Secrets',
+    steps: [
+      'Go to your repo -> Settings -> Secrets -> Actions',
+      'Add secret MATCH_PASSWORD (your match encryption password)',
+      'Add secret KEYSTORE_PASSWORD (your Android keystore password)',
+      'Upload creds/ files as secrets if using CI',
+    ],
+    confirmQuestion: 'Have you configured GitHub Actions secrets?',
+  });
+
+  await runGuide(rl, {
+    title: 'Create Firebase Project (optional)',
+    steps: [
+      'Go to console.firebase.google.com',
+      'Create a new project or select existing',
+      'Add your iOS and Android apps',
+      'Download google-services.json and GoogleService-Info.plist',
+    ],
+    confirmQuestion: 'Have you set up Firebase? (skip if not needed)',
+  });
+}

package/src/templates.mjs

@@ -46,13 +46,18 @@ function copyIfMissing(srcPath, destPath, label, isDirectory) {
   }
 }
 
-export function installClaudeMd(targetPath, packageDir) {
+export function installClaudeMd(targetPath, packageDir, appName) {
   const template = join(packageDir, 'templates', 'CLAUDE.md.template');
   if (!existsSync(template)) return;
   const action = existsSync(targetPath) ? 'Updating' : 'Installing';
   console.log(`${action} CLAUDE.md...`);
   ensureDir(join(targetPath, '..'));
-  copyFileSync(template, targetPath);
+
+  let content = readFileSync(template, 'utf8');
+  if (appName) {
+    content = content.replace(/\{APP_NAME\}/g, appName);
+  }
+  writeFileSync(targetPath, content, 'utf8');
 }
 
 export function installCiTemplates(projectDir, packageDir) {

package/templates/fastlane/ios/Fastfile.template

@@ -91,6 +91,7 @@ platform :ios do
         skip_binary_upload: true,
         skip_metadata: false,
         skip_screenshots: false,
+        overwrite_screenshots: true,
         run_precheck_before_submit: false,
         submit_for_review: false
       )

package/templates/github/workflows/ios-release.yml

@@ -92,6 +92,22 @@ jobs:
         with:
           channel: stable
 
+      - name: Cache Flutter
+        uses: actions/cache@v4
+        with:
+          path: /Users/runner/.pub-cache
+          key: pub-cache-${{ hashFiles('app/pubspec.lock') }}
+          restore-keys: |
+            pub-cache-
+
+      - name: Cache CocoaPods
+        uses: actions/cache@v4
+        with:
+          path: app/ios/Pods
+          key: pods-${{ hashFiles('app/ios/Podfile.lock') }}
+          restore-keys: |
+            pods-
+
       - name: Install yq
         run: brew install yq
 

package/templates/scripts/ci/android/upload-metadata.sh

@@ -44,6 +44,8 @@ fi
 # --- Upload metadata via Fastlane ---
 echo "Uploading Android metadata..."
 
+cd "$APP_ROOT/android"
+
 set +e
 FASTLANE_OUTPUT=$(PACKAGE_NAME="$PACKAGE_NAME" \
 GOOGLE_PLAY_SERVICE_ACCOUNT_JSON_PATH="$SA_FULL_PATH" \

package/templates/scripts/ci/ios/upload-metadata.sh

@@ -16,34 +16,10 @@ if [ ! -d "$METADATA_DIR" ] && [ ! -d "$SCREENSHOTS_DIR" ]; then
   ci_skip "No iOS metadata directories found"
 fi
 
-HASH_DIRS=()
 for dir in "$METADATA_DIR" "$SCREENSHOTS_DIR"; do
-  [ -d "$dir" ] && HASH_DIRS+=("$dir") && echo "  Found: $dir"
+  [ -d "$dir" ] && echo "  Found: $dir"
 done
 
-# --- Hash-based change detection ---
-HASH=$(
-  find "${HASH_DIRS[@]}" -type f ! -name '.DS_Store' -print0 \
-    | LC_ALL=C sort -z \
-    | xargs -0 shasum -a 256 2>/dev/null \
-    | shasum -a 256 \
-    | cut -d' ' -f1
-)
-
-STATE_DIR="$PROJECT_ROOT/.ci-state"
-mkdir -p "$STATE_DIR"
-STATE_FILE="$STATE_DIR/ios-metadata-hash"
-
-if [ -f "$STATE_FILE" ]; then
-  STORED_HASH=$(cat "$STATE_FILE")
-  if [ "$HASH" = "$STORED_HASH" ]; then
-    ci_skip "iOS metadata unchanged since last upload"
-  fi
-  echo "Changes detected (old: ${STORED_HASH:0:12}..., new: ${HASH:0:12}...)"
-else
-  echo "No cached hash found. First run — will upload metadata."
-fi
-
 # --- Validate Apple credentials ---
 if [ -z "$P8_KEY_PATH" ] || [ -z "$APPLE_KEY_ID" ] || [ -z "$APPLE_ISSUER_ID" ]; then
   echo "ERROR: Apple credentials not configured in ci.config.yaml" >&2
@@ -70,6 +46,4 @@ cd "$APP_ROOT/ios"
 
 bundle exec fastlane upload_metadata_ios
 
-# --- Update hash on success ---
-echo "$HASH" > "$STATE_FILE"
 ci_done "iOS metadata uploaded to App Store Connect"