Skip to content
Back to search

greenlight

MarketplaceWorks with Claude CodeGitHub

Greenlight — Apple App Store and Google Play pre-submission compliance scanner.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/revylai--greenlight/badge.svg)](/listings/revylai--greenlight)

HTML

<a href="/listings/revylai--greenlight"><img src="/api/listings/revylai--greenlight/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# Homebrew (macOS)
brew install revylai/tap/greenlight

# Go
go install github.com/RevylAI/greenlight/cmd/greenlight@latest

# Build from source
git clone https://github.com/RevylAI/greenlight.git
cd greenlight && make build
# Binary at: build/greenlight

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 33 lines
  1. {
  2. "name": "greenlight",
  3. "owner": {
  4. "name": "revylai"
  5. },
  6. "description": "Greenlight \u2014 Apple App Store and Google Play pre-submission compliance scanner.",
  7. "plugins": [
  8. {
  9. "name": "greenlight",
  10. "source": "./",
  11. "description": "Run every App Store and Google Play compliance check in one command: code patterns, privacy manifests, Android manifests and Gradle, IPA/APK/AAB binaries, metadata. Catches rejections before you submit.",
  12. "category": "compliance",
  13. "tags": [
  14. "apple",
  15. "app-store",
  16. "review",
  17. "guidelines",
  18. "ios",
  19. "swift",
  20. "react-native",
  21. "expo",
  22. "rejection",
  23. "compliance",
  24. "android",
  25. "google-play",
  26. "play-policy",
  27. "gradle",
  28. "aab"
  29. ],
  30. "strict": true
  31. }
  32. ]
  33. }
README.md · README · 424 lines
  1. # greenlight
  2. [![Release](https://img.shields.io/github/v/release/RevylAI/greenlight?color=2ea44f)](https://github.com/RevylAI/greenlight/releases)
  3. [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
  4. [![Go](https://img.shields.io/badge/go-1.24+-00ADD8?logo=go&logoColor=white)](go.mod)
  5. [![Powered by Revyl](https://img.shields.io/badge/powered%20by-Revyl-1C1833)](https://revyl.com?utm_source=greenlight&utm_medium=readme&utm_campaign=badge)
  6. **Know before you submit.** Pre-submission compliance scanner for the Apple App Store and Google Play.
  7. Greenlight reads your app (source code, privacy manifests, Android manifests and Gradle builds, IPA binaries, App Store Connect metadata) and checks it against Apple's Review Guidelines and Google Play's Developer Program Policies. Every finding cites the rule it comes from. No account, no uploads, no network. A full preflight on a mid-size project finishes in single-digit milliseconds.
  8. A static scan can only prove a flow *exists*. `greenlight verify` proves it *works*: it runs your account-deletion, restore-purchases, and Sign in with Apple flows on a cloud device and fails the build if any of them dead-ends. That tier is powered by [Revyl](https://revyl.com?utm_source=greenlight&utm_medium=readme&utm_campaign=intro) and needs a free account. Everything else on this page runs offline. See [`greenlight verify`](#greenlight-verify-path).
  9. ## Install
  10. ```bash
  11. # Homebrew (macOS)
  12. brew install revylai/tap/greenlight
  13. # Go
  14. go install github.com/RevylAI/greenlight/cmd/greenlight@latest
  15. # Build from source
  16. git clone https://github.com/RevylAI/greenlight.git
  17. cd greenlight && make build
  18. # Binary at: build/greenlight
  19. ```
  20. ## Quick start
  21. ```bash
  22. # Everything, one command, zero uploads
  23. greenlight preflight /path/to/your/project
  24. # Include an IPA for binary analysis
  25. greenlight preflight . --ipa build.ipa
  26. # Gate CI on it
  27. greenlight preflight . --exit-code
  28. ```
  29. ## Severity
  30. Four levels. The top two fail a CI gate; the bottom two are advisory.
  31. | Level | Meaning |
  32. |-------|---------|
  33. | CRITICAL | Rejection or install failure is near-certain. Fix before you submit. |
  34. | HIGH | A published deadline, a required declaration, or a check that fails at runtime. |
  35. | WARN | Likely to draw reviewer attention or an information request. |
  36. | INFO | Best practice. |
  37. `--exit-code` trips on CRITICAL and HIGH, and on a scanner that crashed, so an incomplete scan never reports as a pass.
  38. ## Commands
  39. ### `greenlight preflight [path]`
  40. Runs every applicable scanner in parallel. Android and iOS projects in one repo are both picked up, so a cross-platform app is checked against both stores in a single pass.
  41. ```bash
  42. greenlight preflight . # scan current directory
  43. greenlight preflight ./my-app --ipa build.ipa # with binary inspection
  44. greenlight preflight . --format json # JSON for CI
  45. greenlight preflight . --format sarif --output greenlight.sarif
  46. greenlight preflight . --exit-code # non-zero on CRITICAL/HIGH
  47. ```
  48. | Scanner | Checks |
  49. |---------|--------|
  50. | metadata | app.json / Info.plist: name, version, bundle ID format, icon, privacy policy URL, purpose strings |
  51. | codescan | 24 rules over Swift, Objective-C, React Native, and Expo source |
  52. | privacy | PrivacyInfo.xcprivacy completeness, Required Reason APIs, tracking SDKs vs ATT |
  53. | playscan | Google Play policy, target API deadline, restricted permissions, foreground service types, Play Billing version (Android projects only) |
  54. | ipa | Binary: Info.plist keys, launch storyboard, icons, app size, framework privacy manifests |
  55. Adding `--verify` extends the same command into the runtime tier, so one invocation covers static and runtime:
  56. ```bash
  57. greenlight preflight . --verify --build-name "My App" \
  58. --var email=qa@acme.com --var password=secret --exit-code
  59. ```
  60. `--verify` accepts the same targeting flags as the standalone command: `--artifact`, `--build-name`, `--device-model`, `--os-version`, `--var`.
  61. ### `greenlight codescan [path]`
  62. ```bash
  63. greenlight codescan /path/to/project
  64. greenlight codescan . --config path/to/.greenlight.yml
  65. ```
  66. 24 rules, roughly 60 patterns, over Swift, Objective-C, React Native, and Expo.
  67. CRITICAL:
  68. - Private API usage (§2.5.1)
  69. - Hardcoded secrets and API keys (§1.6)
  70. - External payment for digital goods (§3.1.1)
  71. - Dynamic code execution (§2.5.2)
  72. - Cryptocurrency mining (§3.1.5)
  73. - UIWebView, a removed API and a hard rejection (§2.5.1)
  74. HIGH:
  75. - Missing Sign in with Apple alongside social login (§4.8)
  76. - Missing Restore Purchases with IAP (§3.1.1)
  77. - Missing ATT with ad or tracking SDKs (§5.1.2)
  78. - Account creation with no deletion path (§5.1.1)
  79. - A crypto exchange or on-ramp SDK, which usually needs licensing or a legal opinion (§3.1.5(b))
  80. WARN:
  81. - Crypto wallet, which requires an Organization account (§3.1.5(b)), plus exchange signals in copy and references to exchange brands
  82. - Insecure HTTP URLs (§1.6)
  83. - Vague Info.plist purpose strings, and missing required privacy keys (§5.1.1)
  84. - Placeholder content left in strings (§2.1)
  85. - References to competing platforms (§2.3)
  86. - Hardcoded IPv4 addresses (§2.5)
  87. - WebView-only app pattern (§4.2)
  88. - Expo config problems (§2.1)
  89. INFO: debug logging left in production code (§2.1), and no encryption export-compliance declaration.
  90. Rules that describe a project-level fact, such as "no account deletion anywhere", report once for the whole project rather than once per file that triggers them.
  91. ### `greenlight playscan [path]`
  92. ```bash
  93. greenlight playscan /path/to/project
  94. greenlight playscan --apk app-release.apk # built artifact: merged manifest
  95. greenlight playscan --aab app-release.aab # app bundle
  96. greenlight playscan . --format json
  97. greenlight playscan . --exit-code
  98. ```
  99. Checks an Android app against Google Play's Developer Program Policies and its published distribution deadlines. Every finding links the policy page it comes from.
  100. Deadlines:
  101. - Target API level. New apps and updates must target API 36 from August 31, 2026. Apps below API 35 already lose distribution to new users on newer devices. CRITICAL / HIGH. Play runs a separate schedule for Wear OS, Android TV, Automotive, and XR, so an app declaring one of those form factors gets a WARN naming its track instead of a blocking finding on the phone schedule.
  102. - Play Billing Library. v7 and below lose support on August 31, 2026, and there is no direct v7 to v9 upgrade path. Versions reached through a variable or a version catalog `version.ref` are resolved. HIGH
  103. Restricted permissions, each of which needs an approved use case or a declaration form:
  104. - SMS and Call Log, including the July 2026 change that drops phone-call account verification as a permitted `READ_CALL_LOG` use
  105. - `MANAGE_EXTERNAL_STORAGE` (All files access)
  106. - `QUERY_ALL_PACKAGES`, `REQUEST_INSTALL_PACKAGES`
  107. - `ACCESS_BACKGROUND_LOCATION`, which needs a declaration and a demo video
  108. - Broad photo and video access over the system Photo Picker (API 33+)
  109. - Accessibility Service, VPN service, and device admin, which are declared as a component's `android:permission` rather than a `<uses-permission>`
  110. - Overlays, usage stats
  111. - Contacts, ahead of the 2026 Contact Permissions policy
  112. Manifest and build:
  113. - Foreground services missing the base `FOREGROUND_SERVICE` permission, or a declared type missing its `FOREGROUND_SERVICE_*` permission. Both throw at `startForeground()`. CRITICAL
  114. - `specialUse` foreground services, which need a Console justification
  115. - `android:exported` missing on components with an intent filter (API 31+), which makes the package fail to install. CRITICAL
  116. - `android:debuggable="true"`. CRITICAL
  117. - `android:usesCleartextTraffic="true"`
  118. - An ads SDK shipped without `com.google.android.gms.permission.AD_ID`, which silently returns a zeroed advertising ID
  119. - Account creation without the required in-app *and* web deletion paths
  120. `--apk` and `--aab` read the *merged* manifest, so they see permissions contributed by library manifests that a source scan structurally cannot. Every manifest and permission check above runs against a built artifact, plus the native code checks below.
  121. The three checks that read the Gradle model (Play Billing version, ads-SDK detection, auth-SDK detection) cannot run on an archive, because a built artifact does not carry one. The scan reports that gap as a finding rather than staying silent, so a clean artifact scan is never mistaken for a clean scan of everything. Source and artifact are complementary; `preflight` accepts both at once:
  122. ```bash
  123. greenlight preflight . --aab app-release.aab
  124. ```
  125. Native code checks:
  126. - 16 KB page size. Google Play requires apps targeting Android 15+ to support 16 KB memory pages. Greenlight checks ELF `LOAD` segment alignment on `arm64-v8a` libraries, 16 KB zip alignment of uncompressed libraries, and `GNU_RELRO` presence. CRITICAL / HIGH
  127. - 64-bit requirement. Every 32-bit ABI must ship with its 64-bit counterpart, so `armeabi-v7a` without `arm64-v8a`, or `x86` without `x86_64`, is flagged. CRITICAL
  128. In an AAB, native code is read from every module rather than `base/` alone, so a library that ships in a feature module is checked like any other.
  129. Both formats are decoded in pure Go, an APK's compiled binary XML and an AAB's protobuf manifest alike, so no Android SDK, `aapt2`, or `bundletool` is required.
  130. On scope: a source scan reads the `AndroidManifest.xml` and Gradle files in your repo, which is the pre-merge manifest. Permissions contributed by library manifests only appear once the build merges them, so a clean source scan is not proof of a clean merged manifest. Scan the built artifact to close that gap. `targetSdk` is resolved from the app module, convention plugins (`build-logic/`, `buildSrc/`, `build-plugin/`), version catalogs, `gradle.properties`, and named constants; when it cannot be resolved, the scan says so instead of reporting a pass.
  131. ### `greenlight privacy [path]`
  132. ```bash
  133. greenlight privacy /path/to/project
  134. ```
  135. Checks that PrivacyInfo.xcprivacy exists and is filled in, finds Required Reason APIs used in code and compares them against what the manifest declares, and cross-references detected tracking SDKs against your ATT implementation.
  136. ### `greenlight ipa <path.ipa>`
  137. ```bash
  138. greenlight ipa /path/to/build.ipa
  139. ```
  140. Plists are parsed for real, binary and XML both, rather than string-matched. Inspects:
  141. - PrivacyInfo.xcprivacy presence
  142. - Info.plist completeness and purpose string quality
  143. - App Transport Security configuration
  144. - App icon presence and sizes, including icons that live in Assets.car
  145. - Launch storyboard presence
  146. - App size against the 200 MB cellular download limit
  147. - Embedded framework privacy manifests
  148. ### `greenlight scan --app-id <ID>`
  149. ```bash
  150. greenlight auth setup # one-time: configure API key
  151. greenlight auth login # or: sign in with Apple ID
  152. greenlight scan --app-id 6758967212 # run all tiers
  153. ```
  154. API-based checks against your app in App Store Connect: metadata completeness, screenshots for required device sizes, build processing status, age rating and encryption compliance, and content analysis for platform references and placeholders.
  155. ### `greenlight verify [path]`
  156. Static checks confirm a flow *exists* in your source. `verify` confirms it *works*, by handing flow-dependent guidelines to the [Revyl](https://revyl.com?utm_source=greenlight&utm_medium=readme&utm_campaign=verify) CLI and running them on a cloud device.
  157. This is the gap static analysis cannot close. A "Delete Account" button wired to nothing passes codescan: the string `deleteAccount` is in the source, §5.1.1 is suppressed, and you get GREENLIT. At runtime it dead-ends, and Apple rejects under §5.1.1(v). `verify` taps the button.
  158. ```bash
  159. greenlight verify . --dry-run # show claimed flows + generated tests, no device
  160. greenlight verify . --build-name "My App" \
  161. --var email=qa@acme.com --var password=secret
  162. greenlight verify . --build-name "My App" --flows account-deletion --os-version "iOS 26.2"
  163. greenlight verify . --artifact build/MyApp.app --build-name "My App" # upload, then run
  164. greenlight verify . --platform android --artifact app-release.apk --build-name "My App"
  165. ```
  166. Only flows your app actually claims are run:
  167. | Flow | Guideline | What runtime proves that static can't |
  168. |------|-----------|----------------------------------------|
  169. | `account-deletion` | §5.1.1 | The account is gone, not that a `deleteAccount` string exists |
  170. | `restore-purchases` | §3.1.1 | "Restore Purchases" does something, rather than being a silent no-op |
  171. | `sign-in-apple` | §4.8 | The Apple sign-in sheet appears, and the control is not dead |
  172. A failed flow becomes a BLOCK that static analysis could never produce, with a shareable Revyl report link as evidence. `--open` follows the live session in your browser while it runs, and `--exit-code` gates CI on it.
  173. Getting set up takes about two minutes:
  174. ```bash
  175. brew install revylai/tap/revyl # the device runner
  176. revyl auth login # free account, no card
  177. greenlight verify . --dry-run # see the generated tests first
  178. ```
  179. Unlike every other command here, `verify` is not offline: it needs the [`revyl` CLI](https://docs.revyl.com), an account, and either a registered build or a local artifact passed to `--artifact`. Revyl runs cloud simulators and emulators, so iOS takes a simulator `.app` and Android takes an `.apk`. A device `.ipa` is rejected with an explanation. [Create an account](https://app.revyl.ai/signup?utm_source=greenlight&utm_medium=readme&utm_campaign=verify).
  180. ### `greenlight guidelines`
  181. ```bash
  182. greenlight guidelines list # all sections
  183. greenlight guidelines show 2.1 # a specific guideline
  184. greenlight guidelines search "privacy" # full-text search
  185. ```
  186. ## Output formats
  187. | Command | Formats |
  188. |---------|---------|
  189. | `preflight`, `codescan` | terminal, json, sarif |
  190. | `playscan`, `ipa`, `verify` | terminal, json |
  191. | `scan` | terminal, json, junit |
  192. `--output file` writes to a file instead of stdout. `--exit-code` is available on `preflight`, `playscan`, and `verify`.
  193. Upload SARIF to GitHub code scanning and findings show up in the Security tab and inline on pull requests:
  194. ```yaml
  195. - run: greenlight preflight . --format sarif --output greenlight.sarif
  196. - uses: github/codeql-action/upload-sarif@v3
  197. with:
  198. sarif_file: greenlight.sarif
  199. ```
  200. ## CI
  201. ```yaml
  202. # GitHub Actions
  203. - name: App Store + Play compliance
  204. run: greenlight preflight . --exit-code
  205. ```
  206. That fails the job on any CRITICAL or HIGH finding, and on a scanner that crashed mid-scan. To keep the report as an artifact too:
  207. ```yaml
  208. - run: greenlight preflight . --format json --output greenlight-report.json --exit-code
  209. ```
  210. To gate on the runtime tier in the same step, add `--verify`. The runner needs an authenticated `revyl` CLI on PATH:
  211. ```yaml
  212. - run: greenlight preflight . --verify --build-name "My App" --exit-code
  213. ```
  214. ## Where a static scan stops
  215. Greenlight reads text. That is the whole of it: source files, plists, manifests, and binaries, matched against rules. It is fast and it is free because it never runs your app.
  216. Which means there is a class of rejection it cannot see, structurally, no matter how many rules get added. A "Delete Account" button wired to nothing is the clean example. The string is in the source, so §5.1.1 is satisfied and greenlight prints GREENLIT. Apple taps the button, nothing happens, and you are rejected under §5.1.1(v), which costs you the fix plus another trip through review. Same for a Restore Purchases handler that catches its own error and returns, or a Sign in with Apple button behind a feature flag that is off in the release build.
  217. Every one of those ships green. Nothing in this repo can catch them, because catching them requires running the app.
  218. That is what `greenlight verify` does, and it is why [Revyl](https://revyl.com?utm_source=greenlight&utm_medium=readme&utm_campaign=static-ceiling) exists. Revyl runs mobile tests written in plain English on cloud devices, so the check is "the account is actually gone" instead of "the word `deleteAccount` appears in a file". Greenlight uses it for three flows. The same engine covers the rest of your app.
  219. ```bash
  220. greenlight verify . --dry-run # free, offline, shows you the tests it would run
  221. ```
  222. Start with `--dry-run`. It generates the tests and prints them without touching a device or needing an account, so you can see whether the runtime tier is worth it before you [sign up](https://app.revyl.ai/signup?utm_source=greenlight&utm_medium=readme&utm_campaign=static-ceiling).
  223. ## Configuration (`.greenlight.yml`)
  224. Drop a `.greenlight.yml` in your project root to tune the code scan:
  225. ```yaml
  226. rules:
  227. hardcoded-ipv4:
  228. severity: info # info | warn | critical
  229. platform-reference:
  230. enabled: false # turn a rule off
  231. ignore:
  232. - vendor # skip a directory, anywhere in the tree
  233. - "*.generated.ts" # skip by filename
  234. - src/legacy # skip a path
  235. ```
  236. It applies to `codescan` and to the codescan portion of `preflight`. Point at a specific file with `codescan --config path/to/.greenlight.yml`.
  237. To silence one line rather than a whole rule, use an inline directive on the offending line or the line directly above it:
  238. ```swift
  239. let host = "10.1.2.3" // greenlight:ignore hardcoded-ipv4
  240. ```
  241. A bare `// greenlight:ignore` suppresses every rule on that line. Naming the rule is better: it keeps the other checks live.
  242. ## Claude Code skill
  243. Greenlight ships as a Claude Code plugin, so Claude can run the scan, read the findings, fix them in your code, and re-run until GREENLIT.
  244. ```bash
  245. # In Claude Code
  246. /plugin marketplace add RevylAI/greenlight
  247. /plugin install greenlight
  248. ```
  249. Or copy the skill file into a project by hand:
  250. ```bash
  251. mkdir -p .claude/skills
  252. cp /path/to/greenlight/skills/greenlight/SKILL.md .claude/skills/greenlight.md
  253. ```
  254. Then: *"Run greenlight preflight and fix everything until it passes."* Claude works down the severity ladder, CRITICAL first, then HIGH, WARN, and INFO, re-running after each pass.
  255. ## Codex skill
  256. A Codex-native skill package lives at `codex-skill/`.
  257. ```bash
  258. mkdir -p ~/.codex/skills/app-store-preflight-compliance
  259. cp -R codex-skill/* ~/.codex/skills/app-store-preflight-compliance/
  260. ```
  261. Then, in Codex:
  262. ```text
  263. Use $app-store-preflight-compliance to run Greenlight preflight and fix all findings until GREENLIT.
  264. ```
  265. ## Architecture
  266. ```
  267. greenlight
  268. ├── preflight Run every applicable scanner, one command
  269. │ ├── metadata app.json / Info.plist
  270. │ ├── codescan 24 rejection-risk rules
  271. │ ├── privacy Privacy manifest + Required Reason APIs
  272. │ ├── playscan Google Play policy (Android projects)
  273. │ ├── ipa Binary inspection (with --ipa)
  274. │ └── --verify Chain the runtime tier onto the same run
  275. │
  276. ├── codescan Code only, tunable via .greenlight.yml
  277. ├── privacy Privacy manifest only
  278. ├── playscan Google Play only, source or --apk / --aab
  279. ├── ipa Binary only
  280. │
  281. ├── verify Runtime flow validation on a cloud device (Revyl)
  282. │ ├── account-deletion §5.1.1 the account is actually deleted
  283. │ ├── restore-purchases §3.1.1 Restore Purchases isn't a no-op
  284. │ └── sign-in-apple §4.8 the Apple sign-in sheet appears
  285. │
  286. ├── scan App Store Connect API checks (tiers 1-4)
  287. │ ├── Tier 1 Metadata and completeness
  288. │ ├── Tier 2 Content analysis
  289. │ ├── Tier 3 Binary inspection
  290. │ └── Tier 4 Historical pattern matching
  291. │
  292. ├── auth App Store Connect authentication
  293. │ ├── login Apple ID + 2FA session
  294. │ ├── setup API key configuration
  295. │ ├── status Current auth state
  296. │ └── logout Remove credentials
  297. │
  298. └── guidelines Built-in Apple Review Guidelines database
  299. ├── list All 5 sections with subsections
  300. ├── show A specific guideline
  301. └── search Full-text search
  302. ```
  303. ## Built by Revyl
  304. Greenlight catches App Store rejections. [Revyl](https://revyl.com?utm_source=greenlight&utm_medium=readme&utm_campaign=footer) catches the bugs that get through.
  305. It is the mobile reliability platform behind `greenlight verify`: write tests in plain English, run them on cloud devices, catch the broken flows a static scan cannot see. Greenlight itself is MIT licensed and stays that way. Revyl is where you go when you want the rest of your app covered the way those three flows are.
  306. [Start free](https://app.revyl.ai/signup?utm_source=greenlight&utm_medium=readme&utm_campaign=footer) · [Docs](https://docs.revyl.com) · [revyl.com](https://revyl.com?utm_source=greenlight&utm_medium=readme&utm_campaign=footer)
  307. As a little easter egg for reading this far, here is one month of Revyl free: [`ng32jDS9`](https://app.revyl.ai/signup?promo=ng32jDS9&utm_source=greenlight&utm_medium=readme&utm_campaign=easter-egg) :)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.