Skip to content

Allow Pro license tokens from Rails and Node configuration - #4552

Merged
justin808 merged 7 commits into
mainfrom
ihabadham/feature/configurable-pro-license-token
Jul 10, 2026
Merged

Allow Pro license tokens from Rails and Node configuration#4552
justin808 merged 7 commits into
mainfrom
ihabadham/feature/configurable-pro-license-token

Conversation

@ihabadham

@ihabadham ihabadham commented Jul 9, 2026

Copy link
Copy Markdown
Collaborator

Why

React on Rails Pro license validation only consumed REACT_ON_RAILS_PRO_LICENSE, even though Rails applications commonly keep secrets in encrypted credentials and the renderer password already supports application configuration. That forced Rails deployments to expose the license through the process environment and left the separate Node renderer's configuration boundary unclear.

What changed

  • add ReactOnRailsPro.configuration.license_token, with explicit nonblank Rails configuration taking precedence over REACT_ON_RAILS_PRO_LICENSE
  • add the Node renderer's licenseToken option with the same precedence and blank-value fallback
  • validate the configured token during both clustered-master and single-process renderer startup
  • mask license values in every sanitized Node renderer configuration view
  • preserve REACT_ON_RAILS_PRO_LICENSE as the backward-compatible default and generator path
  • document Rails credentials, standalone Node secret configuration, process separation, CI behavior, security guidance, troubleshooting, and migration from the removed key file across the canonical and package docs

Rails configuration intentionally does not propagate to a separately running Node service. Each process must receive the same token through its own configuration or environment.

Validation

  • pnpm run lint
  • pnpm start format.listDifferent
  • pnpm run type-check
  • pnpm run build
  • (cd react_on_rails_pro && BUNDLE_GEMFILE=../Gemfile bundle exec rubocop --ignore-parent-exclusion)
  • (cd react_on_rails && bundle exec rake rbs:validate)
  • node script/generate-llms-full.mjs --check
  • script/check-docs-sidebar
  • script/check-pro-license-headers
  • git diff --check
  • pre-commit hooks, including offline Markdown links
  • pre-push hooks, including online Markdown links

Local test suites were intentionally left to CI under the repository's React on Rails PR policy. An automated local review pass was stopped when it attempted to start those prohibited suites; no local test result is claimed.

Review churn

  • Pre-push review gate: manual end-to-end flow and secret-redaction review; automated Codex review stopped for attempting prohibited local tests
  • Post-push review churn: one planned changelog-only commit completed after obtaining the PR number
  • Remaining gaps: optimized hosted CI has been requested for the Ruby and Node test suites

Demo coordination

No flagship demo change is needed: the existing environment-variable setup remains supported and generated defaults are unchanged. This adds optional secret-source configuration without changing the recommended generated deployment path.

Summary by CodeRabbit

  • New Features
    • Added config.license_token support for Rails apps (including credentials/config) with precedence over REACT_ON_RAILS_PRO_LICENSE.
    • Added standalone Node renderer licenseToken option with env fallback and masked diagnostics.
  • Bug Fixes
    • Updated license validation and startup logging to respect precedence/blank values and avoid token disclosure in sanitized output.
    • Improved license-status caching to be scoped per effective token.
  • Documentation
    • Refreshed Pro license setup, installation, upgrading, troubleshooting, and CI/license-task guidance, including review-app token exposure security.
  • Tests
    • Expanded test coverage for token resolution, masking, and startup validation flows.

Codex Decision Log

  • Non-blocking: Should this PR target release/17.0.0 rather than main?
    • Decision: Keep the main target.
    • Why: The 17.0.0 tracker is in development mode, the RC branch is for stabilizing fixes only, and this is an optional configuration capability with no demonstrated RC regression or release hard-gate need.
    • Review later: Backport only if a maintainer identifies a concrete 17.0.0 stabilizing need.

Review Coverage Note

  • Current head SHA: 1325f12e7d921699f09b8c52270b4a964f814273.
  • Current-head review systems: claude-review and CodeRabbit completed successfully.
  • Degraded advisory coverage: visible Greptile and GitHub Codex review artifacts predate the final code head, so they are treated as stale advisory history rather than merge evidence.
  • Local fallback review attempts: codex review could not start because the installed CLI is too old for its configured model; the Claude CLI report-only fallback is not authenticated. Independent implementation review and required runtime QA were completed instead.

@ihabadham

Copy link
Copy Markdown
Collaborator Author

+ci-status

@github-actions

github-actions Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

CI Status

Head SHA: db26ec0557ee
Changed files: 34
Docs-only heuristic (matches ci-changes-detector metadata paths): no
ready-for-hosted-ci label: absent
force-full-hosted-ci label: absent
Current hosted-CI waiver: not present for this SHA

Only the required gate is active unless hosted CI is requested.

@ihabadham

Copy link
Copy Markdown
Collaborator Author

+ci-run-hosted

@github-actions github-actions Bot added the ready-for-hosted-ci Run optimized hosted GitHub CI for this PR label Jul 9, 2026
@github-actions

github-actions Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

Hosted CI Requested

Triggered 9 workflow(s) for db26ec0557ee.
Mode: optimized hosted CI (path-selected by script/ci-changes-detector).
Added ready-for-hosted-ci, so future commits will keep running optimized hosted CI until +ci-stop-hosted is used.

View progress in the Actions tab.

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: e4ee31c7c8

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

Comment thread packages/react-on-rails-pro-node-renderer/src/shared/licenseValidator.ts Outdated
@greptile-apps

greptile-apps Bot commented Jul 9, 2026

Copy link
Copy Markdown

Greptile Summary

This PR adds configurable Pro license-token sources for Rails and the Node renderer. The main changes are:

  • Rails config.license_token with fallback to REACT_ON_RAILS_PRO_LICENSE.
  • Node renderer licenseToken support with the same fallback behavior.
  • Startup license logging for clustered and single-process renderer modes.
  • Masking for license values in sanitized renderer configuration logs.
  • Documentation and tests for the new token sources.

Confidence Score: 4/5

The Node license metadata path needs a cache fix before merging.

  • The Rails and Node fallback behavior matches the documented token precedence.
  • License values are masked in the changed sanitized config output.
  • The Node validator now accepts per-call tokens, but its caches still reuse the first result across later token values.

packages/react-on-rails-pro-node-renderer/src/shared/licenseValidator.ts

Important Files Changed

Filename Overview
packages/react-on-rails-pro-node-renderer/src/shared/licenseValidator.ts Adds token-aware validator entry points, but the status and metadata caches are still shared across all token values.
packages/react-on-rails-pro-node-renderer/src/shared/configBuilder.ts Adds licenseToken resolution and masking for renderer configuration output.
packages/react-on-rails-pro-node-renderer/src/shared/logLicenseStatus.ts Extracts license status logging behind a helper that accepts the resolved token.
packages/react-on-rails-pro-node-renderer/src/master.ts Passes the resolved renderer license token into startup license logging for clustered mode.
packages/react-on-rails-pro-node-renderer/src/ReactOnRailsProNodeRenderer.ts Passes the resolved renderer license token into startup license logging for single-process mode.
react_on_rails_pro/lib/react_on_rails_pro/license_validator.rb Prefers Rails config.license_token before falling back to the environment token.
react_on_rails_pro/lib/react_on_rails_pro/configuration.rb Adds license_token to the Rails Pro configuration object.

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
  RailsConfig[config.license_token] --> RailsValidator[Rails license validator]
  RailsEnv[REACT_ON_RAILS_PRO_LICENSE] --> RailsValidator
  NodeConfig[licenseToken option] --> BuildConfig[buildConfig]
  NodeEnv[REACT_ON_RAILS_PRO_LICENSE] --> BuildConfig
  BuildConfig --> Startup[Node renderer startup]
  Startup --> LogLicense[logLicenseStatus]
  LogLicense --> NodeValidator[getLicenseStatus]
  NodeValidator --> Cache[process-wide license caches]
Loading
%%{init: {'theme': 'base', 'themeVariables': {"darkMode": true, "background": "#0d1117", "primaryColor": "#21262d", "primaryTextColor": "#e6edf3", "primaryBorderColor": "#8b949e", "lineColor": "#8b949e", "textColor": "#e6edf3", "edgeLabelBackground": "#161b22", "actorBkg": "#21262d", "actorBorder": "#8b949e", "actorTextColor": "#e6edf3", "actorLineColor": "#8b949e", "signalColor": "#8b949e", "signalTextColor": "#e6edf3", "noteBkgColor": "#373320", "noteBorderColor": "#d4a72c", "noteTextColor": "#f0e6c0", "labelBoxBkgColor": "#21262d", "labelBoxBorderColor": "#8b949e", "labelTextColor": "#e6edf3", "loopTextColor": "#e6edf3", "activationBkgColor": "#30363d", "activationBorderColor": "#8b949e"}}}%%
flowchart TD
  RailsConfig[config.license_token] --> RailsValidator[Rails license validator]
  RailsEnv[REACT_ON_RAILS_PRO_LICENSE] --> RailsValidator
  NodeConfig[licenseToken option] --> BuildConfig[buildConfig]
  NodeEnv[REACT_ON_RAILS_PRO_LICENSE] --> BuildConfig
  BuildConfig --> Startup[Node renderer startup]
  Startup --> LogLicense[logLicenseStatus]
  LogLicense --> NodeValidator[getLicenseStatus]
  NodeValidator --> Cache[process-wide license caches]
Loading

Reviews (1): Last reviewed commit: "Record configurable Pro license secret s..." | Re-trigger Greptile

Comment thread packages/react-on-rails-pro-node-renderer/src/shared/licenseValidator.ts Outdated
Comment thread packages/react-on-rails-pro-node-renderer/src/shared/licenseValidator.ts Outdated
Comment thread packages/react-on-rails-pro-node-renderer/src/shared/licenseValidator.ts Outdated
@github-actions

github-actions Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

size-limit report 📦

Path Size
react-on-rails/client bundled (gzip) 63.51 KB (0%)
react-on-rails/client bundled (gzip) (time) 63.51 KB (0%)
react-on-rails/client bundled (brotli) 54.46 KB (0%)
react-on-rails/client bundled (brotli) (time) 54.46 KB (0%)
react-on-rails-pro/client bundled (gzip) 64.87 KB (0%)
react-on-rails-pro/client bundled (gzip) (time) 64.87 KB (0%)
react-on-rails-pro/client bundled (brotli) 55.81 KB (0%)
react-on-rails-pro/client bundled (brotli) (time) 55.81 KB (0%)
registerServerComponent/client bundled (gzip) 135.18 KB (0%)
registerServerComponent/client bundled (gzip) (time) 135.18 KB (0%)
registerServerComponent/client bundled (brotli) 81.49 KB (0%)
registerServerComponent/client bundled (brotli) (time) 81.49 KB (0%)
wrapServerComponentRenderer/client bundled (gzip) 127.65 KB (0%)
wrapServerComponentRenderer/client bundled (gzip) (time) 127.65 KB (0%)
wrapServerComponentRenderer/client bundled (brotli) 74.78 KB (0%)
wrapServerComponentRenderer/client bundled (brotli) (time) 74.78 KB (0%)

@coderabbitai

coderabbitai Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

Review Change Stack

Walkthrough

Adds license_token/licenseToken configuration paths for React on Rails Pro, updates license validation and startup logging to use them, and revises related documentation, tests, and diagnostics.

Changes

License token configuration

Layer / File(s) Summary
Rails configuration support
react_on_rails_pro/lib/react_on_rails_pro/configuration.rb, react_on_rails_pro/sig/react_on_rails_pro/configuration.rbs, react_on_rails_pro/spec/react_on_rails_pro/configuration_spec.rb
Adds license_token defaults, accessors, initializer support, type signatures, and spec coverage.
Rails license lookup
react_on_rails_pro/lib/react_on_rails_pro/license_validator.rb, react_on_rails_pro/lib/react_on_rails_pro/license_task_formatter.rb, react_on_rails_pro/spec/react_on_rails_pro/*, react_on_rails_pro/CLAUDE.md
license_token is preferred over ENV for Rails license lookup, and the related messaging/specs are updated.
Node config and license validation
packages/react-on-rails-pro-node-renderer/src/shared/configBuilder.ts, packages/react-on-rails-pro-node-renderer/src/shared/licenseValidator.ts, packages/react-on-rails-pro-node-renderer/tests/*configBuilder*, packages/react-on-rails-pro-node-renderer/tests/licenseValidator*, packages/react-on-rails-pro-node-renderer/README.md
Adds licenseToken, updates masking and cache behavior, and extends tests for precedence and token-scoped validation.
Node startup license logging
packages/react-on-rails-pro-node-renderer/src/shared/logLicenseStatus.ts, packages/react-on-rails-pro-node-renderer/src/master.ts, packages/react-on-rails-pro-node-renderer/src/ReactOnRailsProNodeRenderer.ts, packages/react-on-rails-pro-node-renderer/tests/logLicenseStatus.test.ts, packages/react-on-rails-pro-node-renderer/tests/masterStartupFailure.test.ts, packages/react-on-rails-pro-node-renderer/tests/nodeRendererStartupChecks.test.ts
Replaces inline startup checks with logLicenseStatus and wires it into master and single-process renderer startup.
Documentation updates
CHANGELOG.md, README.md files, LICENSE_SETUP.md, docs/oss/*, docs/pro/*, llms-full*.txt
Documents the new token sources, precedence rules, masking behavior, CI usage, and review-app guidance.

Estimated code review effort: 3 (Moderate) | ~30 minutes

Possibly related issues

Suggested labels: hosted-ci-no-benchmarks

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name Status Explanation Resolution
Docstring Coverage ⚠️ Warning Docstring coverage is 46.15% which is insufficient. The required threshold is 80.00%. Write docstrings for the functions missing them to satisfy the coverage threshold.
✅ Passed checks (4 passed)
Check name Status Explanation
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.
Description Check ✅ Passed Check skipped - CodeRabbit’s high-level summary is enabled.
Title check ✅ Passed The title clearly summarizes the main change: configurable Pro license tokens for both Rails and Node setups.
✨ Finishing Touches
📝 Generate docstrings
  • Create stacked PR
  • Commit on current branch
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Commit unit tests in branch ihabadham/feature/configurable-pro-license-token

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

Comment @coderabbitai help to get the list of available commands.

@claude

claude Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

Review: Configurable Pro license tokens (Rails config.license_token / Node licenseToken)

Overall this is a well-scoped, well-tested change. The precedence rule (explicit nonblank config > REACT_ON_RAILS_PRO_LICENSE, blank falls back to env) is implemented consistently on both the Ruby (license_validator.rb#load_license_string) and Node (licenseValidator.ts#loadLicenseString, configBuilder.ts#buildConfig) sides, and the token masking in configBuilder.ts's sanitized log views mirrors the existing password handling correctly (verified with the new configBuilder.test.ts cases).

What I checked closely

  • configBuilder.ts buildConfig/envValuesUsed/sanitizedSettings: the licenseToken fallback assignment (config.licenseToken = userConfig.licenseToken?.trim() || runtimeDefaultConfig.licenseToken) runs unconditionally after the object spread, so it doesn't need the explicitUndefinedPassword-style workaround that password requires — that's correct and actually simpler.
  • master.ts: license validation now runs after buildConfig() but still before cluster.fork() calls, confirmed by the new masterStartupFailure.test.ts assertion (operations.indexOf('license') < operations.indexOf('fork')), so the documented "checked once in master before workers fork" behavior is real, not just asserted in docs.
  • No token leakage: grepped for any place a full/raw Config or Configuration object is logged, serialized (to_h/inspect), or exposed via an endpoint — didn't find one outside the already-sanitized logSanitizedConfig paths. license_task_formatter.rb never prints the raw token either.
  • Single source of truth: confirmed no other code path reads process.env.REACT_ON_RAILS_PRO_LICENSE / ENV["REACT_ON_RAILS_PRO_LICENSE"] directly outside the two validator files, so the new config precedence can't be silently bypassed elsewhere.

Minor findings

  1. No CHANGELOG.md entry. This is a user-visible feature (new config.license_token / licenseToken config options), and the repo's own changelog-guidelines.md says user-visible features should get an entry in the [Unreleased] section. The PR description mentions "one planned changelog-only commit after obtaining the PR number" — just flagging so it doesn't get dropped before merge.

  2. getLicenseStatus/getLicenseOrganization/getLicensePlan cache ignores the token argument on subsequent calls (licenseValidator.ts:216-223 etc.) — once cachedLicenseStatus is set, later calls with a different licenseToken argument still return the first cached result. Currently harmless because each process only calls these once at startup (master or single-process mode), but the new parameterized signature invites a future caller to pass a different token per call and silently get a stale answer. Not blocking, but worth a one-line doc-comment caveat on getLicenseStatus since the function is exported and no longer purely env-driven.

  3. Small wording nit in license_task_formatter.rb:57: "Configure config.license_token or set REACT_ON_RAILS_PRO_LICENSE" reads a little awkwardly (mixing "configure X" and "set Y" verbs for parallel options). Not a real issue, just a polish suggestion.

No correctness, security, or performance blockers found. Test coverage for the new precedence/fallback/masking behavior looks thorough on both the Ruby and TS sides.

@claude

claude Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

Review: Allow Pro license tokens from Rails and Node configuration

Overview

This PR adds ReactOnRailsPro.configuration.license_token (Rails) and a matching licenseToken config option (Node renderer) as alternatives to the REACT_ON_RAILS_PRO_LICENSE env var, with explicit nonblank config taking precedence and blank config falling back to the env var. It also masks the token in all sanitized Node renderer config log views, validates the resolved token at both clustered-master and single-process renderer startup, and updates a large amount of documentation (canonical docs, package README, LICENSE_SETUP.md, generated llms-full*.txt) plus the changelog.

Code quality

  • The precedence/fallback logic (configured.presence || ENV[...]) is implemented consistently in both Ruby (license_validator.rb#load_license_string) and TypeScript (licenseValidator.ts#loadLicenseString, configBuilder.ts#buildConfig), including the "blank configured value falls through to ENV" edge case in both directions.
  • Good attention to secret hygiene: sanitizedSettings() masks licenseToken the same way it already masks password (distinguishing <EMPTY STRING> from <MASKED>), and envValuesUsed() never echoes the actual token, matching the existing password pattern.
  • master.ts now calls logLicenseStatus(config.licenseToken) after buildConfig() instead of checking getLicenseStatus() directly from raw process.env before config resolution — this is a real correctness fix, not just a refactor, since it's what makes Rails/Node config-sourced tokens actually get validated.
  • Extracting logLicenseStatus.ts out of master.ts so it can be shared between the clustered-master and single-process startup paths is a clean, minimal refactor.
  • Comment/doc accuracy: the updated "Thread Safety Notes" block in licenseValidator.ts was corrected to reflect that validation now runs once in the master (not once per worker) — good catch, this wasn't just left stale.

Potential issues (non-blocking / minor)

  • getLicenseOrganization() / getLicensePlan() in licenseValidator.ts were updated to accept an optional licenseToken param for consistency with getLicenseStatus(), but neither is currently called anywhere in src/ outside tests. If a future caller invokes either without threading the resolved config token through (the way logLicenseStatus does for getLicenseStatus), it would silently fall back to process.env.REACT_ON_RAILS_PRO_LICENSE only, ignoring a configured licenseToken — an easy trap for a future PR. Not a bug today, just worth a short comment/reminder near the exports if these are meant to be used later (e.g. from a health/info endpoint).
  • Module-level caching (cachedLicenseStatus, etc.) means getLicenseStatus(token) ignores its argument entirely after the first call in a given process. That's fine for the current single-call-at-startup usage, but the cache is invisible from the call site — a second call with a different token elsewhere would return the first result. Worth keeping in mind if these functions ever get called from more than one place per process.

Security

  • No secret-leak issues found: grepped for other places the Node renderer config object might be logged and didn't find any unmasked paths besides logSanitizedConfig(), which is already covered by the new masking.
  • The Rails Configuration object doesn't override #inspect, so license_token (like the pre-existing renderer_password) would appear in a raw .inspect dump if some other code path serialized the whole config object — this is a pre-existing pattern shared with renderer_password, not something introduced by this PR, so not a blocker, but noting it for completeness.
  • Docs correctly call out that Rails config does not propagate to a separately-running Node process, and docs/pro/deployment/review-app-security.md was updated to cover all three token sources (env, Rails credentials, Node licenseToken) rather than just the env var — good, this closes a gap the new feature would otherwise have opened.

Test coverage

  • Strong coverage on both sides: Ruby specs cover default/explicit/blank-fallback/env-precedence cases for license_token in configuration_spec.rb, license_validator_spec.rb, and engine_spec.rb; TS tests cover the same matrix in configBuilder.test.ts and licenseValidator.test.ts, plus new dedicated tests for logLicenseStatus.ts and updated masterStartupFailure.test.ts / nodeRendererStartupChecks.test.ts to assert the resolved token is passed to license validation before workers fork.
  • The "masks license tokens from every sanitized configuration view" test in configBuilder.test.ts directly asserts the serialized log payload never contains the raw token string — a good regression guard for the exact class of bug this PR is trying to avoid.

Performance

No performance concerns — this is startup-time config resolution and logging only; no hot-path changes.

Summary

Solid, well-tested, low-risk feature addition with thorough documentation updates. No blocking issues found; the two notes above are forward-looking observations rather than defects in this PR.

@coderabbitai coderabbitai Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🧹 Nitpick comments (2)
packages/react-on-rails-pro-node-renderer/tests/configBuilder.test.ts (1)

105-134: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add a positive-path test for envValuesUsed().REACT_ON_RAILS_PRO_LICENSE.

Coverage tests the negative case (ENV usage suppressed when overridden, 128-134) but not the positive case: that when the ENV token is actually the effective value, envValuesUsed().REACT_ON_RAILS_PRO_LICENSE reports '<MASKED>'. Since this diagnostic is the security-relevant signal that a secret was sourced from ENV, a regression here (e.g. an inverted condition) wouldn't be caught by existing tests.

✅ Suggested additional test
+  it('reports the license ENV as used (masked) when no configured token overrides it', () => {
+    process.env.REACT_ON_RAILS_PRO_LICENSE = 'env-license-token';
+
+    const envValues = envValuesUsedForRenderedConfig({});
+
+    expect(envValues.REACT_ON_RAILS_PRO_LICENSE).toBe('<MASKED>');
+  });
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/react-on-rails-pro-node-renderer/tests/configBuilder.test.ts` around
lines 105 - 134, Add a positive-path test in configBuilder.test.ts for
envValuesUsed() covering the effective ENV license case: when
REACT_ON_RAILS_PRO_LICENSE supplies the actual token and no configured
licenseToken overrides it, assert envValuesUsed().REACT_ON_RAILS_PRO_LICENSE is
'<MASKED>'. Use the existing helpers buildConfig and
envValuesUsedForRenderedConfig to locate the behavior, and keep the current
negative override test as-is.
packages/react-on-rails-pro-node-renderer/tests/licenseValidator.test.ts (1)

27-29: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Consider adding parallel token-precedence tests for getLicenseOrganization and getLicensePlan.

The new tests cover getLicenseStatus with an explicit token, precedence, and fallback, but getLicenseOrganization and getLicensePlan received signature updates without corresponding test coverage for the explicit-token path. While the underlying loadLicenseString logic is shared, parallel tests would guard against future divergence.

The validPayload object is also duplicated across the three new test cases (lines 92–97, 106–111, 121–126). Extracting it to a shared constant or beforeEach/factory would reduce repetition.

Also applies to: 91-135

🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/react-on-rails-pro-node-renderer/tests/licenseValidator.test.ts`
around lines 27 - 29, Add parallel token-precedence coverage in
licenseValidator.test.ts for getLicenseOrganization and getLicensePlan,
mirroring the existing getLicenseStatus explicit-token, precedence, and fallback
cases so the shared loadLicenseString behavior stays protected. Update the test
suite around the getLicenseStatus/getLicenseOrganization/getLicensePlan
signatures to assert the explicit token path for each helper, and refactor the
repeated validPayload setup into a shared constant, factory, or beforeEach to
remove duplication across those test cases.
🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@packages/react-on-rails-pro-node-renderer/tests/configBuilder.test.ts`:
- Around line 105-134: Add a positive-path test in configBuilder.test.ts for
envValuesUsed() covering the effective ENV license case: when
REACT_ON_RAILS_PRO_LICENSE supplies the actual token and no configured
licenseToken overrides it, assert envValuesUsed().REACT_ON_RAILS_PRO_LICENSE is
'<MASKED>'. Use the existing helpers buildConfig and
envValuesUsedForRenderedConfig to locate the behavior, and keep the current
negative override test as-is.

In `@packages/react-on-rails-pro-node-renderer/tests/licenseValidator.test.ts`:
- Around line 27-29: Add parallel token-precedence coverage in
licenseValidator.test.ts for getLicenseOrganization and getLicensePlan,
mirroring the existing getLicenseStatus explicit-token, precedence, and fallback
cases so the shared loadLicenseString behavior stays protected. Update the test
suite around the getLicenseStatus/getLicenseOrganization/getLicensePlan
signatures to assert the explicit token path for each helper, and refactor the
repeated validPayload setup into a shared constant, factory, or beforeEach to
remove duplication across those test cases.

ℹ️ Review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: c7ff6801-0cba-4d2b-9df6-bf8dd2c74d76

📥 Commits

Reviewing files that changed from the base of the PR and between 92b29df and db26ec0.

📒 Files selected for processing (34)
  • CHANGELOG.md
  • docs/oss/api-reference/generator-details.md
  • docs/oss/building-features/node-renderer/js-configuration.md
  • docs/oss/configuration/configuration-pro.md
  • docs/pro/deployment/review-app-security.md
  • docs/pro/installation.md
  • docs/pro/license-ci-integration.md
  • docs/pro/troubleshooting.md
  • docs/pro/updating.md
  • docs/pro/upgrading-to-pro.md
  • llms-full-pro.txt
  • llms-full.txt
  • packages/react-on-rails-pro-node-renderer/README.md
  • packages/react-on-rails-pro-node-renderer/src/ReactOnRailsProNodeRenderer.ts
  • packages/react-on-rails-pro-node-renderer/src/master.ts
  • packages/react-on-rails-pro-node-renderer/src/shared/configBuilder.ts
  • packages/react-on-rails-pro-node-renderer/src/shared/licenseValidator.ts
  • packages/react-on-rails-pro-node-renderer/src/shared/logLicenseStatus.ts
  • packages/react-on-rails-pro-node-renderer/tests/configBuilder.test.ts
  • packages/react-on-rails-pro-node-renderer/tests/licenseValidator.test.ts
  • packages/react-on-rails-pro-node-renderer/tests/logLicenseStatus.test.ts
  • packages/react-on-rails-pro-node-renderer/tests/masterStartupFailure.test.ts
  • packages/react-on-rails-pro-node-renderer/tests/nodeRendererStartupChecks.test.ts
  • react_on_rails_pro/CLAUDE.md
  • react_on_rails_pro/LICENSE_SETUP.md
  • react_on_rails_pro/README.md
  • react_on_rails_pro/lib/react_on_rails_pro/configuration.rb
  • react_on_rails_pro/lib/react_on_rails_pro/license_task_formatter.rb
  • react_on_rails_pro/lib/react_on_rails_pro/license_validator.rb
  • react_on_rails_pro/sig/react_on_rails_pro/configuration.rbs
  • react_on_rails_pro/spec/react_on_rails_pro/configuration_spec.rb
  • react_on_rails_pro/spec/react_on_rails_pro/engine_spec.rb
  • react_on_rails_pro/spec/react_on_rails_pro/license_task_formatter_spec.rb
  • react_on_rails_pro/spec/react_on_rails_pro/license_validator_spec.rb

@ihabadham

Copy link
Copy Markdown
Collaborator Author

Addressed the CodeRabbit coverage suggestions in a264e0f: added the positive effective-ENV diagnostic assertion (REACT_ON_RAILS_PRO_LICENSE is reported as <MASKED>) and token-switching coverage for status, organization, and plan metadata.

@ihabadham

Copy link
Copy Markdown
Collaborator Author

Address-review summary

Scan scope: full PR history; no prior summary.

Mattered

  • Reproduced stale status, organization, and plan values when an ENV/default lookup preceded an explicit Node licenseToken lookup.
  • Fixed all three caches in a264e0fb2 with bounded token-aware entries while preserving the ENV/default process-lifetime cache behavior.
  • Added token-switching regression coverage, replied to all four cache threads, and resolved them.
  • The initial required-gate failure was caused by hosted CI not yet being requested; the current head has the hosted-CI label and no failing checks. The old Markdown failure was a transient HTTP 522 from an unrelated existing link; the current rerun is pending and branch online link checks pass.

Optional

  • Added the positive diagnostic assertion that an effective REACT_ON_RAILS_PRO_LICENSE source is reported as <MASKED>.

Skipped

  • Duplicate cache reports were handled through the same fix.
  • Repeated-payload cleanup and the generic third-party docstring warning were declined as unrelated churn.
  • CI status, size report, walkthrough, and acknowledgment comments were non-actionable.

Follow-up issue: None.

Next default scan starts after this comment. Say check all reviews to rescan the full PR.

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: a264e0fb2d

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

Comment thread react_on_rails_pro/lib/react_on_rails_pro/license_validator.rb
@claude

claude Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

Review Summary

This is a well-scoped, thoroughly-tested feature that adds Rails (config.license_token) and Node renderer (licenseToken) configuration sources for the Pro license token, with REACT_ON_RAILS_PRO_LICENSE preserved as the backward-compatible fallback. I read through the Ruby and TypeScript implementation changes plus the doc updates. Overall this looks correct and safe to merge — no bugs found, only a couple of minor/optional notes below.

Correctness

  • Precedence logic is consistent on both sides: Rails (license_validator.rb#load_license_string) and Node (configBuilder.ts#buildConfig, licenseValidator.ts#loadLicenseString) both implement "explicit nonblank config wins, blank/whitespace falls back to ENV" identically, and the tests exercise both directions (configured-over-env, blank-falls-back-to-env) on both stacks.
  • Cache-key redesign in licenseValidator.ts (single slot keyed by token ?? ENV_SYMBOL) correctly prevents a getLicenseStatus() call made without a token (ENV path) from returning stale cached data once a later call passes an explicit token ("does not reuse an ENV/default status for a later configured token" test). Since getLicenseStatus/getLicenseOrganization/getLicensePlan are only invoked once per process (from logLicenseStatus.ts, itself called once from master.ts and once from the single-process branch of ReactOnRailsProNodeRenderer.ts), the single-slot cache is sufficient — no thrashing concern in practice.
  • Startup ordering in master.ts is preserved correctly: buildConfig() then logLicenseStatus(config.licenseToken) then logSanitizedConfig() then fork workers, verified by the new "passes the resolved config token to license validation before forking workers" test.
  • Gap fix: single-process mode (workersCount: 0) previously never validated/logged license status (only the clustered master path did). This PR closes that gap via ReactOnRailsProNodeRenderer.ts calling logLicenseStatus(resolvedConfig.licenseToken). Good catch.
  • Rails engine ordering is correct too — config.license_token is set inside ReactOnRailsPro.configure (an app initializer), and the license check runs in config.after_initialize, so it always sees the configured value.

Security

  • Token masking in the Node renderer's sanitized config log (sanitizedSettings) is applied consistently for licenseToken (mirroring the existing password masking), and there's a dedicated test ("masks license tokens from every sanitized configuration view") that asserts the raw token strings never appear in the serialized log payload.
  • JWT verification still pins algorithms: ['RS256'] (both Ruby and JS), so this doesn't reopen the alg: none downgrade path.
  • Docs correctly call out that Rails config does NOT propagate to a separately-running Node renderer process, and that both processes need their own token source — this is an easy footgun to document, and it's covered well (installation.md, LICENSE_SETUP.md, review-app-security.md).

Minor / optional nits (non-blocking)

  • react_on_rails_pro/lib/react_on_rails_pro/license_task_formatter.rb:57 — "No license found. Configure config.license_token or set REACT_ON_RAILS_PRO_LICENSE" reads a little awkwardly (mixed verbs "Configure X or set Y"). Not worth blocking on, just a possible copy tweak, e.g. "Set config.license_token or REACT_ON_RAILS_PRO_LICENSE."
  • On the Ruby side, ReactOnRailsPro::Configuration#license_token (like the pre-existing renderer_password) has no masking if a caller ever dumps ReactOnRailsPro.configuration directly (e.g. via inspect/pp in a console or custom diagnostics). This is pre-existing behavior for renderer_password too, not a regression introduced here, but since this PR explicitly adds masking on the Node renderer side, it might be worth a follow-up to apply the same care if a Rails-side "sanitized config" dump is ever added.
  • Doc-heavy PR (34 files, ~735/-131) with several near-duplicate edits across docs/pro/installation.md, docs/pro/updating.md, docs/pro/upgrading-to-pro.md, react_on_rails_pro/LICENSE_SETUP.md, and the generated llms-full*.txt mirrors — this is expected/required by the repo's generate-llms-full.mjs --check convention, just flagging for reviewers who might otherwise be surprised by the volume of doc churn for a config-precedence feature.

Test coverage
Coverage is strong on both stacks: configBuilder.test.ts, licenseValidator.test.ts, new logLicenseStatus.test.ts, masterStartupFailure.test.ts, nodeRendererStartupChecks.test.ts on the JS side; configuration_spec.rb, engine_spec.rb, license_task_formatter_spec.rb, license_validator_spec.rb on the Ruby side. Precedence, blank-fallback, masking, and single-process startup validation are all directly exercised.

No blocking issues found — approving from a code-review standpoint.

@ihabadham

Copy link
Copy Markdown
Collaborator Author

Address-review summary

Scan scope: activity after latest summary at 2026-07-09T20:58:47Z (default cutoff).

Mattered

  • Reproduced the Ruby cache bug: an early no-token lookup remained :missing after assigning config.license_token, while an explicit reset produced the expected recomputed result.
  • Fixed all five Ruby metadata caches in 562938618 by invalidating them when config.license_token changes, with regression coverage for status, organization, plan, attribution, and expiration.
  • Confirmed Node parity: the Node validator already keys its status, organization, and plan caches by explicit token and already covers switching from ENV/default to configured tokens.
  • Replied to and resolved the Ruby cache review thread. No unresolved review threads remain.

Optional

  • Simplified the missing-license guidance to “Set config.license_token or REACT_ON_RAILS_PRO_LICENSE” in 2ada63840 and updated its expectation.

Skipped

  • Rails-side configuration masking was not changed because no Rails sanitized configuration dump currently exists; the same direct-object behavior already applies to renderer_password.
  • The generated/documentation volume note was informational and requires no code change.

Follow-up issue: None.

Validation: focused pre/post-fix Ruby probe; targeted Pro RuboCop; RBS validation; repository Prettier check; Pro license-header check; git diff --check; pre-commit hooks; pre-push branch lint and online Markdown links. Per repository policy, no local test suite was run; hosted CI is running on 2ada63840.

Pre-push review gate: manual self-review plus explicit Ruby/Node parity review; /simplify skipped because this was a minimal, review-targeted correctness patch and wording-only cleanup.

Next default scan starts after this comment. Say check all reviews to rescan the full PR.

Comment thread react_on_rails_pro/lib/react_on_rails_pro/configuration.rb Outdated
@claude

claude Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

Review: Allow Pro license tokens from Rails and Node configuration

Reviewed the diff (34 files, +760/-131) — this is a well-scoped, well-tested change that adds config.license_token (Rails) and licenseToken (Node renderer) as configurable secret sources for the Pro license, with explicit-nonblank-wins-over-ENV precedence on both sides, token masking in diagnostics, and thorough doc updates.

Overview

  • Ruby: ReactOnRailsPro.configuration.license_token added as a new config attribute with a custom setter that resets LicenseValidator's cache when the value changes; LicenseValidator#load_license_string now checks configuration before falling back to ENV["REACT_ON_RAILS_PRO_LICENSE"].
  • Node renderer: licenseToken added to Config, threaded through buildConfig, masked in every sanitized log view (default/customized/final), and passed explicitly into a new shared logLicenseStatus() helper used by both cluster-master and single-process startup paths (dedupes the previously master-only inline logging logic).
  • licenseValidator.ts caching switched from simple "cache once, no key" to a keyed cache (explicit token vs. an ENV/default sentinel key) so an earlier ENV-derived lookup can't stick around once an explicit token is supplied later in the same process — nice touch, and well covered by tests (does not reuse ENV/default status for a later configured token, etc.).
  • Docs are updated comprehensively and consistently across docs/pro/*, docs/oss/*, llms-full*.txt, and package READMEs, including the important process-boundary caveat (Rails config doesn't propagate to a standalone Node renderer) and the review-app security guidance extended to cover all three token sources.

Code quality / correctness

  • Security: token values are consistently masked (<MASKED> / <EMPTY STRING>) in every Node-side sanitized log view, and Ruby-side error/rake messages never echo the token value. I didn't find any place where the raw configured/env token leaks into logs.
  • Precedence semantics ("explicit nonblank wins, blank falls through to ENV") are implemented identically and correctly on both the Ruby and Node sides, and are well covered by unit tests on both.
  • Left one inline comment on react_on_rails_pro/lib/react_on_rails_pro/configuration.rb's license_token= setter: its cache-invalidation ("changed") check is instance-local, so it won't invalidate LicenseValidator's cache if a new Configuration instance is ever built directly with a non-default license_token: (a stubbing pattern already used elsewhere in this spec suite for other fields via allow(ReactOnRailsPro).to receive(:configuration).and_return(...)). No current call site hits this, so it's not an active bug, but the guarantee stated in the adjacent comment isn't fully true for that path.
  • Minor, non-blocking behavior change worth calling out: in master.ts, license-status logging now happens after buildConfig() (previously before). Since buildConfig() can process.exit(1) on invalid config (e.g. bad port/password), the license log line is now skipped in that failure path. Seems intentional/harmless but isn't mentioned in the PR description.
  • Good defensive test coverage overall: precedence, blank-fallback, masking-in-every-view, cache-key isolation between ENV/default and explicit tokens, and ordering guarantees (license check runs before workers are forked).

Risks / things to double check

  • No behavior change for apps that only use REACT_ON_RAILS_PRO_LICENSE — confirmed the env-var-only path is preserved as the default in both defaultConfig (Node) and load_license_string (Ruby).
  • The generator/install path intentionally still documents only the env-var form, matching the PR description ("no flagship demo change needed").

Nice work — this is a solid, low-risk enablement change with strong test coverage on both runtimes.

@ihabadham

Copy link
Copy Markdown
Collaborator Author

Address-review summary

Scan scope: activity after latest summary at 2026-07-09T21:14:53Z (default cutoff).

Mattered

  • Reproduced stale Ruby license metadata when the effective configuration was replaced with a fresh token-bearing Configuration instance.
  • Fixed all five Ruby caches in 1325f12e7 by keying them by normalized explicit token while preserving a shared ENV/default cache key and reset-required semantics.
  • Added regression coverage for replacing the effective configuration and preserving ENV/default caching.
  • Replied to and resolved the cache-invalidation review thread.

Optional

  • Skipped the note about documenting that invalid Node renderer configuration can exit before license logging. Resolving configuration first is required to obtain licenseToken, and no code change is needed.

Skipped

  • The remaining positive review summary, security assessment, documentation observations, and generator-path confirmation were non-actionable.

Follow-up issue: None.

Validation: focused pre/post-fix Ruby probe; targeted Pro RuboCop; RBS validation; Pro license-header check; git diff --check; pre-commit hooks; pre-push branch lint and online Markdown links. Per repository policy, no local test suite was run; hosted CI is running on 1325f12e7.

Next default scan starts after this comment. Say check all reviews to rescan the full PR.

@claude

claude Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

Review: Allow Pro license tokens from Rails and Node configuration

Overview
Adds config.license_token (Rails) and licenseToken (Node renderer) as alternative sources for the Pro license, with explicit nonblank configuration taking precedence over REACT_ON_RAILS_PRO_LICENSE, blank values falling back to the env var, and masking of the token in all sanitized diagnostic output. Also refactors the Ruby/TS license caches to key on the resolved token instead of a single process-lifetime flag, and moves the Node renderer startup license log into a shared logLicenseStatus helper invoked with the resolved token in both master and single-process modes.

Correctness

  • The precedence/fallback logic is symmetric and correctly implemented on both sides:
    • Ruby: configured_token || ENV.fetch(...) in load_license_string (license_validator.rb).
    • Node: userConfig.licenseToken?.trim() || runtimeDefaultConfig.licenseToken in buildConfig (configBuilder.ts), with the same blank-collapses-to-undefined behavior as the env default.
  • The new cache-keying scheme (license_cache_key / licenseCacheKey) fixes a real staleness bug: previously the cache was a single process-lifetime flag, so a configured token set after first access could never invalidate a cached ENV-derived (or missing) result. Keying the cache by the resolved token (falling back to a sentinel for the ENV/default path) correctly invalidates when the configured token changes, while intentionally preserving the prior one-shot ENV caching, reset-required semantics when only the ENV var changes at runtime. This is documented in code comments and covered by dedicated specs in license_validator_spec.rb (cases such as "when the ENV/default source changes after its status was cached" and "when a configured token is assigned after missing license information was cached").
  • Double-checked locking in fetch_cached_license_value looks correct: the cache key is recomputed both outside and inside the mutex, so a race where the configured token changes between the two checks is handled correctly.
  • Node renderer: license validation now happens once in the master before forking workers, or once in single-process mode, matching the updated doc comment in licenseValidator.ts about validating once per relevant process. master.ts and ReactOnRailsProNodeRenderer.ts were updated consistently, and masterStartupFailure.test.ts / nodeRendererStartupChecks.test.ts assert the resolved token is threaded through and that license logging happens before forking.

Security

  • Token masking is thorough: sanitizedSettings() masks licenseToken in all three sanitized views (module-load defaults, user-provided config, final config), and a dedicated test in configBuilder.test.ts (masks license tokens from every sanitized configuration view) asserts neither the configured nor env-derived token value appears anywhere in the serialized log payload. That is a good defense against accidental leakage via logSanitizedConfig().
  • docs/pro/deployment/review-app-security.md was correctly updated to cover all three token sources (env var, Rails credentials, Node licenseToken), not just the original env var.
  • No new location was found that logs the raw token (checked engine.rb, license_task_formatter.rb, and the Node log call sites). The only user-facing message referencing the token is the informational Set config.license_token or REACT_ON_RAILS_PRO_LICENSE hint, which does not include the value.

Test coverage

  • Good coverage of the precedence/fallback matrix on both sides (configured-only, env-only, both-present-configured-wins, blank-configured-falls-back-to-env), plus the cache-invalidation edge cases described above.
  • configuration_spec.rb and engine_spec.rb cover the new accessor and its use through the Rails engine log_license_status path.

Minor observations (non-blocking)

  • The installation, LICENSE_SETUP, and updating docs all consistently describe the same precedence rules, which is good since these are easy to let drift after a change like this.
  • The PR is large but the diff is well-scoped: Rails config, Node config, both validators cache logic, the shared Node startup log helper, and docs all change together consistently, with no leftover references to the old single-source-of-truth behavior found.

Overall this is a solid, well-tested change with good attention to the security-sensitive masking requirement and to a real pre-existing cache-staleness bug. No blocking correctness or security issues found.

@justin808

Copy link
Copy Markdown
Member

@ihabadham my agent it trying to finish this one up.

@justin808

Copy link
Copy Markdown
Member

@ihabadham we need to decide if this one goes into release/17.0.0 rather than main

@justin808
justin808 added this pull request to the merge queue Jul 10, 2026
Merged via the queue into main with commit 91aeba1 Jul 10, 2026
55 checks passed
@justin808
justin808 deleted the ihabadham/feature/configurable-pro-license-token branch July 10, 2026 04:23
@justin808

Copy link
Copy Markdown
Member

Batch handoff — ROR A 07-09 17:33

Immediate maintainer attention

  • None.

FYI / decisions made

  • Final state: merged. PR Allow Pro license tokens from Rails and Node configuration #4552 landed on main as 91aeba19402885e1e408592e966a1b18374c8097 at 2026-07-10T04:23:21Z.
  • merge_authority: auto_merge_when_gates_pass; the standard GitHub merge queue accepted the PR and performed the merge.
  • Release target decision: retain main. The open 17.0.0 tracker is in development mode; this optional configuration capability is not a demonstrated RC stabilizer.
  • Gate evidence at PR head 1325f12e7d921699f09b8c52270b4a964f814273: required CI readiness READY; merge state CLEAN; zero unresolved review threads; strict merge ledger complete_allowed: true with no violations or unknown fields.
  • Local gate validation: Node focused configuration/validator/startup/logging tests (122 passing), TypeScript check, source lint; Ruby focused specs (196 passing), Pro RuboCop and RBS; docs/sidebar, generated llms, Prettier, and diff checks.
  • Adversarial review: no BLOCKING or DISCUSS finding after manual diff/risk review. Local codex review could not start because the installed CLI is too old for its configured model; Claude CLI report-only fallback was unavailable because it is not authenticated. Current-head GitHub review checks from claude-review and CodeRabbit passed; visible Greptile/Codex artifacts predated the final code head and were treated only as stale advisory history.
  • Post-merge sweep: no late bot/human comment or unresolved thread. Normal main push CI for 91aeba194 has started; early docs, markdown-links, llms, mirrored-block, and docs-site checks are successful, with broader suites still in their normal queued/running state.

QA Evidence

qa-evidence v1

  • QA lane: ror-a-pr4552-qa-license-config; terminal heartbeat done at 2026-07-10T04:08:57Z; claim handed to the coordinator.
  • Scope checked: Rails Pro configuration/license metadata; standalone Node renderer precedence, masking, clustered-master, and workersCount=0; mapped docs and generated llms output.
  • Tested at: 1325f12e7d921699f09b8c52270b4a964f814273.
  • Automated checks: focused Rails specs (177 examples); focused Node tests (178); Node renderer build; Pro license-header; llms generated-output; diff-whitespace checks — all passed.
  • Manual checks: synthetic configured-token and whitespace-fallback behavior in Rails and Node; sanitized Node runtime log kept the synthetic token masked; docs confirm Rails configuration does not cross into a standalone Node process.
  • Findings: none.
  • QA required: yes — user-visible Rails and Node Pro runtime configuration changed.
  • QA lane status: satisfied.
  • Release-blocking status: clear.
  • Process-gap disposition: not applicable.

Merge ledger

priority-finding-dispositions v1

Confidence note: high for the merged PR. Coordination dashboard URL is UNKNOWN; backend event recording is unsupported, but claims, terminal heartbeats, QA evidence, and the strict ledger were all available.

Next action: no PR action remains. Continue the repository’s normal post-merge main health monitoring for the in-flight push workflows.

@justin808

Copy link
Copy Markdown
Member

@ihabadham @AbanoubGhadban this is on the release branch. It can be coming out very quickly after the first release.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

ready-for-hosted-ci Run optimized hosted GitHub CI for this PR

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants