requestshield 0.1.5 → 0.1.7

package/config/.env.prod

@@ -0,0 +1,5 @@
+# Public QAT settings for source-checkout development only. Never add secrets.
+API_URL=https://management-api-qat.intellifend.ai
+OAUTH_ISSUER=https://incongruous-cherry-0283.customers.stytch.dev
+OAUTH_AUTHORIZATION_ISSUER=stytch.com/project-test-968146e2-6f34-4936-9d1c-a7e966813c70
+OAUTH_CLIENT_ID=connected-app-test-5ff62ca4-c0eb-48c3-84e5-06ae8f669998

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "requestshield",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Customer CLI for IntelliFend RequestShield.",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
   },
   "files": [
     "src/",
+    "config/.env.prod",
     "skills/",
     "README.md"
   ],
@@ -18,19 +19,21 @@
     "node": ">=22.13"
   },
   "scripts": {
-    "build": "node scripts/check-package.mjs",
+    "check": "npm run lint && npm run typecheck && npm test && npm run test:contract && npm run build",
+    "build": "npm run lint && node scripts/build-package.mjs",
     "lint": "node scripts/check-package.mjs",
     "test": "node --test",
+    "test:contract": "node scripts/run-management-contract.mjs",
+    "requestshield-qat": "node dev/main-qat.mjs",
+    "requestshield-stg": "node dev/main-stg.mjs",
     "test:update-check:manual": "node scripts/manual-update-check.mjs",
     "typecheck": "tsc -p jsconfig.json --noEmit",
     "prepack": "node scripts/package-skill.mjs stage",
     "postpack": "node scripts/package-skill.mjs clean",
-    "prepublishOnly": "npm run lint && npm run typecheck && npm test"
+    "prepublishOnly": "npm run check"
   },
   "devDependencies": {
     "@types/node": "26.1.1",
-    "esbuild": "^0.28.1",
-    "postject": "1.0.0-alpha.6",
     "typescript": "^6.0.3"
   },
   "license": "UNLICENSED"

package/skills/requestshield/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: requestshield
-description: Install, verify, troubleshoot, or remove IntelliFend RequestShield bot protection in a customer codebase — the browser SDK in Seamless or Manual mode, plus Java backend enforcement via the Spring Boot 3 starter or the Java core SDK — driving the `requestshield` CLI for sign-in, app keys, the integration contract, and traffic checks. Use this skill whenever the user mentions RequestShield, IntelliFend, `X-IntelliFend-Token`, `IntelliFend.getToken()`, `data-protect`, `@RequestShieldProtected`, App Key or API Secret setup, or asks to protect an endpoint such as registration, sign-in, password reset, checkout, or form submission from bots, scripted abuse, or credential stuffing — even when they never name the product. Also use it before hand-editing any file that already contains a RequestShield script tag, `verify()` call, or protection annotation.
+description: Install, verify, troubleshoot, or remove IntelliFend RequestShield bot protection in a customer codebase — the browser SDK in Seamless or Manual mode, plus Java backend enforcement via the Spring Boot 3 starter or the Java core SDK — using the `requestshield` CLI for sign-in, applications and credentials, with SDK documentation and runtime observations for integration checks. Use this skill whenever the user mentions RequestShield, IntelliFend, `X-IntelliFend-Token`, `IntelliFend.getToken()`, `data-protect`, `@RequestShieldProtected`, App Key or API Secret setup, or asks to protect an endpoint such as registration, sign-in, password reset, checkout, or form submission from bots, scripted abuse, or credential stuffing — even when they never name the product. Also use it before hand-editing any file that already contains a RequestShield script tag, `verify()` call, or protection annotation.
 ---
 
 # RequestShield integration
@@ -27,18 +27,18 @@ password reset, checkout, form submission — not a read-only route in front of
 
 ```bash
 requestshield --version          # is the CLI present?
-requestshield auth status        # {"authenticated":true,...} — most commands need this
+requestshield auth status --json # local session metadata, no provider check
 ```
 
 
-If `requestshield --version` fails, the CLI is not installed. **Stop and say so.** Ask
-the user to install it; do not substitute hand-crafted HTTP calls, and do not fall back
-to the example values in this skill — the contract is the only authoritative source for
-the script URL, header name, and released modes, and a guessed script URL produces a
-page that silently loads nothing.
+If `requestshield --version` fails, explain that CLI account/app operations need
+an installed compatible version. Do not substitute invented HTTP calls. SDK URLs,
+headers, modes and backend requirements come from the customer documentation for
+the chosen SDK release; the integration-contract CLI command is unavailable.
 
-If `auth status` shows the user signed out, ask them to run `requestshield signin`
-themselves — it is interactive. Never script around it or ask for credentials.
+If local status is `signed_out`, ask the user to complete `requestshield signin`
+themselves. Never ask for credentials. `valid` is a local state only; an expired
+session may refresh during the next authenticated command.
 
 Those commands are the preflight for integration-changing work. For read-only CLI
 questions, go to **Classify the request** and run only the matching command.
@@ -50,16 +50,16 @@ single CLI call or a short answer. Match on what the user wants, not on exact wo
 
 | Intent | Sounds like | Do this |
 | --- | --- | --- |
-| **General info** | "what version", "is there a newer CLI", "am I up to date" | `requestshield --version`, then `requestshield update check`. Report both and the gap between them. No credentials check, no repo scan. |
+| **General info** | "what version", "is there a newer CLI", "am I up to date" | Use `requestshield --version`. For an explicitly requested update check, explain that production `update check` can offer a global npm installation; accept it only within the user’s requested scope. |
 | **Authentication** | "sign me in", or preflight `auth status` came back unauthenticated | Ask the user to run `requestshield signin` in their own terminal, and wait. It is interactive — never automate it, never run it for them, never ask for credentials. Re-run `auth status` once they confirm. |
 | **Key / secret management** | "create an app key", "I need an API Secret", "rotate the secret", "deactivate a key" | **Hand the command over; do not run it.** → "Key and secret management" below. |
 | **Install** | "add RequestShield", "protect /api/register" | `references/integration-planning.md` full flow → **Installing** → **Verifying** → **Negative test**. Do not reorder or skip a step. |
 | **Uninstall** | "remove it", "roll it back" | `references/integration-planning.md` (Detect existing integration only) → **Uninstalling**. |
 | **Verify / troubleshoot** | "is it set up right?", "why is it not blocking?", a reason code | `references/integration-planning.md` (Detect existing integration only) → **Verifying**. For a reason code, also read `references/troubleshooting.md`. |
-| **Challenge volume** | "how much traffic", "how many challenges", "show me the volume" | Ask for the time range first. `challenge volume` takes `--from`/`--to`/`--granularity`; a guessed window produces a confident wrong answer. Then run it with the App Key. |
-| **Billing** | "am I being charged", "what plan", "what are my limits" | Resolve the application, then run `requestshield get billing <app-key>`. |
-| **Service health** | "is the service up", "is it degraded" | `requestshield server`. |
-| **Agent setup** | "set this up for Codex too", "install the skill for Claude" | Run `requestshield agent setup` for auto-detection, or pass the requested agent: `--agent codex` or `--agent claude`. This installs agent guidance; it does not mint keys or edit customer application code. |
+| **Challenge volume** | "how much traffic", "how many challenges" | Explain that the CLI analytics command is unavailable. Use existing authorized monitoring; do not infer volume from app status. |
+| **Billing** | "am I being charged", "what plan", "what are my limits" | Explain that billing is unavailable in this CLI; use the customer’s established billing/support channel. |
+| **Service health** | "is the service up", "is it degraded" | No service-health CLI command exists. Inspect authorized health/monitoring evidence without exposing credentials. |
+| **Agent setup** | "set this up for Codex too", "install the skill for Claude" | Run `requestshield agent setup` for auto-detection, or pass the requested agent: `--codex` or `--claude`. This installs agent guidance; it does not mint keys or edit customer application code. |
 | **Anything else** | | Look the command up in `references/cli.md`. If it is not there, run `requestshield --help` rather than guessing at a flag. |
 
 Full CLI surface, output shapes, and which commands need auth: `references/cli.md`.
@@ -72,30 +72,30 @@ independent.
 
 ## Key and secret management
 
-`keys create`, `app key rotate`, and `keys deactive` are the one place you do **not**
-drive the CLI. Two independent reasons, and each is sufficient on its own:
+Commands that display API secrets should run in the user's terminal so their
+values never enter the agent's tool output or conversation. State-changing
+commands must match the user's requested application and action.
 
-- `keys create` and `app key rotate` print the API Secret to stdout exactly once. A
-  command you run puts that value in your tool output and transcript.
-- `keys deactive` and `app key rotate` change state for a live App Key. Deactivating the
-  wrong one stops verifying real traffic.
-
-So hand it over. Tell the user which command to run in their own terminal:
-
-```bash
-requestshield keys create --app-name <name>          # new App Key + API Secret pair
-requestshield app key rotate --app-key <app-key>     # new secret, App Key unchanged
-requestshield keys deactive --app-key <app-key>      # stops verification for that key
+```console
+requestshield keys create --app-name <name>
+requestshield keys rotate <app-key>
+requestshield keys reveal <app-key>
+requestshield keys revoke <app-key>
+requestshield apps disable <app-key>
 ```
 
-Warn them **before** they run secret creation or rotation that the secret appears once
-and they need somewhere to put it. Afterwards, confirm by presence only and use
-`requestshield credentials status <app-key>` for the server-side view. Never ask the
-user to paste the secret back, and never read it out of a file or the environment.
+Create makes a new application. Rotate keeps the App Key and replaces its secret.
+Reveal retrieves the current active secret when a prior response was lost; an
+exposed secret instead requires rotation. Revoke invalidates the secret, while
+application disable retains it. Acceptance is asynchronous, not proof of immediate
+propagation. Explain the impact and storage requirement before the user runs a
+command, then confirm secret presence only. Never ask them to paste a secret back.
 
-A lost or exposed secret cannot be re-displayed. The fix is `app key rotate`, run by
-the user. Deleting a leaked value from a repo, log, artifact, or transcript does not
-un-expose it.
+Create/rename/enable do not prompt. Disable/rotate/revoke/reveal require confirmation
+or `--yes`. Mutations other than reveal accept `--idempotency-key`; uncertain results
+must be retried with identical arguments and the same key within seven days, never
+a fresh key. A replay may return `apiSecret: null`; use explicit reveal rather than
+automatically creating or rotating again. See `references/cli.md`.
 
 ## Installing
 
@@ -106,7 +106,7 @@ It must settle the App Key, the existing-integration state, the contract values,
 backend path, and the browser mode before step 1 below.
 
 1. **Browser side** — add the hosted script once in `<head>`, using the `script_url`
-   from `requestshield contract`, then follow the chosen browser reference:
+   from the published customer documentation for that SDK release, then follow the chosen browser reference:
    - Seamless → `references/browser-seamless.md`
    - Manual → `references/browser-manual.md`
 2. **Backend side** — add the dependency, configure `app-key` and `api-secret` from
@@ -135,7 +135,7 @@ hand-off and warning are in **Key and secret management** above. Afterwards refe
 only as "the secret you just received".
 
 If a secret has already reached a repo, a log, an artifact, or this transcript, the fix
-is `requestshield app key rotate --app-key <app-key>`, run by the user.
+is `requestshield keys rotate <app-key>`, run by the user.
 
 ## Verifying
 
@@ -160,30 +160,22 @@ Then the static checks. They are deterministic and catch most real breakage.
 - Cross-origin endpoints: CORS allows `X-IntelliFend-Token`.
 - No token or secret in logs, analytics, URLs, or error reporting.
 
-Structural correctness is not proof of enforcement. For runtime evidence, exercise the
-endpoint and confirm the platform saw the traffic:
-
-```bash
-requestshield challenge volume <app-key> \
-  --from <start> \
-  --to <end> \
-  --granularity hour
-```
-
-Report static correctness and platform traffic separately. A flat zero after real
-traffic means the browser half is not firing; go back to the selected browser reference
-before changing backend code.
+Structural correctness is not proof of enforcement. For runtime evidence,
+exercise the endpoint in an authorized environment and inspect the browser request
+and backend decision without recording tokens. The CLI challenge-volume command
+is unavailable, and application status does not establish traffic. Report static
+checks, observed requests and backend enforcement separately.
 
 ### The negative test — the only proof of enforcement
 
-Neither static checks nor `challenge volume` can prove the backend refuses a tokenless
-mutation. The proof is a request the backend should reject.
+Neither static checks nor observed browser traffic can prove the backend refuses a
+tokenless mutation. The proof is a request the backend should reject.
 
 Before running it, establish:
 
-1. `requestshield server` is healthy. This reports platform health only; it does not prove
-   that the backend under test can reach the Challenge Server or that its local circuit
-   has closed. A healthy platform can still produce a degraded result at that backend.
+1. The backend under test can reach its configured verification service and safe
+   metrics show a non-degraded control request. A platform-wide health report alone
+   would not establish that this backend’s local circuit has closed.
 2. The endpoint's effective mode is `BLOCK`, not `MONITOR`. Include any method-level
    override when resolving the effective mode. `MONITOR` allows every request by design.
 3. A valid control request is available. Its authentication, session, CSRF state, route,
@@ -255,9 +247,9 @@ first:
    other source and header in place.
 5. Configuration keys and environment variable references.
 
-Then ask whether to also deactivate the keys server-side:
-`requestshield keys deactive --app-key <app-key>`. That is not reversible the way a
-code edit is, so it stays the user's explicit call.
+Application disable is a separate action: `requestshield apps disable <app-key>`.
+Perform or hand it off only when the user requested that live-state change; removing
+integration code does not itself authorize revocation or disable.
 
 ## Non-negotiables
 
@@ -280,8 +272,8 @@ These separate an integration that protects traffic from one that only looks lik
   backend apply its configured policy.
 - **The API Secret stays at the backend.** Never put it in browser code,
   client-visible responses, source control, logs, build artifacts, or chat transcripts.
-- **You never run a command that mints, rotates, or deactivates a key.** Hand those
-  commands to the user and verify by presence only.
+- **Keep displayed secrets out of tool output.** Hand create/rotate/reveal to the
+  user and verify by presence only. Match other live-state changes to user intent.
 
 ## Reference files
 
@@ -298,10 +290,10 @@ These separate an integration that protects traffic from one that only looks lik
 ## For agent setup
 
 `requestshield agent setup` installs this skill for the detected or requested agent.
-Use `--agent codex` or `--agent claude` when the user names the target agent. For Codex
-repositories that also use `AGENTS.md`, the CLI can write the managed block from
-`assets/AGENTS.codex.md` so repo-local guidance points back to the installed skill and
-the same reference files.
+Use `--codex` or `--claude` when the user names the target agent. Setup installs
+into the agent’s personal skill directory; it does not edit repository `AGENTS.md`.
+`assets/AGENTS.codex.md` is an optional template for a separately requested
+repository instruction change.
 
 Agent setup installs guidance only. It does not mint keys, rotate secrets, deactivate
 keys, or edit customer application code.

package/skills/requestshield/assets/AGENTS.codex.md

@@ -1,11 +1,11 @@
-<!-- requestshield:begin — managed by `requestshield agent setup --agent codex`. Edit the skill source, not this block. -->
+<!-- Optional repository guidance template. Agent setup installs the personal skill; it does not write this file. -->
 ## RequestShield integration
 
 This repository uses IntelliFend RequestShield to protect selected operations from
 automated abuse. Before installing, verifying, changing, or removing that protection —
 and before hand-editing any file that already contains a RequestShield script tag,
 `data-protect`, `X-IntelliFend-Token`, `IntelliFend.getToken()`, `verify()`, or
-`@RequestShieldProtected` — read `.requestshield/skill/SKILL.md` and follow it.
+`@RequestShieldProtected` — read `~/.agents/skills/requestshield/SKILL.md` and follow it.
 
 The procedure exists because the failure mode here is silent. Every integration has two
 halves: the browser obtains and transports a token, and the backend evaluates it before
@@ -24,29 +24,30 @@ tokens flowing with nothing enforcing them. Java below 17 blocks both backend pa
 
 Orientation:
 
-- `.requestshield/skill/SKILL.md` — the procedure. Start here.
-- `.requestshield/skill/references/integration-planning.md` — the planning flow:
+- `~/.agents/skills/requestshield/SKILL.md` — the procedure. Start here.
+- `~/.agents/skills/requestshield/references/integration-planning.md` — the planning flow:
   credentials check, detecting an existing integration, gating on the backend stack
   (Java version, Spring MVC vs WebFlux, other frameworks), and choosing the browser mode.
   Read it before any install, verify, or uninstall.
-- `.requestshield/skill/references/cli.md` — the `requestshield` CLI; every platform
-  action (sign-in, keys, contract, traffic checks) goes through it.
-- `.requestshield/skill/references/browser-seamless.md` — Seamless mode: exact-endpoint
+- `~/.agents/skills/requestshield/references/cli.md` — supported sign-in, app and secret
+  commands. Contract, service-health, credential-status, traffic and billing commands
+  are unavailable; use customer release docs and authorized runtime observations.
+- `~/.agents/skills/requestshield/references/browser-seamless.md` — Seamless mode: exact-endpoint
   matching, and the transports it does not cover.
-- `.requestshield/skill/references/browser-manual.md` — Manual mode, carriers, CORS, CSP.
-- `.requestshield/skill/references/backend-spring-boot.md` — enforcement on Spring Boot 3
+- `~/.agents/skills/requestshield/references/browser-manual.md` — Manual mode, carriers, CORS, CSP.
+- `~/.agents/skills/requestshield/references/backend-spring-boot.md` — enforcement on Spring Boot 3
   MVC: the `@RequestShieldProtected` annotation path.
-- `.requestshield/skill/references/backend-java-core.md` — enforcement on any other
+- `~/.agents/skills/requestshield/references/backend-java-core.md` — enforcement on any other
   Java 17 backend: the `verify()` path.
-- `.requestshield/skill/references/troubleshooting.md` — reason codes and diagnosis.
+- `~/.agents/skills/requestshield/references/troubleshooting.md` — reason codes and diagnosis.
 
 Five rules worth carrying without opening a file:
 
 - The **API Secret** never enters source control, logs, or a reply. It belongs in backend
-  runtime secret storage, and `requestshield app key rotate` is the fix if it leaks. The
+  runtime secret storage, and `requestshield keys rotate <app-key>` is the fix if it leaks. The
   **App Key** is public and must be identical in browser and backend.
-- **Never run `keys create`, `app key rotate`, or `keys deactive` yourself.** They print
-  the secret or change state for a live key. Hand the command to the user, have them
+- **Keep secret output out of tool transcripts.** Have the user run create, rotate
+  and reveal in their own terminal, then have them
   export `INTELLIFEND_REQUESTSHIELD_APP_KEY` and
   `INTELLIFEND_REQUESTSHIELD_API_SECRET`, and confirm by presence only.
 - Every protected request needs its **own token, verified exactly once**. Reuse or a
@@ -57,6 +58,5 @@ Five rules worth carrying without opening a file:
   non-empty string**; when it is empty, omit the header and let the backend apply its
   configured policy.
 
-Run `requestshield contract` before writing integration code — it is authoritative for
-the script URL, header name, released modes, and backend baseline.
-<!-- requestshield:end -->
+Consult customer documentation for the chosen SDK release before changing the script
+URL, header name, released modes or backend baseline. The contract CLI is unavailable.

package/skills/requestshield/references/backend-java-core.md

@@ -13,9 +13,9 @@ is not Spring Boot 3 MVC, including a Spring Boot 3 app built on WebFlux, which
 Spring MVC. Also needed: the same App Key the browser uses, the backend-only API Secret,
 and a web framework that can extract the token carrier.
 
-Confirm the baseline and supported languages with `requestshield contract` first. If the
-customer's backend language is not listed, the honest answer is that the integration is
-not supported yet, because a browser-only install protects nothing.
+Confirm the baseline and supported languages in the customer SDK documentation
+for the selected release. The CLI integration-contract command is unavailable. Do
+not promise an undocumented backend path; a browser-only install protects nothing.
 
 The browser mode does not decide this path. Either Seamless or Manual mode delivers the
 token, and the application extracts it and passes the value unchanged to `verify()`.

package/skills/requestshield/references/backend-spring-boot.md

@@ -13,9 +13,9 @@ writing anything — the detection recipes are in `integration-planning.md`, und
 -> Run the check**. Also needed: the same
 App Key the browser uses, and the backend-only API Secret.
 
-Confirm the baseline and supported languages with `requestshield contract` first. If the
-customer's backend language is not listed, the honest answer is that the integration is
-not supported yet, because a browser-only install protects nothing.
+Confirm the baseline and supported languages in the customer SDK documentation
+for the selected release. The CLI integration-contract command is unavailable. Do
+not promise an undocumented backend path; a browser-only install protects nothing.
 
 The browser mode does not decide this path. Either Seamless or Manual mode delivers the
 token in `X-IntelliFend-Token`, and the starter reads that header without caring how it

package/skills/requestshield/references/browser-manual.md

@@ -16,7 +16,7 @@ Seamless interception:
 
 ```html
 <script
-  src="SCRIPT_URL_FROM_CONTRACT"
+  src="SDK_SCRIPT_URL_FROM_RELEASE_DOCS"
   data-app-key="YOUR_APP_KEY"
   defer
 ></script>
@@ -24,7 +24,7 @@ Seamless interception:
 
 | Attribute | Required | Notes |
 | --- | --- | --- |
-| `src` | Yes | Take it from `requestshield contract` → `browser.script_url`. Currently `https://static.intellifend.ai/intellifend.js`; read the contract rather than trusting this line. |
+| `src` | Yes | Use the customer Browser SDK installation documentation for the selected release; its mutable example is `https://static.intellifend.ai/intellifend.js`. The CLI contract command is unavailable. |
 | `data-app-key` | Yes | Public App Key. Must match the backend's configured key. |
 | `defer` | Recommended | Keeps HTML parsing unblocked. |
 
@@ -188,8 +188,8 @@ Content-Security-Policy:
   worker-src 'self' blob:;
 ```
 
-Confirm the hosts **and the directive list** against `requestshield contract` and the
-customer deployment guide before editing a live policy — this skill is not the authority
+Confirm the hosts **and the directive list** against the customer SDK release and
+deployment documentation before editing a live policy — this skill is not the authority
 on either. If `getToken()` returns an empty string on a page that sends a CSP, a blocked
 directive is the first thing to check: the browser console names what it refused, which
 beats guessing at the policy.

package/skills/requestshield/references/browser-seamless.md

@@ -14,7 +14,7 @@ otherwise an early request leaves the page before interception is installed:
 
 ```html
 <script
-  src="SCRIPT_URL_FROM_CONTRACT"
+  src="SDK_SCRIPT_URL_FROM_RELEASE_DOCS"
   data-app-key="YOUR_APP_KEY"
   data-protect='["/api/register"]'
   defer
@@ -136,20 +136,12 @@ Static checks:
 3. Every protected endpoint reaches the network via `fetch` or async XHR from page
    scope.
 
-Runtime check: exercise the endpoint, confirm the network request carries a non-empty
-`X-IntelliFend-Token`, then confirm the platform saw it. This proves the browser half is
-firing; the negative test in `SKILL.md` proves backend enforcement.
-
-```bash
-requestshield challenge volume <app-key> \
-  --from <start> \
-  --to <end> \
-  --granularity hour
-```
-
-Zero volume with a correct-looking `data-protect` is nearly always a path mismatch
-(trailing slash, case, a different origin than assumed) or one of the uncovered
-transports above. Re-read the actual request URL before changing anything else.
+Runtime check: exercise the endpoint in an authorized environment and confirm its
+request carries a non-empty `X-IntelliFend-Token` without recording the token value.
+Inspect safe backend decision metrics separately; the negative test in `SKILL.md`
+provides enforcement evidence. The CLI challenge-volume command is unavailable.
+A missing header can indicate a path mismatch or an uncovered transport; compare
+the actual request URL and transport before changing backend code.
 
 ## Expected result