@daemux/store-automator 0.2.0 → 0.5.0

package/scripts/manage_version_ios.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""
+Automatic iOS version management via App Store Connect API.
+Queries the latest app version and decides whether to create a new version or reuse existing.
+
+State logic:
+  READY_FOR_SALE            -> create new version (auto-increment patch)
+  PREPARE_FOR_SUBMISSION    -> reuse existing version
+  WAITING_FOR_REVIEW        -> reuse existing version
+  IN_REVIEW                 -> reuse existing version
+  REJECTED                  -> reuse existing version
+  PENDING_DEVELOPER_RELEASE -> error (must manually release first)
+  No versions exist         -> create version 1.0.0
+
+Version increment uses base-10 rollover: 1.0.9 -> 1.1.0, 1.9.9 -> 2.0.0
+
+Required env vars:
+  APP_STORE_CONNECT_KEY_IDENTIFIER  - Key ID from App Store Connect
+  APP_STORE_CONNECT_ISSUER_ID       - Issuer ID from App Store Connect
+  APP_STORE_CONNECT_PRIVATE_KEY     - Contents of the P8 key file
+  BUNDLE_ID                         - App bundle identifier
+"""
+import os
+import sys
+import json
+import time
+
+try:
+    import jwt
+    import requests
+except ImportError:
+    print("Installing dependencies...", file=sys.stderr)
+    import subprocess
+    subprocess.check_call([
+        sys.executable, "-m", "pip", "install",
+        "PyJWT", "cryptography", "requests"
+    ], stdout=subprocess.DEVNULL)
+    import jwt
+    import requests
+
+BASE_URL = "https://api.appstoreconnect.apple.com/v1"
+
+
+def get_jwt_token(key_id, issuer_id, private_key):
+    payload = {
+        "iss": issuer_id,
+        "exp": int(time.time()) + 1200,
+        "aud": "appstoreconnect-v1",
+    }
+    return jwt.encode(payload, private_key, algorithm="ES256", headers={"kid": key_id})
+
+
+def get_app_id(headers, bundle_id):
+    resp = requests.get(
+        f"{BASE_URL}/apps",
+        params={"filter[bundleId]": bundle_id},
+        headers=headers,
+        timeout=(10, 30),
+    )
+    resp.raise_for_status()
+    data = resp.json().get("data", [])
+    if not data:
+        print(f"ERROR: No app found for bundle ID {bundle_id}", file=sys.stderr)
+        sys.exit(1)
+    return data[0]["id"]
+
+
+def get_versions(headers, app_id):
+    resp = requests.get(
+        f"{BASE_URL}/apps/{app_id}/appStoreVersions",
+        headers=headers,
+        timeout=(10, 30),
+    )
+    resp.raise_for_status()
+    return resp.json().get("data", [])
+
+
+def increment_version(version_str):
+    parts = version_str.split(".")
+    major = int(parts[0])
+    minor = int(parts[1]) if len(parts) > 1 else 0
+    micro = int(parts[2]) if len(parts) > 2 else 0
+    micro += 1
+    if micro >= 10:
+        micro, minor = 0, minor + 1
+    if minor >= 10:
+        minor, major = 0, major + 1
+    return f"{major}.{minor}.{micro}"
+
+
+def create_version(headers, app_id, version_string):
+    resp = requests.post(
+        f"{BASE_URL}/appStoreVersions",
+        json={
+            "data": {
+                "type": "appStoreVersions",
+                "attributes": {
+                    "platform": "IOS",
+                    "versionString": version_string,
+                    "releaseType": "AFTER_APPROVAL",
+                },
+                "relationships": {
+                    "app": {"data": {"type": "apps", "id": app_id}}
+                },
+            }
+        },
+        headers=headers,
+        timeout=(10, 30),
+    )
+    resp.raise_for_status()
+    return resp.json()["data"]
+
+
+def main():
+    key_id = os.environ.get("APP_STORE_CONNECT_KEY_IDENTIFIER", "")
+    issuer_id = os.environ.get("APP_STORE_CONNECT_ISSUER_ID", "")
+    private_key = os.environ.get("APP_STORE_CONNECT_PRIVATE_KEY", "")
+    bundle_id = os.environ.get("BUNDLE_ID", "")
+
+    if not all([key_id, issuer_id, private_key, bundle_id]):
+        print("ERROR: Missing required environment variables", file=sys.stderr)
+        sys.exit(1)
+
+    token = get_jwt_token(key_id, issuer_id, private_key)
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+    }
+
+    app_id = get_app_id(headers, bundle_id)
+    versions = get_versions(headers, app_id)
+
+    new_version = None
+    if not versions:
+        new_version = "1.0.0"
+    else:
+        latest = max(versions, key=lambda x: x["attributes"]["createdDate"])
+        state = latest["attributes"]["appStoreState"]
+        current_version = latest["attributes"]["versionString"]
+
+        if state == "PENDING_DEVELOPER_RELEASE":
+            print(
+                "ERROR: App is Pending Developer Release. Publish it first.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        elif state == "READY_FOR_SALE":
+            new_version = increment_version(current_version)
+        else:
+            result = {
+                "version": current_version,
+                "version_id": latest["id"],
+                "state": state,
+            }
+
+    if new_version:
+        created = create_version(headers, app_id, new_version)
+        result = {
+            "version": new_version,
+            "version_id": created["id"],
+            "state": "PREPARE_FOR_SUBMISSION",
+        }
+
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

package/src/codemagic-api.mjs

@@ -0,0 +1,73 @@
+const BASE_URL = 'https://api.codemagic.io';
+
+async function cmFetch(token, method, path, body) {
+  const url = `${BASE_URL}${path}`;
+  const headers = {
+    'x-auth-token': token,
+    'Content-Type': 'application/json',
+  };
+
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  } catch (err) {
+    throw new Error(`Network error: ${err.message}.`);
+  }
+
+  if (response.status === 401) {
+    throw new Error('Authentication failed. Check your CM_API_TOKEN.');
+  }
+  if (response.status === 403) {
+    throw new Error('Permission denied. Check API token permissions.');
+  }
+  if (response.status >= 500) {
+    throw new Error(`Codemagic API error (${response.status}). Try again later.`);
+  }
+  if (!response.ok) {
+    throw new Error(`Codemagic API error (${response.status}).`);
+  }
+
+  const text = await response.text();
+  if (!text) return {};
+  return JSON.parse(text);
+}
+
+export async function listApps(token) {
+  const data = await cmFetch(token, 'GET', '/apps');
+  return data.applications || [];
+}
+
+export async function findAppByRepo(token, repoUrl) {
+  const apps = await listApps(token);
+  const normalized = normalizeRepoUrl(repoUrl);
+  return apps.find((app) => {
+    const appRepo = app.repository?.url || app.repositoryUrl || '';
+    return normalizeRepoUrl(appRepo) === normalized;
+  }) || null;
+}
+
+export async function addApp(token, repoUrl) {
+  return cmFetch(token, 'POST', '/apps', { repositoryUrl: repoUrl });
+}
+
+export async function startBuild(token, appId, workflowId, branch) {
+  return cmFetch(token, 'POST', '/builds', { appId, workflowId, branch });
+}
+
+export async function getBuildStatus(token, buildId) {
+  const data = await cmFetch(token, 'GET', `/builds/${buildId}`);
+  return data.build || data;
+}
+
+export function normalizeRepoUrl(url) {
+  return url
+    .replace(/^git@github\.com:/, 'https://github.com/')
+    .replace(/^ssh:\/\/git@github\.com\//, 'https://github.com/')
+    .replace(/\.git$/, '')
+    .replace(/\/$/, '')
+    .toLowerCase();
+}

package/src/codemagic-setup.mjs

@@ -0,0 +1,164 @@
+import { findAppByRepo, addApp, startBuild, getBuildStatus, normalizeRepoUrl } from './codemagic-api.mjs';
+import { exec } from './utils.mjs';
+import { execFileSync } from 'child_process';
+
+const POLL_INTERVAL_MS = 30_000;
+const POLL_TIMEOUT_MS = 15 * 60 * 1000;
+const TERMINAL_STATUSES = new Set(['finished', 'failed', 'canceled']);
+
+function resolveToken(tokenArg) {
+  const token = process.env.CM_API_TOKEN || tokenArg;
+  if (!token) {
+    console.error('Codemagic API token required. Set CM_API_TOKEN or pass --token=...');
+    process.exit(1);
+  }
+  return token;
+}
+
+function resolveRepoUrl() {
+  const url = exec('git remote get-url origin');
+  if (!url) {
+    console.error('Not a git repository. Run from your project root.');
+    process.exit(1);
+  }
+  return normalizeRepoUrl(url);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function extractOwnerRepo(repoUrl) {
+  const match = repoUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+  return match ? { owner: match[1], repo: match[2] } : null;
+}
+
+function setupWebhook(repoUrl, appId) {
+  const ownerRepo = extractOwnerRepo(repoUrl);
+  if (!ownerRepo) {
+    console.log('Warning: Cannot extract owner/repo from URL. Skipping webhook setup.');
+    return false;
+  }
+
+  const { owner, repo } = ownerRepo;
+  const webhookUrl = `https://api.codemagic.io/hooks/${appId}`;
+
+  if (!exec('which gh')) {
+    console.log('');
+    console.log('GitHub CLI not found. Webhook not created.');
+    console.log('To enable auto-triggering, manually create webhook:');
+    console.log(`  Repository: ${owner}/${repo}`);
+    console.log(`  URL: ${webhookUrl}`);
+    console.log(`  Content type: application/json`);
+    console.log(`  Events: push, pull_request, create`);
+    return false;
+  }
+
+  try {
+    const payload = JSON.stringify({
+      name: 'web',
+      active: true,
+      events: ['push', 'pull_request', 'create'],
+      config: { url: webhookUrl, content_type: 'json' },
+    });
+
+    execFileSync('gh', ['api', `repos/${owner}/${repo}/hooks`, '-X', 'POST', '--input', '-'], {
+      input: payload,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    console.log(`Webhook created: ${owner}/${repo} → Codemagic`);
+    return true;
+  } catch (error) {
+    const errorMsg = String(error?.message || error);
+    if (errorMsg.includes('422') || errorMsg.includes('already exists')) {
+      console.log('Webhook already exists.');
+      return true;
+    }
+    console.log(`Warning: Cannot create webhook (${errorMsg})`);
+    console.log('Create manually in GitHub repository settings.');
+    return false;
+  }
+}
+
+async function pollBuildStatus(token, buildId) {
+  console.log(`Polling build ${buildId} (every 30s, max 15 min)...`);
+  const start = Date.now();
+
+  while (Date.now() - start < POLL_TIMEOUT_MS) {
+    await sleep(POLL_INTERVAL_MS);
+
+    const build = await getBuildStatus(token, buildId);
+    const status = build.status || 'unknown';
+    console.log(`  Build status: ${status}`);
+
+    if (TERMINAL_STATUSES.has(status)) {
+      return status;
+    }
+  }
+
+  console.log('Build still running. Check dashboard.');
+  return 'timeout';
+}
+
+export async function runCodemagicSetup(options) {
+  const {
+    tokenArg = '',
+    branch = 'main',
+    workflowId = 'default',
+    trigger = false,
+    wait = false,
+  } = options;
+
+  const token = resolveToken(tokenArg);
+  const repoUrl = resolveRepoUrl();
+
+  console.log(`Repository: ${repoUrl}`);
+  console.log('Checking Codemagic for existing app...');
+
+  let app = await findAppByRepo(token, repoUrl);
+
+  if (app) {
+    console.log(`App already registered: ${app.appName || app._id}`);
+  } else {
+    console.log('App not found. Adding to Codemagic...');
+    app = await addApp(token, repoUrl);
+    console.log(`App added: ${app.appName || app._id}`);
+
+    console.log('Setting up GitHub webhook...');
+    setupWebhook(repoUrl, app._id);
+  }
+
+  const appId = app._id;
+
+  if (!trigger) {
+    console.log('\nSetup complete. Use --trigger to start a build.\n');
+    console.log('To enable GitHub Actions auto-trigger:');
+    console.log('  1. Fill codemagic.app_id in ci.config.yaml');
+    console.log('  2. Run: npx @daemux/store-automator --github-setup');
+    return { appId, buildId: null, status: null };
+  }
+
+  console.log(`\nTriggering build on branch "${branch}" (workflow: ${workflowId})...`);
+  const buildResult = await startBuild(token, appId, workflowId, branch);
+  const buildId = buildResult.buildId;
+  console.log(`Build started: ${buildId}`);
+
+  if (!wait) {
+    console.log('Use --wait to poll until completion.');
+    return { appId, buildId, status: null };
+  }
+
+  const status = await pollBuildStatus(token, buildId);
+
+  if (status === 'finished') {
+    console.log('Build finished successfully.');
+  } else if (status === 'failed') {
+    console.error('Build failed.');
+    process.exit(1);
+  } else if (status === 'canceled') {
+    console.log('Build was canceled.');
+  }
+
+  return { appId, buildId, status };
+}

package/src/github-setup.mjs

@@ -0,0 +1,52 @@
+import { exec } from './utils.mjs';
+import { execFileSync } from 'child_process';
+
+function resolveToken(tokenArg) {
+  const token = process.env.CM_API_TOKEN || tokenArg;
+  if (!token) {
+    console.error('Codemagic API token required. Set CM_API_TOKEN or pass --token=...');
+    process.exit(1);
+  }
+  return token;
+}
+
+function checkGhCli() {
+  const ghPath = exec('which gh');
+  if (!ghPath) {
+    console.error('GitHub CLI (gh) is required but not found.');
+    console.error('Install it: https://cli.github.com/');
+    process.exit(1);
+  }
+
+  const authStatus = exec('gh auth status 2>&1');
+  if (!authStatus || authStatus.includes('not logged')) {
+    console.error('GitHub CLI is not authenticated. Run: gh auth login');
+    process.exit(1);
+  }
+}
+
+function setGitHubSecret(name, value) {
+  try {
+    execFileSync('gh', ['secret', 'set', name, '--body', value], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    console.log(`  Secret ${name} set successfully.`);
+  } catch (err) {
+    console.error(`Failed to set GitHub secret: ${name}`);
+    if (err.stderr) console.error(err.stderr.trim());
+    process.exit(1);
+  }
+}
+
+export async function runGitHubSetup(options) {
+  checkGhCli();
+  const token = resolveToken(options.tokenArg);
+
+  console.log('Configuring GitHub repository secret...');
+  setGitHubSecret('CM_API_TOKEN', token);
+
+  console.log('\nGitHub Actions setup complete.');
+  console.log('Next: Fill codemagic.app_id in ci.config.yaml.');
+  console.log('GitHub Actions will trigger configured Codemagic workflows on push to main.');
+}

package/src/install.mjs

@@ -1,14 +1,13 @@
 import { existsSync, rmSync, cpSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { execSync } from 'node:child_process';
+import { execSync, execFileSync } from 'node:child_process';
 import {
   MARKETPLACE_DIR, KNOWN_MP_PATH, CACHE_DIR,
   MARKETPLACE_NAME, PLUGIN_REF,
   getPackageDir, exec, ensureDir, ensureFile, readJson, writeJson,
 } from './utils.mjs';
 import { injectEnvVars, injectStatusLine } from './settings.mjs';
-import { ensureClaudePlugin } from './dependency-check.mjs';
 import { promptForTokens } from './prompt.mjs';
 import { getMcpServers, writeMcpJson } from './mcp-setup.mjs';
 import { installClaudeMd, installCiTemplates, installFirebaseTemplates } from './templates.mjs';
@@ -62,7 +61,7 @@ function registerMarketplace() {
     data = {};
   }
   data[MARKETPLACE_NAME] = {
-    source: { source: 'github', repo: 'daemux/store-automator' },
+    source: { source: 'github', repo: 'daemux/daemux-plugins' },
     installLocation: MARKETPLACE_DIR,
     lastUpdated: new Date().toISOString(),
   };
@@ -93,13 +92,29 @@ function printSummary(scope, oldVersion, newVersion) {
   }
 }
 
+function setupGitHubActions(codemagicToken) {
+  if (!codemagicToken) return false;
+
+  try {
+    execFileSync('which', ['gh'], { encoding: 'utf8', stdio: 'pipe' });
+    const authStatus = execFileSync('gh', ['auth', 'status'], { encoding: 'utf8', stdio: 'pipe' });
+    if (authStatus.includes('not logged')) return false;
+
+    execFileSync('gh', ['secret', 'set', 'CM_API_TOKEN', '--body', codemagicToken], {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export async function runInstall(scope, isPostinstall = false) {
   checkClaudeCli();
 
   console.log('Installing/updating Daemux Store Automator...');
 
-  ensureClaudePlugin();
-
   const tokens = await promptForTokens();
 
   const projectDir = process.cwd();
@@ -132,10 +147,20 @@ export async function runInstall(scope, isPostinstall = false) {
   injectEnvVars(settingsPath);
   injectStatusLine(settingsPath);
 
+  const ghConfigured = setupGitHubActions(tokens.codemagicToken);
+  if (ghConfigured) {
+    console.log('GitHub Actions: CM_API_TOKEN secret configured.');
+  } else if (tokens.codemagicToken) {
+    console.log('GitHub Actions: secret not set (gh CLI unavailable or not authenticated).');
+  }
+
   printSummary(scope, oldVersion, newVersion);
   console.log('');
   console.log('Next steps:');
-  console.log('  1. Fill ci.config.yaml with your app details');
+  console.log('  1. Fill ci.config.yaml (including codemagic.app_id)');
   console.log('  2. Add creds/AuthKey.p8 and creds/play-service-account.json');
-  console.log('  3. Start Claude Code and begin developing your app');
+  console.log('  3. Start Claude Code');
+  if (!ghConfigured) {
+    console.log('  Note: For auto-trigger, install gh CLI and run "gh auth login"');
+  }
 }

package/src/prompt.mjs

@@ -16,7 +16,7 @@ export async function promptForTokens() {
   if (!isInteractive()) {
     console.log('Non-interactive terminal detected, skipping token prompts.');
     console.log('Run "npx store-automator" manually to configure MCP tokens.');
-    return { stitchApiKey: '', cloudflareToken: '', cloudflareAccountId: '' };
+    return { stitchApiKey: '', cloudflareToken: '', cloudflareAccountId: '', codemagicToken: '' };
   }
 
   const rl = createInterface({
@@ -48,7 +48,12 @@ export async function promptForTokens() {
       );
     }
 
-    return { stitchApiKey, cloudflareToken, cloudflareAccountId };
+    const codemagicToken = await ask(
+      rl,
+      'Codemagic API Token (CM_API_TOKEN for CI/CD builds): '
+    );
+
+    return { stitchApiKey, cloudflareToken, cloudflareAccountId, codemagicToken };
   } finally {
     rl.close();
   }

package/src/templates.mjs

@@ -10,6 +10,10 @@ const FILE_COPIES = [
 
 const DIR_COPIES = ['scripts', 'fastlane', 'web'];
 
+const DIR_COPIES_MAPPED = [
+  ['github', '.github'],
+];
+
 const FIREBASE_COPIES = [
   ['firebase/firestore.rules.template', 'backend/firestore.rules'],
   ['firebase/storage.rules.template', 'backend/storage.rules'],
@@ -60,6 +64,15 @@ export function installCiTemplates(projectDir, packageDir) {
       true,
     );
   }
+
+  for (const [src, dest] of DIR_COPIES_MAPPED) {
+    copyIfMissing(
+      join(templateDir, src),
+      join(projectDir, dest),
+      `${dest}/`,
+      true,
+    );
+  }
 }
 
 export function installFirebaseTemplates(projectDir, packageDir) {

package/src/uninstall.mjs

@@ -1,4 +1,4 @@
-import { existsSync, rmSync, unlinkSync } from 'node:fs';
+import { existsSync, rmSync, unlinkSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
@@ -58,6 +58,31 @@ function removeCiTemplates(projectDir) {
       rmSync(dirPath, { recursive: true, force: true });
     }
   }
+
+  removeGitHubWorkflow(projectDir);
+}
+
+function isDirEmpty(dirPath) {
+  if (!existsSync(dirPath)) return true;
+  return readdirSync(dirPath).length === 0;
+}
+
+function removeGitHubWorkflow(projectDir) {
+  const workflowFile = join(projectDir, '.github', 'workflows', 'codemagic-trigger.yml');
+  removeFileIfExists(workflowFile, '.github/workflows/codemagic-trigger.yml');
+
+  const workflowsDir = join(projectDir, '.github', 'workflows');
+  const githubDir = join(projectDir, '.github');
+
+  if (isDirEmpty(workflowsDir)) {
+    rmSync(workflowsDir, { recursive: true, force: true });
+    console.log('Removed empty .github/workflows/ directory.');
+  }
+
+  if (isDirEmpty(githubDir)) {
+    rmSync(githubDir, { recursive: true, force: true });
+    console.log('Removed empty .github/ directory.');
+  }
 }
 
 export async function runUninstall(scope) {
@@ -72,29 +97,20 @@ export async function runUninstall(scope) {
     unregisterMarketplace();
   }
 
-  const baseDir = scope === 'user'
-    ? join(homedir(), '.claude')
-    : join(process.cwd(), '.claude');
-
-  const projectDir = process.cwd();
-  const scopeLabel = scope === 'user' ? 'global' : 'project';
+  const isGlobal = scope === 'user';
+  const baseDir = isGlobal ? join(homedir(), '.claude') : join(process.cwd(), '.claude');
+  const scopeLabel = isGlobal ? 'global' : 'project';
 
   removeFileIfExists(join(baseDir, 'CLAUDE.md'), `${scopeLabel} CLAUDE.md`);
-  removeCiTemplates(projectDir);
-  removeMcpServers(projectDir);
+  removeCiTemplates(process.cwd());
+  removeMcpServers(process.cwd());
 
-  const settingsPath = join(baseDir, 'settings.json');
   console.log(`Cleaning ${scopeLabel} settings...`);
-  removeEnvVars(settingsPath);
-  removeStatusLine(settingsPath);
+  removeEnvVars(join(baseDir, 'settings.json'));
+  removeStatusLine(join(baseDir, 'settings.json'));
 
-  console.log('');
-  if (scope === 'user') {
-    console.log('Done! store-automator uninstalled globally.');
-  } else {
-    console.log('Done! store-automator uninstalled from this project.');
-    console.log('');
-    console.log(`Note: Marketplace files remain in ${MARKETPLACE_DIR}`);
-    console.log('Run with --global --uninstall to remove marketplace completely.');
-  }
+  console.log(isGlobal
+    ? '\nDone! store-automator uninstalled globally.'
+    : `\nDone! store-automator uninstalled from this project.\n\nNote: Marketplace files remain in ${MARKETPLACE_DIR}\nRun with --global --uninstall to remove marketplace completely.`
+  );
 }