Skip to content

README.de.md

Latest commit

 

History

History
490 lines (391 loc) · 43.5 KB

README.de.md

File metadata and controls

490 lines (391 loc) · 43.5 KB
Raw

Launch — bauen, signieren und im App Store und bei Google Play veröffentlichen

Quelloffene, selbst gehostete Alternative zu Expo EAS — bauen, signieren, Stores konfigurieren & veröffentlichen Sie Ihre Expo-/React-Native-Apps aus einer einzigen typisierten launch.config.ts im App Store & bei Google Play, direkt von Ihrem eigenen Rechner und mit Ihren eigenen Schlüsseln. Keine Abrechnung pro Build.

npm version npm downloads CI status MIT license Node version TypeScript types included

211 App Store Connect & Google Play API operations Full create / read / update / delete coverage across the store APIs 2008 tests passing

English · 简体中文 · 日本語 · 한국어 · Español · Português · Français · Deutsch · Русский

📦 Releases & Changelog

Eine App zu veröffentlichen ist mehr als nur ein Build: das Einrichten der Signierung, die Konfiguration in App Store Connect / Play Console, In-App-Käufe, Listing-Metadaten, der Upload und danach die Over-the-Air-Updates. EAS baut und reicht ein — der Rest ist über die Portale von Apple und Google und eine Handvoll Werkzeuge verstreut. Launch zieht die gesamte Veröffentlichung in einen einzigen lokalen, deklarativen Workflow zusammen: es richtet Ihre Signierung ein, gleicht Ihre Store-Produkte ab, generiert das native Projekt, baut und signiert das Binary, meldet die tatsächliche Download-Größe pro Gerät, speichert das Artefakt und lädt es in den Test-Track hoch — auf Hardware, die Ihnen gehört, mit Schlüsseln, die in Ihrem lokalen Keychain bleiben. Die iOS-Signierung benötigt einen Mac; falls Sie keinen haben, baut Launch auf einem Cloud-Mac in Ihrem eigenen AWS-Konto oder reicht an Expo EAS weiter — siehe Bauen ohne Mac.

Neu hier? Führen Sie launch demo aus für eine 60-sekündige simulierte Tour durch die gesamte Pipeline — keine Einrichtung, kein Build, kein Konto erforderlich. Sie läuft außerdem automatisch ab, wenn Sie launch zum ersten Mal ausführen.

Launch feature map — setup, store configuration, build, release, re-sign, notifications, distribution, team management, and reports

Warum Launch

Der Build war nie der schwierige Teil — die Veröffentlichung drumherum ist es. Launch übernimmt diese gesamte Fläche, lokal und quelloffen:

  • Die gesamte Veröffentlichung, ein Workflow. Signierung, Store-Produkte, Build, Größenprüfung, Upload und OTA-Updates stammen aus einer einzigen launch.config.ts und einer Handvoll Befehle — nicht aus einem Dutzend Dashboards und CI-Snippets.
  • Store-Einrichtung als Code. launch sync gleicht In-App-Käufe, Abonnements, Preise und Capabilities aus einer einzigen typisierten launch.config.ts mit App Store Connect ab; ein weiteres Dutzend Befehle deckt Game Center, Wallet, App Clips, In-App-Events, A/B-Experimente, Territorien und den gesamten Google-Play-Katalog ab — dazu launch metadata für das Listing. Das sind die Teile, die EAS Ihnen zum manuellen Anklicken überlässt.
  • 0 € Compute, unbegrenzte Builds. EAS rechnet pro Build ab, begrenzt die kostenlose Stufe hinter einem 45-Minuten-Timeout und kostet in den kostenpflichtigen Plänen 19–199 $/Monat plus Mehrverbrauch. Launch baut auf Ihrem eigenen Rechner — kein Zähler, keine Warteschlange, kein Timeout.
  • Ihre Schlüssel bleiben lokal. Ihr Verteilungszertifikat, Ihr App-Store-Connect-API-Schlüssel und Ihr Android-Upload-Schlüssel bleiben in Ihrem OS-Keychain; Launch sendet immer nur eine CSR an Apple. (Das Bauen ohne Mac ist die einzige Ausnahme — siehe unten.)
  • Niemals Anbieterbindung. MIT-lizenziert, aufgebaut auf fastlane, Gradle und den eigenen APIs der Plattformen, mit austauschbaren Providern für Storage/Credentials/Build/Submit. Nichts Proprietäres, von dem Sie später migrieren müssten.
  • Es lehrt, während es läuft. Fügen Sie --explain an jeden Befehl an — oder führen Sie launch demo aus — um jeden Schritt (CSR, Provisioning-Profil, TestFlight, Play-Track, Abonnementgruppe) in verständliches Deutsch zu übersetzen.

Was Launch ist — und was nicht

Launch ist ein End-to-End-Veröffentlichungswerkzeug: es übernimmt den gesamten Weg von der Quelle bis zum Store — Build, Code-Signierung, Größenprüfung, Store-Konfiguration als Code, Upload, öffentliche Veröffentlichung und Over-the-Air-Updates — für iOS und Android, auf Hardware, die Ihnen gehört.

Launch ist nicht nur ein App-Store-Connect-SDK oder ein ASC-MCP-Server. Diese umhüllen einen Ausschnitt von Apples API; Launch steuert die gesamte Veröffentlichung über Apple und Google hinweg, mit Signierung, Build und OTA-Updates, die ein API-Wrapper nicht anfasst. Wenn Sie ein selbst gehostetes Expo EAS wollen — nicht nur einen API-Client — dann ist das Launch.

Funktionen

Einrichten & verifizieren

  • Konfiguration in einem Schritt. launch init erkennt Ihre App(s) — einschließlich eines apps/*-Monorepos — und schreibt eine kommentierte launch.config.ts (+ eine Starter-.env.example). Es schreibt nur die Konfiguration; es fasst niemals Credentials oder das native Projekt an.
  • Schlüssel in Ihrem Keychain. launch creds set-key findet die AuthKey_*.p8 in ~/Downloads, validiert sie gegen Apple und speichert sie in Ihrem OS-Geheimnisspeicher; creds setup registriert die App-ID und erstellt oder verwendet die Signier-Assets erneut; das Multi-Konto-creds use/rename/remove wechselt zwischen Teams. creds push-key legt einen nur einmal herunterladbaren APNs-Auth-Schlüssel sicher ab (Apple bietet keine API, um einen zu erstellen) und exportiert ihn bei Bedarf erneut.
  • Geheimnisse, kein Klartext-.env. launch secret set <NAME> speichert ein Build-Geheimnis in Ihrem OS-Keychain (pro App/Profil eingegrenzt) und injiziert es in die Build-Umgebung — so bleiben echte Geheimnisse aus einer committeten .env heraus; secret list (maskiert) und secret rm runden das ab.
  • launch doctor --fix. Erkennt die iOS-/Android-Toolchain und installiert die fehlenden, per Homebrew verfügbaren Werkzeuge hinter einer einzigen Zustimmung (--yes überspringt sie für CI/Agenten), kennzeichnet die store-seitigen Blocker — einen fehlenden App-Store-Connect-Eintrag, eine nicht signierte Apple-Vereinbarung — und validiert Ihre Expo-Konfiguration auf bekannte Native-Config-Fallstricke (eine falsche Bundle-ID / ein falsches Package, ein Splash ohne backgroundColor) — dieselbe Preflight-Prüfung, die launch build vorab ausführt, sodass ein einzeiliger Konfigurationsfehler in einer Sekunde scheitert, nicht erst nach einem Build. Es bringt außerdem die beiden Fallstricke zur Einreichungszeit ans Licht, die EAS verschweigt: die Antwort zur Exportkonformität (einmal aus ios.config.usesNonExemptEncryption gelesen und mit --fix über die API für den neuesten Build beantwortet) und den einmaligen manuellen App-Privacy-Fragebogen — für den Apple keine API anbietet, sodass Launch stattdessen die exakte Checkliste ausdruckt, statt ihn eine Einreichung überraschend blockieren zu lassen.
  • Signierungsstatus auf einen Blick. launch setup ios meldet Ihr iOS-Provisioning durchgängig — aktives Konto, App-ID, Capabilities, Verteilungszertifikat, Profil und registrierte Geräte — und stellt mit --provision das Zertifikat + das App-Store-Profil sicher, genau wie launch creds setup.

App Store Connect konfigurieren — als Code

Jeder Abschnitt unten wird in launch.config.ts (oder seiner eigenständigen *.config.json-Beilage) deklariert und mit einem schreibgeschützten Plan → Ihre Bestätigung → Anwenden abgeglichen — idempotent, ohne jemals eine aktive oder in Prüfung befindliche Version anzufassen. Das ist die Fläche, die EAS vollständig der App-Store-Connect-Website überlässt.

  • Produkte, Preise & Listing. launch sync gleicht Ihre In-App-Käufe, Abonnements, Capabilities und Preise mit App Store Connect ab — und im selben Durchlauf die Listing-Texte pro Sprache (Name, Untertitel, Beschreibung, Schlüsselwörter, Neuerungen, Datenschutz-/Support-/Marketing-URLs), Screenshots und App-Vorschauen — über alle Apps auf einmal.
  • Abonnement-Angebote. launch offers gleicht Angebotscodes sowie Promotion-, Einführungs- & Rückgewinnungs-Angebote ab, dazu die Reihenfolge der beworbenen Käufe; launch offers generate-codes/list/deactivate steuern Angebotscode-Kampagnen über die CLI.
  • Release-Attribute. launch release-config gleicht die App-Store-Altersfreigabe, Kategorien, den Grundpreis und die App-Review-Details (Kontakt + Demo-Konto) mit der bearbeitbaren Version ab.
  • App-Identität & Berechtigungen. launch game-center (Erfolge & Bestenlisten), launch wallet (Apple-Pay-Händler-IDs & Wallet-Pass-Type-IDs), launch app-clips (App-Clip-Karten-Aktion + Untertitel) und launch eu-distribution (EU-Domains für alternative Verteilung + Package-Signier­schlüssel, für den DMA) — die im Portal angeklickte Team-Einrichtung, die spaceship offenlegt, EAS aber nicht.
  • Merchandising & Präsenz. launch availability (Territorien, in denen die App verkauft wird), launch custom-pages (alternative Produktseiten), launch experiments (A/B-Tests der Produktseite), launch accessibility (Barrierefreiheits-Nährwertkennzeichnungen), launch events (In-App-Events) und launch metadata pull/push (das vollständige Listing für iOS und Android — eas metadata ist nur für iOS).

Google Play konfigurieren — als Code

  • Play-Produkte & -Abonnements. launch play-products und launch play-subscriptions gleichen Ihre Play-In-App-Produkte und -Abonnements (Basispläne + Angebote) aus demselben launch.config.ts-Katalog ab, der auch App Store Connect ansteuert — eine einzige Quelle der Wahrheit, beide Stores.
  • Tracks & Rezensionen. launch play-tracks zeigt den Track-Status an und befördert einen Build in einen Track mit einem gewählten Rollout und Release-Notes (und liest/setzt Tester-Gruppen); launch play-reviews liest die Kundenrezensionen aus Play und postet Antworten — ohne die Play Console zu öffnen.

Bauen & veröffentlichen — iOS und Android

  • Ein Befehl pro Plattform. launch build ios / launch build android führt Prebuild → Signieren → Größenprüfung → Upload in den Test-Track (TestFlight / Play intern) aus — derselbe Ablauf, den EAS ausführt.
  • Standardmäßig schnell. ccache wird bei pod install eingebunden, DerivedData bleibt warm, und ein Fingerabdruck des nativen Graphen erzwingt einen sauberen Build nur dann, wenn sich Ihre nativen Abhängigkeiten tatsächlich ändern. JS-Änderungen bauen inkrementell neu; --clean erzwingt einen vollständigen Neubau.
  • Echte Download-Größenprüfung. Meldet die tatsächliche Größe pro Gerät (App-Thinning-Bericht / bundletool) und sperrt anhand des von Ihnen konfigurierten sizeBudgetMB.
  • Sicherheitsnetze. Verweigert den Upload eines Simulator-Builds, einer .app oder eines leeren Artefakts; --dry-run probt die gesamte Pipeline ohne Netzwerk-, Build- oder Kontoänderungen.
  • Bewusste öffentliche Veröffentlichung — kein Portal. Der Test-Track ist die Vorgabe; der öffentliche Store ist das separate, bestätigte launch release <platform>. Für iOS steuert es die App-Store-Connect-API durchgängig — Version erstellen/wiederverwenden, Exportkonformität beantworten, Build anhängen, Release-Notes schreiben, sofortigen / geplanten / phasenweisen Rollout wählen und zur Prüfung einreichen — sodass eine Veröffentlichung nie die Website benötigt. launch status [--watch] [--json] verfolgt die Prüfung (mit CI-Exit-Codes), und launch rollout pause|resume|complete steuert einen phasenweisen Rollout. fastlane ist allein auf den Binary-Upload beschränkt.
  • Neu signieren ohne Neubau. launch build:resign signiert eine gespeicherte .ipa/.aab mit anderen Credentials (einem neuen Konto oder Profil) direkt aus dem Artefakt neu — ohne Neubau.
  • Abschlussbenachrichtigungen. Ein notify-Block pingt einen Slack-/Discord-Webhook und/oder führt einen Shell-Hook aus, wenn ein Build oder eine Einreichung abschließt — bei Erfolg und Misserfolg — sodass ein unbeaufsichtigter/CI-Lauf Ihnen mitteilt, wann er fertig ist. Entspricht EAS-webhook, ohne gehosteten Dienst.

Verteilen & aktualisieren

  • Interne Verteilung. launch build <platform> --distribution internal hostet einen Ad-hoc-iOS-Installationslink / eine Android-.apk in Ihrem eigenen Bucket; registrieren Sie Tester mit launch device add <udid>.
  • Over-the-Air-Updates. launch update veröffentlicht ein JS-/Asset-Update über das Expo-Updates-Protokoll, das expo-updates bereits spricht — code-signiert und in Ihrem eigenen Bucket (S3 / R2 / Supabase) gehostet.
  • Ein schlechtes Update zurückrollen. launch updates list/view zeigen die Historie pro Kanal; launch updates rollback macht ein schlechtes OTA rückgängig — befördern Sie ein bekanntermaßen gutes Update oder setzen Sie Tester auf das eingebettete Bundle zurück.

Tester, Team, Rezensionen & Berichte verwalten — nur per API-Schlüssel

  • TestFlight von der CLI aus. launch testflight groups/create-group/testers/add/rm verwaltet Beta-Gruppen und lädt Tester über denselben App-Store-Connect-API-Schlüssel ein — die Verwaltungsebene rund um den Build-Upload, ohne Apple-ID-Passwort und ohne 2FA.
  • Rezensionen, lesen & beantworten. launch reviews [list] liest Kundenrezensionen (gefiltert nach Bewertung / Territorium); launch reviews reply postet oder ersetzt die Entwicklerantwort, und launch reviews delete entfernt sie — ohne App Store Connect zu öffnen.
  • Verkaufs-, Finanz- & Analyseberichte. launch reports sales/finance/analytics lädt die Berichte zu Verkäufen & Trends, Finanzen und Analysen aus App Store Connect (gezippte TSV) direkt auf Ihren Rechner zum Skripten herunter — die Zahlen, die EAS nie offenlegt.
  • Team & Zugriff. launch team list/invite/remove liest und verwaltet App-Store-Connect-Teammitglieder und ausstehende Einladungen — laden Sie per E-Mail mit Rollen ein oder widerrufen Sie sie — über denselben API-Schlüssel.
  • Sandbox-Tester. launch sandbox list/clear listet Ihre StoreKit-Sandbox-Tester auf und löscht deren Kaufhistorie, sodass Sie In-App-Käufe von einem sauberen Stand aus erneut testen können.

Untersuchen & debuggen

  • Build-Historie. launch builds list/view/log liest den lokalen Artefakt-Index — IDs, Größen pro Gerät, Artefaktpfade und das rohe Build-Log für jeden Build.
  • Installieren & ausführen. launch run [id|latest] installiert ein gebautes Artefakt auf einem verbundenen Gerät oder Simulator (adb/bundletool für Android, devicectl für iOS).
  • Einen Fehler erklären. launch diagnose ordnet einen xcodebuild-/Gradle-/CocoaPods-Fehler einer verständlichen Ursache und Lösung zu; launch fingerprint zeigt, warum der nächste Build sauber statt inkrementell ist. --verbose streamt die rohe Build-Ausgabe statt des Fortschritts-Spinners.

Onboarding & Lehre

  • launch demo. Eine simulierte Tour ohne Einrichtung durch die gesamte Pipeline (läuft beim ersten Lauf einmal automatisch ab); --explain an jedem Befehl und launch explain <topic> decken die Terminologie auf Abruf ab.
  • Stilles Selbst-Upgrade. Greift eine neuere npm-Version auf und führt Ihren Befehl darauf erneut aus — gedrosselt auf einmal täglich und ein No-Op in CI, bei Piping und für Agenten.

Launch vs. EAS

Launch führt dieselbe eas build → eas submit → eas update-Pipeline (plus eas metadata und eas credentials) auf Hardware aus, die Ihnen gehört — und deckt die Store-Einrichtungsschritte ab, die EAS Ihnen überlässt. Wo sich die beiden im selben Workflow unterscheiden:

In Expo EAS In Launch
Der Build-Compute läuft in Expos Cloud, 19–199 $/Monat + Gebühren pro Build Baut auf Ihrem eigenen Rechner — 0 € Compute, MIT-lizenziert, unbegrenzte Builds
Builds warten in der Schlange in einer geteilten Cloud, manchmal stundenlang Builds starten sofort auf Ihrer Hardware — keine Warteschlange
Builds der kostenlosen Stufe sind auf ein 45-Minuten-Timeout begrenzt Kein Timeout — ein Build läuft so lange, wie er muss
Apple-ID-2FA-Aufforderungen / abgelaufene Codes unterbrechen Builds Authentifiziert sich mit einem App-Store-Connect-API-Schlüssel (JWT) — kein Passwort, keine 2FA
Toolchain/Node durch das Build-Image festgelegt; lokale .env wird nicht aufgelöst Ihr eigenes Xcode/Node/Ihre Toolchain und eine dokumentierte Env-Vorrang-Leiter (--print-env zum Prüfen)
In-App-Käufe & Abonnements sind Handarbeit in der ASC-Oberfläche launch sync gleicht IAPs, Abonnements & Capabilities aus launch.config.ts ab
EAS schreibt die Bundle-ID-Capabilities bei jedem Build neu (überschreibt Schalter) launch sync wendet ein minimales sicheres Diff an — Capabilities, die es nicht verwaltet, bleiben unangetastet
eas metadata ist nur für iOS launch metadata synchronisiert das Listing für iOS und Android
Play-IAPs, -Abonnements, -Tracks & -Rezensionen bedeuten die Play-Console-Oberfläche launch play-products / play-subscriptions gleichen Play aus derselben Konfiguration ab; launch play-tracks / play-reviews steuern Tracks & Antworten über die API
Game Center, Wallet, App Clips, In-App-Events, A/B-Experimente, Territorien & Barrierefreiheit sind nur über das Portal Jedes ist Konfiguration als Code — launch game-center / wallet / app-clips / events / experiments / availability / accessibility
Nach eas submit ist die App-Store-Veröffentlichung (Version, Konformität, Notizen, Rollout) Handarbeit im Portal launch release steuert es über die API — danach verfolgen und steuern launch status --watch und launch rollout es
Rezensionen, Berichte & TestFlight-Verwaltung bedeuten einen Gang zur Website launch reviews / launch reports / launch testflight erledigen sie über den API-Schlüssel — kein Portal
EAS Update hostet Ihre OTA-Updates auf Expos Servern (kostenpflichtig) launch update liefert das gleiche Expo-Updates-Protokoll aus Ihrem eigenen Bucket (S3/R2/Supabase)
Builds für die interne Verteilung werden von Expo gehostet --distribution internal hostet die Ad-hoc-.ipa/.apk in Ihrem eigenen Bucket; launch device
Signier-Credentials können auf Expos Servern liegen Schlüssel bleiben in Ihrem OS-Keychain — nur eine CSR verlässt jemals Ihren Rechner
Build-Artefakte werden auf Expo gehostet Artefakte landen in Ihrem eigenen Storage (lokal oder S3 / R2 / Supabase)
Kein Mac? Expos kostenpflichtige Cloud ist der einzige Weg Kein Mac? Ein Cloud-Mac in Ihrem eigenen AWS, ein beliebiger Mac über SSH oder Übergabe an eas build
Geschlossenes SaaS — proprietär, Anbieterbindung MIT, quelloffen — fastlane/Gradle/Plattform-APIs, austauschbare Provider, nichts zu migrieren

Voraussetzungen

  • iOS: eine Apple-Developer-Program-Mitgliedschaft (99 $/Jahr) — hier registrieren — und dann macOS mit Xcode + Befehlszeilenwerkzeugen, fastlane (brew install fastlane) und ein App-Store-Connect-API-Schlüssel (.p8 + Key-ID + Issuer-ID) — hier einen generieren. Kein Mac? Siehe Bauen ohne Mac.
  • Android: ein Google-Play-Developer-Konto (einmalig 25 $) — hier registrieren — und dann ein JDK (jedes Betriebssystem — kein Mac nötig) und ein Google-Play-Dienstkonto-JSON-Schlüssel.
  • Node 20+ auf jeder Plattform.

Führen Sie jederzeit launch doctor aus, um alles oben Genannte zu prüfen.

Installation

npm install --save-dev launch-store     # per-project (recommended; resolves the typed launch.config.ts)
npm install --global launch-store       # or global, for just the `launch` command

Schnellstart

Von der Paywall bis zum Test-Track in fünf Befehlen (tauschen Sie ios → android für Google Play):

launch init                 # scaffold launch.config.ts + .env.example, tailored to your repo
launch creds set-key        # import your store API key into the OS keychain
launch creds setup          # register the app id + create/reuse signing assets
launch build ios --dry-run  # rehearse the whole flow — no network, no build, no account changes
launch build ios            # build, sign, size-check, and upload to the testing track

launch build verwendet Ihre zwischengespeicherten Credentials stillschweigend wieder; falls sie fehlen, bietet es an, sie inline einzurichten. Die öffentliche Veröffentlichung ist das separate, bewusste launch release <platform>.

Verkaufen Sie In-App-Käufe oder Abonnements? Deklarieren Sie sie in launch.config.ts und führen Sie launch sync aus, um sie auf App Store Connect zu erstellen und abzugleichen — ohne sich durch das Portal zu klicken.

Veröffentlichen Sie bereits eine App? launch adopt liest Ihre aktive App-Store-Connect-Einrichtung — Produkte, Capabilities, Signierung und Listing — und schreibt sie in einem Schritt zurück in die Konfiguration, sodass Sie sie mit sync weitertreiben können.

Befehle

Die alltäglichen:

Befehl Was er tut
launch build <ios|android> Führt die vollständige Pipeline aus — Prebuild, Signieren, Build, Größenprüfung, Upload in den Test-Track.
launch release <ios|android> Veröffentlicht den neuesten Build im öffentlichen Store, mit Bestätigung.
launch update Veröffentlicht ein Over-the-Air-JS-Update (Expo-Updates-Protokoll) in Ihren eigenen Bucket.
launch sync Gleicht App-Store-Connect-Produkte, -Preise und das Listing aus launch.config.ts ab.
launch adopt Bindet eine bereits veröffentlichte App ein — importiert ihre App-Store-Connect-Einrichtung in die Konfiguration.
launch creds Untersucht Credentials, importiert den API-Schlüssel, richtet die Signierung ein, wechselt Apple-Konten.
launch doctor Prüft, ob die lokale Toolchain und das Store-Konto bereit sind.

Vollständige Befehlsreferenz → docs/commands.md — alle 45 Befehle und jedes Flag, aus der CLI generiert, sodass sie nie veraltet. Oder führen Sie launch <command> --help aus.

Driving Launch from an AI agent? launch agents init scaffolds ready-made skills into your repo — Claude Code Skills (.claude/skills/), Cursor rules (.cursor/rules/), and a Launch section in AGENTS.md for Codex — so Claude Code, Cursor, and Codex can run the workflows above (ship, release, store-config-as-code, OTA updates, CI, and launch doctor) with the same plan → confirm → apply guardrails Launch uses, and never publish without your say-so. launch agents check keeps them in sync.

Konfiguration

App-Fakten (Bundle-ID, Version) werden aus der Expo-Konfiguration jeder App gelesen — app.json oder app.config.{ts,js} — sodass sie nie dupliziert werden. launch.config.ts enthält nur Launch-spezifische Einstellungen:

import { defineConfig } from "launch-store";

export default defineConfig({
  // appRoots: ["./apps"],   // for a monorepo; omit to scan the repo root
  credentials: "local", // OS keychain + ~/.launch
  storage: "local", // ~/.launch/artifacts (swap for s3/r2/supabase later)
  buildEngine: "fastlane", // "fastlane" (local Mac) · "remote-mac" (AWS EC2 Mac) · "eas" (Expo cloud)
  // submit: "app-store-connect", // or "eas" to submit through Expo

  // Only needed to build iOS without a Mac via `--remote aws` — see "Building without a Mac".
  // aws: { region: "us-east-1" },

  profiles: {
    // `env` is inline per-profile vars; `envFile` renames the base dotenv. Precedence, highest first:
    // --env flags › keychain secrets › profile `env:` › .env.local (--include-local) › .env.<profile> › .env
    production: {
      name: "production",
      envFile: ".env",
      env: {},
      sizeBudgetMB: 200,
    },
  },

  // Ping a Slack/Discord webhook and/or run a shell hook when a build or submit finishes (success or
  // failure). Both fields are optional; omit `notify` entirely for no notifications.
  // notify: { webhookUrl: "https://hooks.slack.com/services/…", command: "say build done" },

  // In-app purchases & subscriptions, keyed by bundle id — `launch sync` reconciles these onto App Store
  // Connect (and `launch play-products` / `play-subscriptions` onto Google Play). Capabilities aren't
  // declared here; they're read from app.json's `ios.entitlements`. Omit if your app sells nothing.
  // products: { "com.company.app": { subscriptionGroups: [/* … */], inAppPurchases: [/* … */] } },

  // Launch-native App Store Connect sections — each reconciled by its own command, declared inline here
  // (or, for back-compat, as a standalone `*.config.json` sidecar). Per-app ones are keyed by iOS bundle
  // id; Wallet & EU distribution are team-level. See examples/hello-world for a worked copy of each.
  // gameCenter: { "com.company.app": { achievements: [/* … */], leaderboards: [/* … */] } },
  // appClips: { "com.company.app": { clips: { "com.company.app.Clip": { action: "OPEN" } } } },
  // releaseAttributes: { "com.company.app": { pricing: { customerPrice: 9.99 }, categories: { primary: "PRODUCTIVITY" } } },
  // wallet: { merchantIds: [/* … */], passTypeIds: [/* … */] },
  // euDistribution: { domains: [/* … */] },
});

Führen Sie launch build <platform> --print-env aus, um die vollständig aufgelöste Umgebung zu sehen und zu erfahren, woher jeder Wert stammt (Geheimnisse maskiert), noch bevor ein einziger Build läuft. Ein voll ausgestattetes Beispiel für zwei Plattformen (iOS + Android) — das jede Konfiguration-als-Code-Fläche durchexerziert, von Produkten, Angeboten und Release-Attributen über Game Center, Wallet, EU-Verteilung bis hin zum Google-Play-Katalog — liegt in examples/hello-world (siehe dessen README für eine Funktion-für-Funktion-Tour).

Bauen ohne Mac

Die iOS-Signierung ist nur unter macOS möglich, daher braucht ein Windows-/Linux-Entwickler irgendwo einen Mac. Führen Sie launch (den Assistenten) aus oder wählen Sie direkt einen Weg. Android baut überall dort, wo ein JDK läuft, also gilt nichts davon für Android.

Weg Was passiert Kosten
AWS-Cloud-Mac Launch richtet einen EC2-Mac in Ihrem eigenen AWS-Konto ein, baut + signiert + reicht ein und baut ihn dann wieder ab. Sie zahlen direkt an AWS — ~16 $ Minimum pro 24-Stunden-Sitzung (Apples Lizenz setzt eine harte 24-Stunden-Untergrenze).
Mac verbinden (SSH) Bauen Sie auf jedem Mac, den Sie erreichen können — dem eines Kollegen, MacStadium, einer von Hand gestarteten Instanz. Was auch immer dieser Mac Sie kostet.
Expo EAS Launch orchestriert eas-cli durchgängig (eas build → Download → eas submit) in Expos Cloud. Expos kostenlose Stufe mit monatlichen Obergrenzen. 
launch build ios --remote aws            # build on a cloud Mac in your AWS account
launch build ios --remote ec2-user@host  # build on a Mac you reach over SSH
launch cloud doctor                      # check AWS creds, region, Mac-host quota, IAM
launch cloud status                      # live host: age, cost so far, releasable-after time
launch cloud teardown                    # stop + release the host (warns about the 24h floor)

Remote-Builds laden eine flüchtige Kopie Ihrer Signier-Schlüssel mit ausdrücklicher Zustimmung auf Ihren eigenen Host hoch und zerstören sie danach — niemals auf die Server von irgendjemand anderem. Für gelegentliche iOS-Builds ist ein GitHub-Actions-macOS-Runner günstiger als ein EC2-Mac; der Wert von Launch liegt hier in der Automatisierung in Ihrem eigenen Konto mit überall denselben Schlüsseln.

Wie Ihre Credentials gehandhabt werden

  • Der API-Schlüssel (.p8), der private Verteilungsschlüssel und der Android-Upload-Schlüssel liegen in Ihrem OS-Keychain.
  • Das iOS-Zertifikat wird zusätzlich als passwortgeschützte .p12 unter ~/.launch/credentials/ (chmod 600) gesichert; das Passwort wird im Keychain gespeichert, nie neben der Datei.
  • Ihr privater Schlüssel wird lokal generiert — nur eine CSR wird jemals an Apple gesendet.
  • Launch verwendet ein vorhandenes Verteilungszertifikat wieder, statt neue zu erstellen (die Stores begrenzen sie).

FAQ

Was ist Launch? Launch ist eine quelloffene, selbst gehostete Alternative zu Expo EAS: es baut, signiert und veröffentlicht Expo- / React-Native-Apps zu TestFlight und Google Play von Ihrem eigenen Rechner aus, mit Ihren eigenen Schlüsseln und ohne Abrechnung pro Build. Es führt dieselbe Build → Submit → Update-Pipeline aus, die EAS auch ausführt, und fügt die Store-Einrichtungsschritte hinzu, die EAS der App-Store-Connect- und Play-Console-Website überlässt — In-App-Käufe, Abonnements, Capabilities und Listing-Metadaten — als Code.

Ist Launch eine kostenlose, quelloffene Alternative zu Expo EAS? Ja. Launch ist MIT-lizenziert und vollständig quelloffen, und Builds laufen auf Hardware, die Ihnen gehört, sodass es keine Gebühr pro Build, keinen Build-Minuten-Zähler und kein Monatsabonnement gibt — gegenüber EAS' kostenpflichtigen Stufen von $19–$199/mo plus Mehrverbrauch pro Build. Die einzige optionale Kostenstelle ist das Mieten eines Cloud-Macs, wenn Sie iOS ohne einen eigenen Mac bauen müssen.

Wie unterscheidet sich Launch von Expo EAS? EAS führt Ihre Builds in Expos Cloud aus und speichert Ihre Credentials, Artefakte und OTA-Updates auf Expos Servern. Launch führt dieselbe Pipeline auf Ihrem eigenen Rechner aus, hält Signierschlüssel in Ihrem OS-Keychain und speichert Artefakte und OTA-Updates in Ihrem eigenen Bucket (S3 / R2 / Supabase) — und verwaltet dann die Store-Konfiguration, die EAS nicht abdeckt (IAPs, Abonnements, Capabilities und das iOS- und Android-Listing) als Code. Die Befehle entsprechen sich eins zu eins: eas build → launch build, eas submit → launch release, eas update → launch update, eas metadata → launch metadata, eas credentials → launch creds.

Kann ich iOS-Apps ohne einen Mac bauen? iOS-Code-Signierung und die Build-Toolchain sind nur unter macOS verfügbar, sodass ein Mac im Spiel sein muss — aber er muss nicht Ihrer sein. Launch kann einen Cloud-Mac in Ihrem eigenen AWS-Konto (einen EC2 Mac) bereitstellen, über SSH auf jedem erreichbaren Mac bauen oder an Expo EAS' Cloud übergeben. Android-Builds laufen überall, wo ein JDK läuft, ganz ohne Mac.

Unterstützt Launch Android und Google Play? Ja. Launch baut und signiert Android-Apps und lädt sie zu Google Play hoch, und es gleicht Play-In-App-Produkte, Abonnements (Basispläne + Angebote), Release-Tracks und Rezensionsantworten aus demselben launch.config.ts-Katalog ab, der auch App Store Connect steuert — eine einzige Quelle der Wahrheit für beide Stores.

Bietet Launch Over-the-Air-Updates wie EAS Update? Ja. launch update veröffentlicht JS- und Asset-Updates über das Expo-Updates-Protokoll, das Ihre expo-updates-Laufzeit bereits spricht — code-signiert und in Ihrem eigenen Bucket (S3 / R2 / Supabase) statt auf Expos Servern gehostet. launch updates rollback macht eine schlechte Veröffentlichung rückgängig, indem es ein bekanntermaßen gutes Update beförder oder Clients auf das eingebettete Bundle zurücksetzt.

Wie migriere ich von Expo EAS zu Launch? Tauschen Sie die Befehle eins zu eins aus (eas build → launch build, eas submit → launch release, eas update → launch update, eas credentials → launch creds, eas metadata → launch metadata). Falls Ihre App bereits veröffentlicht ist, liest launch adopt Ihre aktive App-Store-Connect-Einrichtung — Produkte, Capabilities, Signierung und Listing — und schreibt sie in einem Schritt zurück in launch.config.ts. Launch kann auch weiterhin an eas build übergeben, wenn Sie keinen Mac haben, sodass Sie schrittweise migrieren können.

Ist Launch nur ein App-Store-Connect-SDK oder MCP-Wrapper? Nein. Ein App-Store-Connect-SDK oder MCP-Server umhüllt einen Ausschnitt von Apples API. Launch steuert die gesamte Veröffentlichung über Apple und Google hinweg — Code-Signierung, native Builds, Größenprüfungen, Store-Konfiguration als Code, die bestätigte öffentliche Veröffentlichung und OTA-Updates — nichts davon berührt ein API-Wrapper. Wenn Sie ein selbst gehostetes Expo EAS statt eines API-Clients möchten, ist das Launch.

Wie unterscheidet sich Launch von Fastlane? Fastlane ist ein Baustein; Launch orchestriert ihn. Launch verwendet fastlane nur für den Binary-Upload-Schritt und umhüllt die gesamte Veröffentlichung damit: Credential-Provisionierung, den Build, die echte Download-Größenprüfung, Store-Konfiguration als Code für beide Stores, die bewusste öffentliche Veröffentlichung, Phased-Rollout-Kontrolle und OTA-Updates — alles aus einer typisierten launch.config.ts.

Wo werden meine Signierschlüssel und Geheimnisse gespeichert? In Ihrem OS-Keychain. Ihr App-Store-Connect-API-Schlüssel (.p8), privater Verteilungsschlüssel und Android-Upload-Schlüssel berühren nie das Repo oder die Server von irgendjemandem — es wird immer nur ein Certificate Signing Request (CSR) an Apple gesendet. Build-Geheimnisse leben ebenfalls im Keychain, über launch secret, sodass sie aus einer committeten .env herausbleiben.

Was benötige ich, um Launch auszuführen? Node 20+ überall. Für iOS: macOS mit Xcode und seinen Befehlszeilenwerkzeugen, fastlane und einen App-Store-Connect-API-Schlüssel (.p8 + Key-ID + Issuer-ID) — oder einen Remote-Mac, wenn Sie keinen haben. Für Android: ein JDK (jedes Betriebssystem) und einen Google-Play-Dienstkonto-JSON-Schlüssel. Führen Sie launch doctor aus, um alles auf einmal zu prüfen.

Was kostet Launch? Launch selbst ist kostenlos (MIT). Sie zahlen nur für das, was Sie ohnehin zahlen würden: Ihre eigene Build-Hardware (oder Cloud-Mac-Zeit, wenn Sie iOS ohne einen lokalen Mac bauen), plus die üblichen Apple-Developer-($99/yr) und Google-Play-Registrierungsgebühren (einmalig $25). Es gibt keine Gebühr pro Build und kein Abonnement.

Läuft Launch in CI? Ja. launch ci init erstellt ein GitHub-Actions-Workflow-Gerüst auf einem gehosteten macOS-Runner, und jeder Befehl degradiert auf nicht-interaktiv, wenn er CI, ein gepipetes stdout oder einen Agenten erkennt — sodass derselbe Ablauf unbeaufsichtigt läuft.

Welche Frameworks unterstützt Launch? Expo- und bare-React-Native-Apps, die sich über die Expo-Konfiguration (app.json / app.config.{ts,js}) und expo prebuild selbst beschreiben. Launch liest Ihre Bundle-ID, Version und Entitlements von dort, sodass nichts dupliziert wird.

Kann Launch Store-Metadaten, In-App-Käufe und Abonnements verwalten? Ja — als Code, für beide Stores. launch sync gleicht IAPs, Abonnements, Preise, Capabilities und das pro-Locale-Listing (Text, Screenshots, Vorschauen) mit App Store Connect ab; launch metadata deckt das Listing für iOS und Android ab; launch play-products / launch play-subscriptions steuern den Google-Play-Katalog. Jeder Befehl führt ein schreibgeschütztes Plan → Bestätigen → Anwenden aus, sodass er nie eine aktive oder in Prüfung befindliche Version überschreibt.

Bindet mich Launch an einen gehosteten Dienst? Nein — es gibt nichts Gehostetes und nichts Proprietäres. Launch ist MIT-lizenziert, aufgebaut auf fastlane, Gradle und den eigenen APIs der Plattformen, mit austauschbaren Storage- / Credentials- / Build- / Submit-Providern. Ihre Schlüssel, Artefakte und Updates liegen in Infrastruktur, die Sie kontrollieren, sodass es später nichts zu migrieren gibt.

Wie fange ich an? Installieren Sie mit npm install --global launch-store (oder --save-dev pro Projekt), dann führen Sie launch demo für eine 60-sekündige simulierte Führung aus — keine Einrichtung oder Konto erforderlich. Wenn Sie bereit sind: launch init → launch creds set-key → launch creds setup → launch build ios.

Mitwirken

Siehe CONTRIBUTING.md für die Entwicklungseinrichtung, das Qualitäts-Gate und wie man ein Backend hinzufügt.

Mitwirkende

YosefHayim

Alle Mitwirkenden →

Lizenz

MIT

Launch ist eine quelloffene Expo-EAS-Alternative — eine lokale, selbst gehostete Möglichkeit, React-Native-Apps von Ihrem eigenen Rechner aus in den App Store und zu Google Play zu bauen und zu veröffentlichen: iOS-Code-Signierung, Einreichung bei TestFlight & Google Play, Store-Konfiguration als Code und OTA-Updates über das Expo-Protokoll, ohne Abrechnung pro Build.