scriptoriumadmin/strix
1
0
Fork 0
mirror of https://github.com/usestrix/strix.git synced 2026-09-05 08:06:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

feat(cli): strix cloud — managed platform CLI (login, scans, billing, and the rest of the API) (#1177)

Browse source 
* feat(cli): add strix login for managed platform sign-in (device flow)

* feat(cli): add --scopes flag to strix login

* docs: document strix login and managed billing in README, AGENTS, docs, and managed skill

* fix(cli): handle malformed login responses and credential file failures

* fix(cli): reject sign-in responses without an API token

* feat(login): interactive workspace and scope selection with presets

* fix(login): reject malformed API token values in sign-in responses

* fix(login): skip the scope prompt when stdin is not a terminal

* fix(login): tolerate malformed selection containers and remove unreadable credential files on logout

* fix(login): treat overflowing timing values as invalid

* fix(login): show the configured platform host in the sign-in banner

* fix(login): bound device flow timing values and clean up unreplaced secret temp files

* feat(cli): add the strix cloud command surface for the managed platform

* feat(cli): manage workspaces and hosted onboarding links from strix cloud

* fix(cli): report a leftover temporary secret file instead of hiding it

* feat(cli): pass a Stripe payment method to the top-up wallet client

* docs(cloud): recommend the Stripe agent wallet as the default payment path

* fix(cloud): preserve API auth during MPP payment

* fix(cloud): drop knowledge query and settings commands removed from the API

* fix(cloud): align agent commands with API contracts

* fix(cloud): send required PR review integration fields

* fix(cloud): preserve scopes when switching workspaces

* fix(cloud): make session command help non-destructive

* feat(cloud): improve human navigation and output

* feat(cli): add native shell completions

* feat(cloud): tailor human list and detail views

* feat(cloud): upload local source for managed scans

* fix(cloud): infer scan type from local targets

* Add agent-friendly managed cloud CLI

* Harden cloud CLI type boundaries

* Clarify cloud test user MFA options

* Correct cloud vulnerability status guidance

* Clarify chat file path handling

* Allow signed storage upload URLs

* Fix provider token request handling

* Improve cloud CLI human list views

* Make cloud CLI workflows actionable and safe

* Make cloud workspace switching session-safe

* Preserve CLI session metadata in JSON output

* Remove preview protection bypass plumbing from cloud CLI
This commit is contained in:
alex s 2026-09-01 14:39:34 -04:00 • committed by GitHub
parent 608ef4a37b
commit de730119f0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
34 changed files with 14564 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
AGENTS.md
View file

@ -38,13 +38,25 @@ Target-specific workflows built on the same engine:
- **Managed cloud (app.strix.ai):** no Docker, no LLM key, no local install; adds team dashboards, scheduling, PR reviews, and downloadable PDF/DOCX reports (Enterprise plan). Best in sandboxed/CI environments and for teams. Use it when local infra isn't available.
```bash
# token from Settings → API Access; register the target as an asset, then:
curl -sS https://app.strix.ai/api/v1/scans -H "Authorization: Bearer $STRIX_API_TOKEN" \
-H "Content-Type: application/json" -d '{"engagement_type":"live_test","domain_ids":["<uuid>"]}'
strix cloud login --scopes scans:read scans:write uploads:write billing:read
strix cloud domains add --domain example.com --asset-type web_app
strix cloud scans start --engagement-type live_test --domain-ids <uuid> --wait
strix cloud scans start --source . --dry-run --show-files --json # review + capture source.archive_sha256
SOURCE_SHA256="<reviewed source.archive_sha256>"
strix cloud scans start --source . --approve-sha256 "$SOURCE_SHA256" --wait
strix cloud vulns list --severity critical
strix cloud billing topup --credits 20 --yes # explicit approval after exit code 5
```
- API docs: https://docs.app.strix.ai (OpenAPI: https://docs.app.strix.ai/openapi.json).
- Account setup runs from the CLI too: `strix cloud workspaces list|create|use` (`workspace` is an alias and `use` accepts a displayed number, name, or ID), `strix cloud session scopes|scopes set`, `strix cloud org members invite`, `strix cloud billing subscribe --plan strix_cloud`, `strix cloud billing portal`, `strix cloud integrations install github`, and `strix cloud domains verify <id>`. Workspace switching preserves the server-side profile and can never widen past the login ceiling; ordinary switches do not reprompt. The last four end at a person: the command prints a link or a DNS record for the user to open or add, and it never completes the payment, installation, or DNS change for them.
- Every REST operation has a `strix cloud <resource> <verb>` command. Run `strix cloud` to list them. Output is JSON when stdout is not a terminal (or with `--json`), and there are no prompts without a TTY. Binary downloads are the exception: redirect raw bytes intentionally, or combine `--output FILE --json` for structured download metadata. Exit codes: `0` success, `1` error, `2` usage, `4` auth or plan limit, `5` payment required. `--token` or `STRIX_API_TOKEN` is a stateless override and never replaces stored auth; set `--workspace-id`/`STRIX_WORKSPACE_ID` for an override CLI session. `--data` adds extra request fields as JSON, and accepts `@file` or `-` for standard input.
- Local source uploads require `uploads:write`. For an agent/CI handoff, review `scans start --source . --dry-run --show-files --json`, capture `source.archive_sha256`, then rerun with the same `--source`, `--exclude`, and `--include-*` selection flags plus `--approve-sha256 HASH`. A changed snapshot is rejected. `--yes` approves only the snapshot built in that invocation, so reserve it for a deliberate human or one-shot approval rather than a digest-bound two-step handoff.
- Git ignores, hidden files, `.git`, symlinks, dependency/build output, secret-like filenames, and nested archives are excluded by default; `.strixignore` and `--exclude` narrow the manifest further (a trailing `/` excludes a directory subtree). Limits: 20,000 files, 25 MiB/file, 250 MiB expanded, 50 MiB compressed. Source-only infers `code_review`; source plus a domain infers `live_test`.
- The temporary local archive is always removed. A staged upload is deleted after a definitive rejection, but retained when a network error, `5xx`, malformed success response, or interruption leaves the scan launch ambiguous. JSON reports its `upload_id` with `launch_outcome_unknown: true`, or with `cleanup_unknown: true` when automatic deletion cannot be confirmed. Check `scans list` before retrying; if no scan is linked, run `uploads delete UPLOAD_ID`.
- Non-Enterprise scans consume the scope estimate (a default-tier source-only review currently starts at 60 credits); Enterprise scans are plan-included. A rejected launch does not consume credits.
- Human output is compact and numbered; non-TTY output and `--json` retain full records. Enable tab completion with `source <(strix completions zsh)` (or `bash`), or `strix completions fish | source`.
- The REST API works directly too: https://docs.app.strix.ai (OpenAPI: https://docs.app.strix.ai/openapi.json).
- CLI docs index for LLMs: https://docs.strix.ai/llms.txt (full: https://docs.strix.ai/llms-full.txt).
- CLI docs index for LLMs: https://docs.strix.ai/llms.txt (full: https://docs.strix.ai/llms-full.txt). Managed API docs for LLMs: https://docs.app.strix.ai/llms.txt.
- Only scan targets the user is authorized to test.
## Contributing to this repo

102
README.md
View file

@ -320,6 +320,108 @@ strix auth status # show the active sign-in
strix auth logout # forget the sign-in
```
#### Use the managed platform: `strix cloud`
The `strix cloud` commands drive the managed platform ([app.strix.ai](https://app.strix.ai)) from the terminal. Sign in once with the device flow. The sign-in creates your account and workspace on first use and stores a personal API token in `~/.strix/platform-auth.json`:
```bash
strix cloud login # browser approval, then workspace + scope profile
strix cloud login --workspace "My Team" # select a workspace by name or ID
strix cloud whoami # fast local account/workspace status
strix cloud session # verify remote session + consent ceiling
strix cloud logout # revoke remotely, then remove locally
```
The default **Recommended** scope preset supports normal scan work, local source uploads,
workspace switching, and user-approved credit top-ups. It excludes credential creation;
request `tokens:write` explicitly (or choose Full) when needed. For strict least privilege, pass an explicit list such as
`--scopes scans:read scans:write uploads:write billing:read`. Named automation
profiles are also available with `--scope-profile minimal|recommended|full`.
Every operation of the [REST API](https://docs.app.strix.ai) has a matching command in the form `strix cloud <resource> <verb>`:
```bash
strix cloud # list all resources
strix cloud scans # run the safe default (`scans list`)
strix cloud scans help # list the verbs of a resource
strix cloud domains add --domain example.com --asset-type web_app
strix cloud scans start --engagement-type live_test --domain-ids <uuid> --wait
strix cloud scans start --source . --dry-run --show-files --json # review + capture source.archive_sha256
SOURCE_SHA256="<reviewed source.archive_sha256>"
strix cloud scans start --source . --approve-sha256 "$SOURCE_SHA256" --wait
strix cloud vulns list --severity critical
strix cloud credits # credit balance
strix cloud billing topup --credits 20 --yes # explicitly approve agent payment after HTTP 402
```
Workspaces and account setup also work from the terminal:
```bash
strix cloud workspaces list # numbered list; `workspace` is also accepted
strix cloud workspaces create --name "My Team" # admin + organizations:write
strix cloud workspaces use 2 # switch by list number, exact name, or ID
strix cloud session scopes # granted scopes + login ceiling
strix cloud session scopes set minimal # narrow without another browser sign-in
strix cloud billing subscribe --plan strix_cloud # opens the hosted checkout page
strix cloud billing portal # opens the billing portal
strix cloud integrations install github # opens the app installation page
strix cloud domains verify <domain-id> # prints the DNS record to add
```
The last four commands end at a person. Strix creates the link, opens the browser for an interactive terminal, and always prints the URL. The user enters the card, approves the installation, or adds the DNS record. Pass `--no-browser` to print the URL only.
The commands work for humans and agents: terminal output favors names, branches, lifecycle states, and numbered selectors, while redirected output (or `--json`) preserves complete machine-readable records and IDs. Human lists retain the selectors needed by follow-up commands but omit internal organization/user IDs; a selector too long for the compact table is repeated losslessly in a copyable block. Paginated lists print the next `--page` or `--offset`, and detail views preserve useful prose within a safe terminal bound; use `--json` for the complete record. Token lists distinguish API keys from named CLI device sessions. Binary downloads are the exception: intentionally redirect their raw bytes, or use `--output FILE --json` to write the file and receive structured download metadata. There are no prompts when stdin is not a terminal. Exit codes: `0` success, `1` error, `2` invalid usage, `4` authentication or plan limit, `5` payment required. `--token` and `STRIX_API_TOKEN` are stateless per-command overrides and never replace the stored sign-in; pair a CLI-session override with `--workspace-id` or `STRIX_WORKSPACE_ID`.
A browser sign-in creates one reusable credential per CLI installation. Logging in again on the
same installation replaces its secret instead of accumulating keys. Workspace switches keep that
credential and expiry, preserve the server-side scope preference, cap access by the target role,
and can never exceed the login consent ceiling. Each process pins its starting workspace, so a
concurrent switch fails safely instead of sending a stale command to another organization.
`strix cloud logout` revokes the server session before deleting the local token; use
`--local-only` only when you deliberately cannot reach the server.
Write commands take request fields as flags, and every write command also accepts one JSON object with `--data`:
```bash
strix cloud scans start --data '{"engagement_type":"code_review"}' # literal JSON
strix cloud scans start --data @request.json # read a file
cat request.json | strix cloud scans start --data - # read standard input
```
For an agent or CI local-source scan, run `--dry-run --show-files --json`, review the manifest,
and capture `source.archive_sha256`. Rerun with the same `--source`, every `--exclude`, and any
`--include-*` selection flags, replacing `--dry-run` with `--approve-sha256 HASH`; Strix
rebuilds the archive and refuses to upload it if the digest changed. `--yes` instead approves
only the snapshot built in that one invocation. It is suitable for a deliberate human or
one-shot approval, not as a digest-bound two-step agent/CI handoff.
The safe default honors `.gitignore` and `.strixignore` and excludes hidden paths, secret-like
files, VCS metadata, dependencies/build output, symlinks, and nested archives. Opt in
separately with `--include-hidden`, `--include-sensitive`, or `--include-archives`. The client
caps a bundle at 20,000 files, 25 MiB per file, 250 MiB expanded, and 50 MiB compressed, and
the service independently validates the archive. Source alone infers a code review; adding a
domain infers a live test. You can always pass `--engagement-type` explicitly.
Strix removes the temporary local archive after every invocation. It deletes a staged remote
upload after a definitive scan rejection. If a network error, `5xx` response, malformed
success response, or interruption makes the launch outcome ambiguous, it retains the upload and reports its `upload_id` with
`launch_outcome_unknown: true`; if automatic deletion cannot be confirmed, it reports the ID
with `cleanup_unknown: true`. Check `strix cloud scans list` before retrying. If no scan is
linked to the retained upload, delete it with `strix cloud uploads delete UPLOAD_ID`.
Non-Enterprise scans consume the deterministic estimate shown for their scope (a source-only
code review at the default `ultra` tier currently starts at 60 credits). Enterprise scans are
plan-included and do not consume the credit wallet. Report downloads need Enterprise,
schedules need Pro, and billing writes need an admin token. Plan blocks exit `4`; an
insufficient credit wallet exits `5` without creating or charging a scan.
Enable native tab completion once per shell session:
```bash
source <(strix completions zsh) # use bash instead of zsh when appropriate
strix completions fish | source
```
#### Connect your own MCP servers
Strix can connect to Model Context Protocol (MCP) servers you list and expose their tools to the agent during a run. Create `~/.strix/mcp-servers.json` with a JSON list of servers. Each entry is either a local `stdio` server that Strix launches as a subprocess, or a remote `http` server:

19
docs/cloud/overview.mdx
View file

@ -35,6 +35,25 @@ Skip the setup. Run Strix in the cloud at [app.strix.ai](https://app.strix.ai).
2. Connect your repository or enter a target URL
3. Launch your first scan
## Scan Local Source
Send a local working tree to the managed white-box scanner without connecting a source-control provider:
```bash
# Review the exact file manifest and capture source.archive_sha256. Nothing is uploaded.
strix cloud scans start --source . --dry-run --show-files --json
SOURCE_SHA256="<reviewed source.archive_sha256>"
# Repeat the same source-selection flags and approve that exact snapshot.
strix cloud scans start --source . --approve-sha256 "$SOURCE_SHA256" --wait
```
In a Git repository, Strix includes tracked files and untracked files that are not ignored. Hidden files, `.git`, symlinks, dependencies and build output, secret-like filenames, and nested archives are excluded by default. Use `.strixignore` or repeat `--exclude GLOB` for project-specific exclusions. `--include-hidden`, `--include-sensitive`, and `--include-archives` are explicit opt-ins.
The CLI limits individual files, total expanded bytes, archive bytes, and file count. For an agent or CI handoff, repeat the same `--source`, `--exclude`, and `--include-*` flags with `--approve-sha256`; Strix refuses the upload if the rebuilt archive differs from the reviewed digest. `--yes` is a one-invocation approval for the snapshot built at that moment, not a digest-bound two-step approval.
The temporary local archive is always removed. After a definitive launch rejection, Strix also deletes the staged remote upload. If a network error, server error, or interruption makes the launch outcome ambiguous, it retains the upload and reports its ID; check `strix cloud scans list` before retrying, then delete an unlinked upload with `strix cloud uploads delete UPLOAD_ID`.
<Card title="Try Strix Cloud" icon="rocket" href="https://app.strix.ai">
Run your first pentest in minutes.
</Card>

3
docs/integrations/coding-agents.mdx
View file

@ -36,13 +36,14 @@ npx skills use usestrix/strix@penetration-testing-with-strix | claude
Both use the same engine and produce the same validated findings and SARIF, so agents can pick per situation or combine them:
- **Open-source CLI (self-hosted)** — runs locally in a Docker sandbox with your own LLM key. Free, fully local, air-gap capable. Best for local dev loops and full control.
- **Managed cloud** — runs on Strix's infrastructure via the [app.strix.ai REST API](https://docs.app.strix.ai). No Docker, no LLM key, no local install; adds team dashboards, scheduling, PR reviews, and downloadable PDF/DOCX reports (Enterprise plan). Best in sandboxed/CI environments and for teams. Create an API token under **Settings → API Access**; the `managed-pentesting-with-strix` skill has the full flow.
- **Managed cloud** — runs on Strix's infrastructure. Drive it with the `strix cloud` CLI (every REST operation has a `strix cloud <resource> <verb>` command) or the [app.strix.ai REST API](https://docs.app.strix.ai) directly. No Docker, no LLM key; adds team dashboards, scheduling, PR reviews, and downloadable PDF/DOCX reports (Enterprise plan). Best in sandboxed/CI environments and for teams. Sign in with `strix cloud login` (browser device sign-in, account created on first use) or create a token in the dashboard under **Settings → API Access**. The `managed-pentesting-with-strix` skill has the full flow.
## Agent-Friendly Interfaces
Everything an agent needs is machine-readable:
- **Headless CLI** — `strix -n` runs without the TUI and exits with `0` (clean), `1` (error), or `2` (vulnerabilities found).
- **Cloud CLI** — `strix cloud` prints JSON when stdout is not a terminal (or with `--json`), never prompts without a TTY, and exits with `0` (success), `1` (error), `2` (usage), `4` (authentication required), or `5` (payment required). Credit top-ups pay the Stripe machine-payment challenge with an agent wallet (`strix cloud billing topup --credits N --yes`). Account setup also runs from the CLI: `strix cloud workspaces list|create|use`, `strix cloud org members invite`, `strix cloud billing subscribe`, `strix cloud billing portal`, and `strix cloud integrations install github`. The last three print a hosted link the user opens to finish the payment or approve the installation.
- **REST API** — the managed platform exposes a documented [OpenAPI](https://docs.app.strix.ai/openapi.json) at `https://app.strix.ai/api/v1` (scans, vulnerabilities, assets, PR reviews, schedules, webhooks) with bearer tokens and scopes.
- **Structured results** — every run writes `vulnerabilities.json`, `vulnerabilities.csv`, `findings.sarif` (SARIF 2.1.0), and per-finding Markdown under `strix_runs/<run-name>/`; the cloud exposes the same as JSON plus SARIF export.
- **Budget controls** — `--max-budget` and `--max-turns` give agents hard cost/time caps.

1
pyproject.toml
View file

@ -230,6 +230,7 @@ ignore = [
# Test doubles use fixture tokens/passwords and match a callee signature whose
# args they intentionally ignore.
"tests/test_viewer_auth.py" = ["S105", "S106", "ARG001"]
"tests/test_cloud_cli.py" = ["S105", "ARG001"]
"tests/test_codex_auth.py" = ["S105", "S106", "SLF001"]
# Hatchling loads the build hook by path, not as an importable package.
"scripts/tui_sidecar_hook.py" = ["INP001"]

293
skills/managed-pentesting-with-strix/SKILL.md
View file

@ -1,23 +1,59 @@
---
name: managed-pentesting-with-strix
description: Run a managed pentest of a web app or API through the app.strix.ai REST API — no local Docker, LLM key, or install needed. Create an API token, register domain/repository assets, launch and poll scans, triage vulnerabilities, export SARIF, download PDF/DOCX pentest reports for SOC 2 and other compliance evidence (Enterprise plan), start PR reviews, and set up schedules and webhooks. Use when the user wants continuous or scheduled pentesting-as-a-service, an auditor-ready pentest report, scans tracked in a team dashboard, or security testing from a sandboxed agent/CI environment with no infrastructure.
description: Run a managed pentest of a web app, API, repository, or local workspace on the app.strix.ai platform with the `strix cloud` CLI or REST API — no local Docker or LLM key needed. Safely review and upload local source, register assets, launch and poll scans, triage vulnerabilities, export SARIF, download compliance reports, start PR reviews, buy credits, and set up schedules or webhooks. Use for managed, continuous, scheduled, team-tracked, or sandboxed-agent security testing.
license: Apache-2.0
metadata:
author: usestrix
homepage: https://docs.app.strix.ai
---
# Strix Cloud API (managed, no local infra)
# Strix Cloud (managed, no local infra)
Use this when you want Strix's autonomous pentesting **without running Docker or an LLM yourself** — the scan runs on Strix's infrastructure and results are tracked in a team dashboard. This is the right choice in sandboxed/hosted agent and CI environments, for teams, and for scheduled/continuous testing (downloadable PDF/DOCX reports are an Enterprise-plan feature). For fully local, free, air-gapped, or BYO-LLM runs, use the open-source CLI in the **penetration-testing-with-strix** skill instead — both share the same engine and SARIF output, so you can mix them.
Full reference: **[docs.app.strix.ai](https://docs.app.strix.ai)** · OpenAPI: `https://docs.app.strix.ai/openapi.json`
There are two equivalent interfaces. Prefer the CLI:
## Setup
- **`strix cloud` CLI** — every REST operation has a command in the form `strix cloud <resource> <verb>`. Install with `curl -sSL https://strix.ai/install | bash`. Run `strix cloud` to list all resources and `strix cloud <resource> help` (or `-h`) to list a resource's verbs; a bare resource with a safe read operation runs its documented default.
- **REST API** — base URL `https://app.strix.ai/api/v1`, `Authorization: Bearer <token>` on every request. Full reference: **[docs.app.strix.ai](https://docs.app.strix.ai)** · agent index: `https://docs.app.strix.ai/llms.txt` · OpenAPI: `https://docs.app.strix.ai/openapi.json`.
- **Base URL:** `https://app.strix.ai/api/v1`
- **Auth:** every request sends `Authorization: Bearer <token>`. Tokens are **org-scoped**.
- **Get a token:** the user creates one in the dashboard at **Settings → API Access** (app.strix.ai). Ask them for it; never hardcode, log, or commit it. Store it in an env var or the CI secret store.
The CLI is equally usable by agents and people. Output is complete JSON when stdout is not a terminal, or when you pass `--json`; terminal tables favor names, branches, lifecycle states, and numbered selectors. Human lists retain the selectors needed by follow-up commands but omit internal organization/user IDs; a selector too long for the compact table is repeated losslessly in a copyable block. Paginated lists print the next `--page` or `--offset`, and detail views preserve useful prose within a safe terminal bound; use `--json` for the complete record. Token lists label credentials as active, expired, or revoked. Binary downloads are the exception: redirect raw bytes intentionally, or use `--output FILE --json` to write the file and receive structured metadata. There are no interactive prompts when stdin is not a terminal. Exit codes: `0` success, `1` request/runtime error, `2` invalid usage, `4` authentication or plan limit, `5` payment required.
Every resource group with a safe read operation has a useful default action, and `-h` or `help` always shows its verbs. Native tab completion includes resources, verbs, flags, workspace commands, and local paths:
```bash
source <(strix completions zsh) # current zsh session
source <(strix completions bash) # current bash session
strix completions fish | source # current fish session
```
Write commands take request fields as flags. Every write command also accepts one JSON object with `--data`, which is the way to send fields that have no flag:
```bash
strix cloud scans start --data '{"engagement_type":"code_review"}' # literal JSON
strix cloud scans start --data @request.json # read a file
cat request.json | strix cloud scans start --data - # read standard input
```
The platform enforces plan and role limits, and the CLI passes the platform message through. Report downloads need the Enterprise plan. Schedules need the Pro plan. Billing writes need an admin token. A blocked command exits with code `4`.
## Setup: sign in
Run the device sign-in. It creates the user's account and workspace on first use and stores a personal API token in `~/.strix/platform-auth.json`:
```bash
strix cloud login
# Non-interactive least-privilege example:
strix cloud login --scopes scans:read scans:write uploads:write billing:read vulnerabilities:read assets:read assets:write
# Or use a stable named profile:
strix cloud login --scope-profile recommended
```
The user approves the sign-in in the browser. With `--scopes` (and optionally `--workspace <name-or-id>`) there are no terminal prompts, so the command works from a non-interactive agent shell. In an interactive terminal without flags, the CLI offers a workspace picker and scope presets (Recommended, Full access, Minimal, Custom). Recommended covers ordinary scans, source uploads, workspace switching, and user-approved credit top-ups; it excludes `tokens:write`, which must be requested explicitly when credential management is required. Use explicit scopes for a narrower automation token.
- `strix cloud whoami` is the fast local status. `strix cloud session --json` verifies the remote device session; `strix cloud session scopes` shows both effective access and the immutable login ceiling.
- `strix cloud logout` revokes the remote session before removing the local token. On a network or server failure it keeps the token so the user can retry; `--local-only` deliberately skips revocation.
- Every other `strix cloud` command uses the stored token automatically. `--token <token>` or `STRIX_API_TOKEN` is a stateless per-command override and never overwrites the stored account. For an override that is itself a CLI session, also pass `--workspace-id` or set `STRIX_WORKSPACE_ID`.
- Never hardcode, log, or commit the token. Store it in an env var or the CI secret store.
- **Scopes (least-privilege):** assign only what the integration needs and rotate regularly:
| Scope | Grants |
@ -28,15 +64,105 @@ Full reference: **[docs.app.strix.ai](https://docs.app.strix.ai)** · OpenAPI: `
| `schedules:read` / `:write` | read schedules · create/trigger recurring scans |
| `pr_reviews:write` | trigger PR security reviews |
| `webhooks:read` / `:write` | manage webhook subscriptions |
| `tokens:write` | create/revoke API tokens |
| `uploads:write` | upload local source or documents for a scan |
| `organizations:read` | read organization details (listing/switching the signed-in user's workspaces needs no API scope) |
| `organizations:write` | create/update workspaces (admin) |
| `tokens:write` | create/revoke ordinary API tokens (not needed to manage the current CLI session) |
| `knowledge:read` / `:write` | read/update organization knowledge |
| `audit:read` | read/export the Enterprise audit log |
| `billing:read` / `billing:write` | read credit balance & auto top-up settings · buy credits (admin) |
HTTP errors map to messages and exit codes: `401` bad/expired token (exit `4`), `402` out of credits (exit `5`), `403` scope/plan-tier limit (exit `4`), `422` validation error (exit `1`).
Create a time-limited automation token with `strix cloud tokens create`. Use
`--rbac-scopes` to restrict it to target IDs, tags, or business units; the value is a
JSON array of `{ "type": "target|tag|business_unit", "value": "..." }` objects:
```bash
export STRIX_API_TOKEN="<token>"
BASE=https://app.strix.ai/api/v1
auth=(-H "Authorization: Bearer $STRIX_API_TOKEN")
strix cloud tokens create --type service --name staging-ci \
--expires-at 2026-12-31T23:59:59Z \
--scopes scans:read scans:write \
--rbac-scopes '[{"type":"tag","value":"staging"}]'
```
All examples use `jq` to parse JSON. Handle HTTP errors: `401` bad/expired token, `402` out of credits, `403` scope/plan-tier limit, `422` validation error.
The token secret is returned once. Store it directly in a secret manager and do not
print or commit it. `--expires-at` and `--expires-in-days` are mutually exclusive.
## 0. Credits & top-ups
Non-Enterprise scans consume org credits. Enterprise engagements are plan-included and do not debit the wallet. Check the balance before a scan (`billing:read`):
```bash
strix cloud credits
```
When the balance is too low, buy credits with `strix cloud billing topup` (`billing:write`, admin token). The server answers the first request with **HTTP 402 and a machine-payment challenge** (Stripe Machine Payments Protocol). The CLI pays the challenge with the `mppx` client when Node.js is available — the user approves the spend in their agent wallet, for example the [Link Agent Wallet](https://link.com/agents). The response returns the receipt (`credits_granted`, `duplicate`, `reference`) and the new balance.
A default-tier source-only code review currently starts at 60 credits. Source uploads are not free: they launch an ordinary `code_review` and use the same deterministic scope estimator. The service checks the full balance before launch, reserves credits atomically only after validation succeeds, and does not create or charge a rejected scan. Retests and Enterprise scans are exempt.
```bash
strix cloud billing topup --credits 20 --yes # explicit approval; skips the TTY prompt
strix cloud billing topup --credits 20 --no-pay # print the 402 challenge without paying
```
The default payment path is the Stripe agent wallet. Tell the user to set it up one time at [link.com/agents](https://link.com/agents). After setup, the user approves each payment in the Link app, and no keys or variables are necessary.
In a non-interactive agent or CI process, payment never proceeds unless the command includes `--yes`. Show the challenge or estimated spend to the user and obtain approval before adding it. `--no-pay` always stops after printing the challenge.
If the user does not want a wallet, create a hosted checkout link with `strix cloud billing subscribe --plan strix_top_up` and give the link to the user. The user pays in the browser.
Automatic top-ups (admin): `strix cloud billing auto-topup` shows the setting. Enable it with:
```bash
strix cloud billing auto-topup update --enabled --topup-credits 20 --monthly-cap-credits 200
```
An omitted `--monthly-cap-credits` keeps the stored cap. Pass `--no-monthly-cap` to remove the cap.
### Workspaces and account setup
Manage workspaces with a personal token from `strix cloud login`:
```bash
strix cloud workspaces list # numbered name/role/current list
strix cloud workspaces create --name "My Team" # admin + organizations:write
strix cloud workspaces use 2 # displayed number, exact name, or ID
strix cloud workspace use "My Team" # singular `workspace` alias also works
strix cloud session scopes # effective scopes + consent ceiling
strix cloud session scopes set minimal # narrow the session
strix cloud org members invite --email dev@example.com --role analyst
```
`workspaces use` retargets the current personal token to a workspace the user already belongs to and stores the updated workspace metadata; the bearer secret and expiry stay unchanged. It does not reprompt during ordinary switches: the server preserves the chosen profile, enforces the immutable login ceiling, and caps effective scopes by the target role. Use `--scope-profile` or `--scopes` to narrow within that ceiling; broader consent requires `strix cloud login` again. The CLI pins each process to the workspace it started in, so concurrent shells fail with a recoverable conflict instead of silently crossing organizations.
### Handoffs a person must finish
Four steps end at the user. The command creates the link or the record and prints it. Strix opens the browser only in an interactive terminal. Pass `--no-browser` to print the URL only.
```bash
strix cloud billing subscribe --plan strix_cloud # hosted checkout page for the Cloud plan
strix cloud billing portal # billing portal for the card and the plan
strix cloud integrations install github # GitHub App or Slack installation page
strix cloud domains verify <domain-id> # DNS record to add, then run it again
```
Give the printed URL or DNS record to the user and wait. Do not claim that the payment, the installation, or the DNS change is complete. Confirm the result afterwards with `strix cloud credits`, `strix cloud integrations list`, or `strix cloud domains list`. All four commands need an admin token, except `domains verify`, which needs `assets:write`.
### Organization knowledge
Agents can manage the organization knowledge base without the dashboard (`knowledge:read` / `knowledge:write`):
```bash
strix cloud knowledge list --search authentication
strix cloud knowledge add --title "Authentication" --content "Staging uses SSO."
strix cloud knowledge update <document-id> --content "Staging uses SSO and TOTP."
strix cloud knowledge delete <document-id>
strix cloud knowledge policies add --key staging-only --content "Never test production."
strix cloud knowledge policies delete staging-only
strix cloud knowledge repos entries usestrix/strix
```
Knowledge policy writes require an admin token. Repository names are passed as normal `owner/name` values; the CLI handles URL encoding. The `costs` and `llm-settings` commands target on-prem installations and return `404` on app.strix.ai.
## 1. Register the target as an asset
@ -44,109 +170,152 @@ Scans run against **registered assets**, not raw URLs. Register once, then reuse
```bash
# Domain (black-box / live target). Requires domain verification before external scanning.
# asset_type must be one of: web_app | api | attack_surface.
curl -sS "$BASE/domains" "${auth[@]}" -H "Content-Type: application/json" \
-d '{"domain":"staging.example.com","asset_type":"web_app"}' | jq '{id:.domain.id, status, reachable, verification}'
# --asset-type must be one of: web_app | api | attack_surface.
strix cloud domains add --domain staging.example.com --asset-type web_app
# Repository (white-box / code review). `full_name` is "owner/name".
# Send one repository object, or a bare JSON array for several — not an object
# wrapping a "repositories" key (that is rejected with 400).
curl -sS "$BASE/repositories" "${auth[@]}" -H "Content-Type: application/json" \
-d '[{"full_name":"org/app","provider":"github"}]' | jq '.repositories[] | {id, full_name}'
strix cloud repos add --data '{"full_name":"org/app","provider":"github"}'
```
Look up existing assets instead of re-adding: `GET /domains`, `GET /repositories` (both `assets:read`, paginated with `?page=&limit=`).
Look up existing assets instead of re-adding: `strix cloud domains list`, `strix cloud repos list` (both `assets:read`).
## 2. Launch a scan
`POST /scans` (`scans:write`). Provide at least one target via `domain_ids`, `repository_ids`, or `internal_targets` (internal infra needs a network connector — see docs).
`strix cloud scans start` (`scans:write`). Provide at least one target with `--domain-ids`, `--repository-ids`, or `--internal-targets` (internal infra needs a network connector — see docs).
```bash
scan_id=$(curl -sS "$BASE/scans" "${auth[@]}" -H "Content-Type: application/json" -d '{
"engagement_type": "live_test",
"domain_ids": ["<domain-uuid>"],
"focus": "IDOR, auth bypass, SSRF",
"context": "Staging. Test account creds are configured as a test user.",
"notify_on_completion": true
}' | jq -r .scan_id)
echo "$scan_id"
strix cloud scans start \
--engagement-type live_test \
--domain-ids <domain-uuid> \
--focus "IDOR, auth bypass, SSRF" \
--context "Staging. Test account creds are configured as a test user." \
--notify-on-completion
```
Useful `CreateScanRequest` fields:
Useful flags (each maps to a `CreateScanRequest` field):
| Field | Purpose |
| Flag | Purpose |
|---|---|
| `engagement_type` | `live_test` (default), `code_review`, `internal_infra`, `compliance_pentest` |
| `domain_ids` / `repository_ids` / `internal_targets` | targets (at least one) |
| `domain_paths` / `repository_branches` | narrow to specific paths / branches |
| `credentials` | authenticated scanning, incl. `mfa_method` (`totp`/`email_otp`/…) + `totp_secret` |
| `headers` | extra HTTP headers (API keys, for example) for the target |
| `focus` / `concerns` / `context` | steer the agents |
| `upload_ids` | attach uploaded source/docs archives for white-box context |
| `notify_on_completion` / `notification_emails` | email when done |
| `--engagement-type` | `live_test` (default), `code_review`, `internal_infra`, `compliance_pentest` |
| `--domain-ids` / `--repository-ids` / `--internal-targets` | targets (at least one) |
| `--domain-paths` / `--repository-branches` | narrow to specific paths / branches (JSON maps) |
| `--credentials` | authenticated scanning, incl. `mfa_method` (`totp`/`email_otp`/…) + `totp_secret` (JSON list) |
| `--headers` | extra target HTTP headers as a JSON array of header objects |
| `--focus` / `--concerns` / `--context` | free-form strings that steer the agents |
| `--upload-ids` | attach uploaded source/docs archives for white-box context |
| `--notify-on-completion` / `--notification-emails` | email when done |
Response is `{ scan_id, title, status }` with `status` = `pending`.
Without `--source`, the response is `{ scan_id, title, status }` with `status` = `pending`.
Local-source success wraps that platform response as
`{ source, upload_id, scan: { scan_id, title, status } }`, so automation can retain the exact
approved manifest and staged-upload identifier alongside the created scan.
## 3. Poll to completion
### Scan a local workspace in the cloud
`GET /scans/{scanId}` (`scans:read`). Status flow: `pending → running → completed` (or `failed` / `cancelled`). Poll on an interval — scans take minutes to hours. Do not block.
For an agent or CI workflow, bind approval to the exact source snapshot that was reviewed. Run
the dry run with the intended source-selection flags, review the manifest and selected paths,
and capture `source.archive_sha256`. Then repeat the same `--source`, every `--exclude`, and
any `--include-hidden`, `--include-sensitive`, or `--include-archives` flags with
`--approve-sha256`:
```bash
while :; do
s=$(curl -sS "$BASE/scans/$scan_id" "${auth[@]}" | jq -r .status)
echo "status=$s"; [[ "$s" =~ ^(completed|failed|cancelled)$ ]] && break
sleep 60
done
strix cloud scans start --source . --exclude 'private/' --dry-run --show-files --json
# After reviewing the output, capture its source.archive_sha256 value:
SOURCE_SHA256="<reviewed source.archive_sha256>"
# Repeat every source-selection flag unchanged; a source-only scan infers code_review.
strix cloud scans start --source . --exclude 'private/' \
--approve-sha256 "$SOURCE_SHA256" --wait
```
The CLI rebuilds the archive and refuses the upload if its SHA-256 no longer matches. `--yes`
has deliberately narrower semantics: it approves only the snapshot built during that one
invocation. Use it for a deliberate human or one-shot approval, not as the second half of a
digest-bound agent/CI review. Without a TTY, a source upload requires either matching
`--approve-sha256` approval or `--yes`; an interactive terminal can instead show the summary,
the selected filenames when `--show-files` is set, and a `[y/N]` confirmation for its current
snapshot.
The default selection is privacy-conscious: in a Git worktree it includes tracked files plus untracked files that are not ignored; it honors `.gitignore`, excludes every hidden path component, always excludes `.git`, symlinks, dependencies/build output, secret-like filenames, and nested archives. Add project exclusions to `.strixignore` (one exclude glob per line) or repeat `--exclude GLOB`; a trailing slash such as `private/` excludes that directory subtree.
The client refuses more than 20,000 files, a file over 25 MiB, more than 250 MiB expanded, or a ZIP over 50 MiB. The service then stream-inflates the ZIP and independently rejects malformed or unsupported entries, unsafe paths, too many entries, oversized entries, excessive expanded data, and oversized compressed input, so an untrusted client cannot bypass the ZIP-bomb controls by forging metadata.
Only use `--include-hidden`, `--include-sensitive`, or `--include-archives` after the dry-run manifest shows that the scan needs them. Hidden and sensitive files are separate opt-ins: for example, including `.env` requires both `--include-hidden` and `--include-sensitive`.
The CLI removes its private temporary local archive after every invocation. Once a remote
upload is staged, a definitive scan rejection causes the CLI to delete it. A network failure,
`5xx` response, malformed success response, or interruption after scan launch begins is
ambiguous—the platform may have accepted the scan—so the CLI retains the upload and returns
its `upload_id` with `launch_outcome_unknown: true`. If an automatic deletion attempt cannot
be confirmed, it instead returns the retained `upload_id` with `cleanup_unknown: true`.
Before retrying, run `strix cloud scans list` to avoid a duplicate scan or charge. If no scan
is linked to the retained upload, remove it with `strix cloud uploads delete UPLOAD_ID`;
linked uploads cannot be deleted.
With no explicit type, source alone infers `code_review`. Any domain target wins and infers `live_test`, so source plus a deployed domain is the normal white-box live-test workflow. Pass `--engagement-type` when you need to override the inference.
## 3. Wait for completion
Pass `--wait` to `scans start` to poll until the scan reaches a final state, or poll yourself with `strix cloud scans get <scan-id>` (`scans:read`). Bound automation with `--wait-timeout SECONDS`; timeout exits cleanly without cancelling the remote scan. Status flow: `pending → running → completed` (or `failed` / `cancelled`). Scans take minutes to hours — poll on an interval, do not block indefinitely.
## 4. Read findings
The scan-detail response includes `executive_summary`, `methodology`, `recommendations`, a `findings` severity roll-up, and a `vulnerabilities[]` array. Each vulnerability carries `title, severity, status, cvss, cwe, endpoint, method, impact, technical_analysis, poc_description, poc_script_code`, and (for code findings) `code_file`/`code_diff`/`code_before`/`code_after`.
```bash
curl -sS "$BASE/scans/$scan_id" "${auth[@]}" \
strix cloud scans get <scan-id> --json \
| jq '["critical","high","medium","low","info"] as $order
| .vulnerabilities
| sort_by(.severity as $s | $order | index($s))
| .[] | {title, severity, endpoint, cwe}'
```
Cloud severities are `critical | high | medium | low` and statuses are `open | in_progress | fixed | ignored`. Sort by an explicit severity order rather than `sort_by(.severity)`, which sorts alphabetically (critical, high, low, medium).
Cloud severities are `critical | high | medium | low` and statuses are `open | in_progress | snoozed | fixed | ignored | not_affected`. Sort by an explicit severity order rather than `sort_by(.severity)`, which sorts alphabetically (critical, high, low, medium).
Org-wide triage across scans: `GET /vulnerabilities` (`vulnerabilities:read`; filter by severity/status). Update triage state with the vulnerabilities `:write` endpoints. To remediate, hand off to the **fix-security-vulnerabilities-with-strix** skill.
Org-wide triage across scans: `strix cloud vulns list --severity critical` (`vulnerabilities:read`, and it also filters by `--status`, `--scan-id`, and more). Update triage state with `strix cloud vulns update <id> --status fixed`. To remediate, hand off to the **fix-security-vulnerabilities-with-strix** skill.
## 5. Export & report
```bash
# SARIF 2.1.0 for GitHub code scanning / ASPM ingestion
curl -sS "$BASE/scans/$scan_id/sarif" "${auth[@]}" -o findings.sarif
strix cloud scans sarif <scan-id> --output findings.sarif
# Report. The format and file type are query params (`Accept` is ignored):
# format=technical (default) | retest | attestation | executive_summary
# type=pdf (default) | docx
# Any report download requires the Enterprise plan; formats beyond `technical`,
# Report. Formats: technical (default) | retest | attestation | executive_summary
# Types: pdf (default) | docx
# Any report download requires the Enterprise plan. Formats beyond `technical`,
# DOCX, and white-label branding are Enterprise-only too. Scan must be completed.
curl -sS "$BASE/scans/$scan_id/report?format=technical&type=pdf" "${auth[@]}" -o strix-report.pdf
strix cloud scans report <scan-id> --format technical --type pdf --output strix-report.pdf
```
Downloads refuse to replace a file unless `--force` is explicit. Enterprise audit logs can be streamed as JSON or exported without trying to JSON-decode the body:
```bash
strix cloud audit list --format csv --all --output audit.csv
strix cloud audit list --format ndjson --all --output audit.ndjson
```
## 6. PR reviews
Trigger an automated security review of a pull request (`pr_reviews:write`); results appear as PR comments and in the dashboard:
Trigger an automated security review of a pull request (`pr_reviews:write`). Read the repository's `provider` and `installation_id` with `strix cloud repos list`; both identify the installed source-control integration. The results appear as PR comments and in the dashboard:
```bash
curl -sS "$BASE/pr-reviews/start" "${auth[@]}" -H "Content-Type: application/json" \
-d '{"repository_full_name":"org/app","pr_number":123}'
strix cloud pr-reviews start \
--provider github \
--installation-id <installation-id> \
--repository-full-name org/app \
--pr-number 123
```
List/inspect via `GET /pr-reviews` and `GET /pr-reviews/{id}`. Repo-level PR-review behavior is configured with the repository-settings endpoint.
List/inspect with `strix cloud pr-reviews list` and `strix cloud pr-reviews get <id>`. Repo-level PR-review behavior is configured with `strix cloud pr-reviews settings`.
## 7. Continuous testing (schedules & webhooks)
- **Schedules** (`schedules:write`, Pro plan): create recurring scans and trigger them on demand — the managed equivalent of a cron-driven CLI loop.
- **Webhooks** (`webhooks:write`): subscribe to pentest/vulnerability lifecycle events such as `scan.completed` and `vulnerability.created` to push results into Slack, ticketing, or your own pipeline instead of polling.
- **Schedules** (`schedules:write`, Pro plan): `strix cloud schedules create` makes recurring scans, and `strix cloud schedules trigger <id>` runs one on demand — the managed equivalent of a cron-driven CLI loop.
- **Webhooks** (`webhooks:write`): `strix cloud webhooks create` subscribes to pentest/vulnerability lifecycle events such as `scan.completed` and `vulnerability.created` to push results into Slack, ticketing, or your own pipeline instead of polling.
See the schedules and webhooks sections at [docs.app.strix.ai](https://docs.app.strix.ai) for payloads.
Network connectors are Enterprise-only. `strix cloud connectors create` may return a one-time enrollment command containing credentials; do not paste it into logs, and request it with `--include-command` only when the user is ready to install it. Browser checkout, source-control installation, DNS verification, connector installation, chat sharing, and publishing SARIF to an external provider are user handoffs or explicit external mutations—prepare the command/link, then obtain the appropriate approval before completing them.
## Safety
Only scan assets the user's organization owns or is authorized to test. External domain scans require verification (DNS/file/meta-tag) enforced by the platform — do not try to bypass it.

169
strix/interface/cloud/__init__.py Normal file
View file

@ -0,0 +1,169 @@
"""`strix cloud` — the managed Strix platform (app.strix.ai) from the terminal.
Every command maps to one operation of the public REST API. Output is JSON
when stdout is not a terminal, so agents can parse every result. Exit codes:
0 success, 1 error, 2 invalid usage, 4 authentication required, 5 payment
required.
"""
from __future__ import annotations
import json
import sys
from rich.console import Console
from rich.markup import escape
import strix.interface.cloud.http as http # noqa: PLR0402
from strix.interface.cloud.render import json_mode
from strix.interface.cloud.runner import resolve, run
from strix.interface.cloud.session import run_session
from strix.interface.cloud.spec import DEFAULT_VERBS, GROUP_HELP, SPEC
from strix.interface.cloud.workspaces import run_workspace_use
from strix.interface.platform_cli import run_login
from strix.interface.terminal_text import sanitize_terminal_text
_USAGE_HEADER = """[bold]Usage:[/] strix cloud <command> [arguments]
[bold]Session commands:[/]
login Sign in to the managed platform and store an API token
logout Remove the stored API token
whoami Show the stored account, workspace, and token state
session Inspect or narrow the remote CLI session
credits Show the credit balance of the workspace
[bold]Resource commands:[/]"""
_USAGE_FOOTER = """
Run [bold]strix cloud <command> help[/] to list its verbs. Common read-only
commands may also run their default verb when no verb is given.
Every REST resource command accepts [bold]--json[/] and [bold]--token[/]. Write
commands accept [bold]--data[/] with a JSON object of extra request fields.
Login is an interactive device flow; [bold]whoami[/] and [bold]logout[/] also
produce JSON automatically when output is redirected.
API reference: https://docs.app.strix.ai"""
_HELP_TOKENS = frozenset({"-h", "--help", "help"})
def _is_help_request(argv: list[str]) -> bool:
"""Recognize a help token with an optional JSON-output flag in either order."""
return sum(argument in _HELP_TOKENS for argument in argv) == 1 and all(
argument in _HELP_TOKENS or argument == "--json" for argument in argv
)
def run_cloud(argv: list[str]) -> int:
"""Run a managed-cloud command without ever leaking a Ctrl-C traceback."""
try:
return _run_cloud(argv)
except KeyboardInterrupt:
if json_mode(flag="--json" in argv):
sys.stdout.write(json.dumps({"error": "Interrupted.", "interrupted": True}) + "\n")
else:
Console(stderr=True).print("[yellow]Interrupted.[/]")
return 130
def _run_cloud(argv: list[str]) -> int: # noqa: PLR0911, PLR0912
"""Entry point for ``strix cloud …``. Returns a process exit code."""
console = Console()
as_json = json_mode(flag="--json" in argv)
if not argv or _is_help_request(argv):
if as_json:
_print_usage_json()
else:
_print_usage(console)
return 0
if argv == ["--json"]:
_print_usage_json()
return 0
group, rest = argv[0], argv[1:]
if group == "workspace":
group = "workspaces"
if group in ("login", "logout", "whoami"):
return _run_session(console, group, rest)
if group == "session":
return run_session(rest)
if group == "credits":
group, rest = "billing", ["credits", *rest]
if group == "workspaces" and rest and rest[0] == "use":
try:
return run_workspace_use(rest[1:])
except http.CloudError as exc:
if "--json" in rest:
sys.stdout.write(json.dumps({"error": str(exc)}) + "\n")
else:
console.print(f"[red]Error:[/] {escape(sanitize_terminal_text(exc))}")
return exc.exit_code
if group not in SPEC:
if as_json:
sys.stdout.write(json.dumps({"error": f"unknown command: {group}"}) + "\n")
return 2
console.print(f"[red]Unknown command:[/] {escape(sanitize_terminal_text(group))}")
_print_usage(console)
return 2
group_help = _is_help_request(rest)
resolved = None if group_help else resolve(group, rest)
if resolved is None:
help_tokens: set[str] = set(_HELP_TOKENS) if group_help else set()
invalid = [arg for arg in rest if arg != "--json" and arg not in help_tokens]
_print_verbs(console, group, as_json=as_json, error="unknown verb" if invalid else None)
return 2 if invalid else 0
cmd, remaining = resolved
verb_label = " ".join(rest[: len(rest) - len(remaining)]) or DEFAULT_VERBS.get(group, "")
return run(group, verb_label, cmd, remaining)
def _run_session(_console: Console, group: str, rest: list[str]) -> int:
if rest and rest[0] == "help":
rest = ["--help", *rest[1:]]
session_argv = {
"login": rest,
"logout": ["logout", *rest],
"whoami": ["status", *rest],
}
return run_login(session_argv[group])
def _print_usage(console: Console) -> None:
console.print(_USAGE_HEADER)
for group in SPEC:
console.print(f" {group:<14}{GROUP_HELP.get(group, '')}")
console.print(_USAGE_FOOTER)
def _print_verbs(
console: Console, group: str, *, as_json: bool = False, error: str | None = None
) -> None:
if as_json:
verbs: list[dict[str, str]] = [
{"name": verb, "help": command.help} for verb, command in SPEC[group].items()
]
if group == "workspaces":
verbs.append({"name": "use", "help": "Switch the stored token to another workspace."})
payload: dict[str, object] = {
"command": f"strix cloud {group}",
"verbs": verbs,
}
if error:
payload["error"] = error
sys.stdout.write(json.dumps(payload, indent=2) + "\n")
return
console.print(f"[bold]strix cloud {group}[/] verbs:")
for verb, cmd in SPEC[group].items():
console.print(f" {verb:<28}{cmd.help}")
if group == "workspaces":
console.print(f" {'use':<28}Switch the stored token to another workspace.")
def _print_usage_json() -> None:
payload = {
"command": "strix cloud",
"session_commands": ["login", "logout", "whoami", "session", "credits"],
"resource_commands": [{"name": group, "help": GROUP_HELP.get(group, "")} for group in SPEC],
}
sys.stdout.write(json.dumps(payload, indent=2) + "\n")

18
strix/interface/cloud/arguments.py Normal file
View file

@ -0,0 +1,18 @@
"""Argument parsing that reports managed-cloud usage errors through one contract."""
from __future__ import annotations
import argparse
from typing import NoReturn
import strix.interface.cloud.http as http # noqa: PLR0402
class CloudArgumentParser(argparse.ArgumentParser):
"""Raise a typed usage error instead of printing argparse prose and exiting."""
def error(self, message: str) -> NoReturn:
raise http.CloudError(
f"invalid arguments for {self.prog}: {message}",
exit_code=http.EXIT_USAGE,
)

374
strix/interface/cloud/billing.py Normal file
View file

@ -0,0 +1,374 @@
"""Billing top-up and agent-wallet execution for ``strix cloud``."""
from __future__ import annotations
import json
import os
import re
import shutil
import subprocess
import sys
import tempfile
from dataclasses import dataclass
from pathlib import Path
from typing import TYPE_CHECKING, Any, cast
import strix.interface.cloud.http as http # noqa: PLR0402
from strix.interface.cloud.payment_proxy import WalletUpstreamResponse, wallet_payment_bridge
from strix.interface.cloud.render import emit
from strix.interface.terminal_text import sanitize_terminal_text
if TYPE_CHECKING:
import argparse
from rich.console import Console
_MAX_WALLET_DETAIL_CHARS = 2_000
# Keep the wallet client on the exact protocol implementation used by the
# platform. This version is also old enough to remain installable in npm
# environments that apply a short package-publication safety window.
_MPPX_PACKAGE = "mppx@0.8.17"
_NPM_REGISTRY = "https://registry.npmjs.org"
_WALLET_ENV_NAMES = frozenset(
{
"ALL_PROXY",
"APPDATA",
"COLORTERM",
"COMSPEC",
"FORCE_COLOR",
"HOME",
"HTTPS_PROXY",
"HTTP_PROXY",
"LANG",
"LC_ALL",
"LC_CTYPE",
"LOCALAPPDATA",
"NO_COLOR",
"NO_PROXY",
"PATH",
"PATHEXT",
"SSL_CERT_DIR",
"SSL_CERT_FILE",
"SYSTEMROOT",
"TEMP",
"TERM",
"TMP",
"TMPDIR",
"USERPROFILE",
"XDG_CONFIG_HOME",
"all_proxy",
"http_proxy",
"https_proxy",
"no_proxy",
}
)
_AUTHORIZATION_SECRET = re.compile(r"(?i)((?:bearer|payment)\s+)[^\s\"']+")
_LOOPBACK_NO_PROXY = ("127.0.0.1", "localhost", "::1")
@dataclass(frozen=True)
class _WalletClientResult:
process: subprocess.CompletedProcess[str]
upstream_responses: tuple[WalletUpstreamResponse, ...]
def run_topup( # noqa: PLR0911, PLR0912
console: Console,
args: argparse.Namespace,
body: dict[str, Any],
*,
as_json: bool,
token: str | None,
) -> int:
"""Handle the HTTP 402 challenge and optional agent-wallet payment."""
response = http.request("POST", "/billing/topup", token=token, body=body)
if response.status_code != 402:
emit(console, http.check(response), as_json=as_json)
return http.EXIT_OK
challenge = http.parsed(response)
if getattr(args, "no_pay", False):
emit(
console,
{"error": "Payment required", "challenge": challenge},
as_json=as_json,
)
return http.EXIT_PAYMENT
credit_count = body.get("credits")
if not getattr(args, "yes", False):
if as_json or not (sys.stdin.isatty() and sys.stdout.isatty()):
emit(
console,
{
"error": (
"Payment requires explicit approval in non-interactive mode. "
"Review the challenge, then re-run with --yes to authorize payment."
),
"challenge": challenge,
},
as_json=as_json,
)
return http.EXIT_PAYMENT
answer = console.input(f"Buy {credit_count} credit(s) now? [y/N]: ").strip().lower()
if answer not in ("y", "yes"):
console.print("[yellow]Payment cancelled.[/]")
return http.EXIT_PAYMENT
npx = shutil.which("npx")
if npx is None:
message = (
"Payment requires a wallet client. Install Node.js and run the command again, "
"or pay the challenge with an MPP wallet client."
)
if as_json:
emit(
console,
{"error": message, "challenge": challenge},
as_json=True,
)
else:
emit(console, challenge, as_json=False)
console.print(f"[yellow]Payment required.[/] {message}")
return http.EXIT_PAYMENT
payment_method = getattr(args, "payment_method", None) or os.environ.get(
"MPPX_STRIPE_PAYMENT_METHOD"
)
if not payment_method and (
not as_json
and not os.environ.get("MPPX_ACCOUNT")
and not os.environ.get("MPPX_STRIPE_SECRET_KEY")
):
console.print(
"[dim]Tip: payments need a wallet. Set up a Stripe agent wallet at "
"https://link.com/agents, and the user approves each payment in the Link app. "
"If the user does not want a wallet, run "
"`strix cloud billing subscribe --plan strix_top_up` for a hosted checkout link.[/]"
)
try:
wallet_result = _run_wallet_client(
npx,
args,
body,
token=token,
payment_method=payment_method,
capture_output=as_json,
)
except KeyboardInterrupt:
emit(
console,
{
"error": (
"Payment was interrupted after the wallet started. The outcome is unknown; "
"run `strix cloud billing credits` and check the balance before retrying."
),
"interrupted": True,
"payment_outcome_unknown": True,
},
as_json=as_json,
)
return 130
except OSError:
emit(
console,
{
"error": "Could not start the wallet client securely.",
"challenge": challenge,
},
as_json=as_json,
)
return http.EXIT_PAYMENT
result = wallet_result.process
confirmed_receipt = _confirmed_topup_receipt(wallet_result.upstream_responses)
if confirmed_receipt is not None:
if as_json:
emit(console, confirmed_receipt, as_json=True)
return http.EXIT_OK
if not as_json:
console.print(
"[yellow]The wallet exited without a confirmed receipt. The payment outcome is "
"unknown; run `strix cloud billing credits` before retrying.[/]"
)
return http.EXIT_PAYMENT
stdout = str(getattr(result, "stdout", "") or "").strip()
stderr = str(getattr(result, "stderr", "") or "").strip()
if result.returncode == 0:
try:
receipt = json.loads(stdout)
except (TypeError, ValueError):
emit(
console,
{
"error": (
"The wallet reported success but did not return JSON. Check the credit "
"balance before retrying payment."
),
"detail": _wallet_detail(stdout or stderr or "No wallet output was returned."),
"payment_outcome_unknown": True,
},
as_json=True,
)
return http.EXIT_PAYMENT
if not _valid_topup_receipt(receipt):
emit(
console,
{
"error": (
"The wallet returned an invalid top-up receipt. Check the credit balance "
"before retrying payment."
),
"detail": _wallet_detail(stdout),
"payment_outcome_unknown": True,
},
as_json=True,
)
return http.EXIT_PAYMENT
emit(
console,
{
"error": (
"The wallet returned a receipt, but the Strix billing endpoint did not "
"confirm it. Check the credit balance before retrying payment."
),
"detail": _wallet_detail(stdout),
"payment_outcome_unknown": True,
},
as_json=True,
)
return http.EXIT_PAYMENT
emit(
console,
{
"error": (
"The wallet exited without a confirmed receipt. The payment outcome is unknown; "
"run `strix cloud billing credits` and check the balance before retrying."
),
"detail": _wallet_detail(
stderr or stdout or f"Wallet client exited with status {result.returncode}."
),
"wallet_exit_code": result.returncode,
"payment_outcome_unknown": True,
},
as_json=True,
)
return http.EXIT_PAYMENT
def _run_wallet_client(
npx: str,
args: argparse.Namespace,
body: dict[str, Any],
*,
token: str | None,
payment_method: str | None,
capture_output: bool,
) -> _WalletClientResult:
"""Run mppx through the loopback bridge without exposing the API token to it."""
upstream_url = f"{http.app_url()}/api/v1/billing/topup"
body_json = json.dumps(body)
wallet_env = _wallet_environment()
upstream_responses: list[WalletUpstreamResponse] = []
with tempfile.TemporaryDirectory(prefix="strix-wallet-") as wallet_cwd:
wallet_root = Path(wallet_cwd)
user_config = wallet_root / "user.npmrc"
global_config = wallet_root / "global.npmrc"
user_config.touch(mode=0o600)
global_config.touch(mode=0o600)
with wallet_payment_bridge(
upstream_url=upstream_url,
api_token=http.api_token(token),
expected_body=body_json.encode(),
timeout=getattr(args, "timeout", None),
response_observer=upstream_responses.append,
) as wallet_url:
command = [
npx,
"--yes",
f"--registry={_NPM_REGISTRY}",
"--ignore-scripts",
f"--userconfig={user_config}",
f"--globalconfig={global_config}",
f"--cache={wallet_root / 'npm-cache'}",
_MPPX_PACKAGE,
wallet_url,
"--fail",
"-J",
body_json,
]
if payment_method:
command += ["-M", f"paymentMethod={payment_method}"]
process = subprocess.run( # noqa: S603
command,
check=False,
capture_output=capture_output,
text=True,
env=wallet_env,
cwd=wallet_root,
)
return _WalletClientResult(process=process, upstream_responses=tuple(upstream_responses))
def _wallet_environment() -> dict[str, str]:
"""Pass only platform essentials and explicit wallet variables to npm/mppx."""
environment = {
name: value
for name, value in os.environ.items()
if name in _WALLET_ENV_NAMES or name.startswith("MPPX_")
}
for name in ("NO_PROXY", "no_proxy"):
entries = [entry.strip() for entry in environment.get(name, "").split(",") if entry.strip()]
normalized = {entry.lower().strip("[]") for entry in entries}
entries.extend(host for host in _LOOPBACK_NO_PROXY if host not in normalized)
environment[name] = ",".join(entries)
return environment
def _wallet_detail(value: str) -> str:
"""Bound and redact third-party wallet diagnostics before returning JSON."""
redacted = _AUTHORIZATION_SECRET.sub(r"\1[redacted]", sanitize_terminal_text(value))
if len(redacted) <= _MAX_WALLET_DETAIL_CHARS:
return redacted
return redacted[: _MAX_WALLET_DETAIL_CHARS - 1] + "…"
def _valid_topup_receipt(value: Any) -> bool:
"""Require the documented success shape before reporting a paid top-up."""
if not isinstance(value, dict):
return False
fields = cast("dict[str, Any]", value)
credits_granted = fields.get("credits_granted")
balance = fields.get("balance")
return (
isinstance(credits_granted, int)
and not isinstance(credits_granted, bool)
and credits_granted >= 0
and isinstance(fields.get("duplicate"), bool)
and isinstance(fields.get("reference"), str)
and bool(fields["reference"])
and isinstance(balance, int)
and not isinstance(balance, bool)
and balance >= 0
)
def _confirmed_topup_receipt(
responses: tuple[WalletUpstreamResponse, ...],
) -> dict[str, Any] | None:
"""Return a receipt only when the trusted bridge observed its successful response."""
for response in reversed(responses):
if not 200 <= response.status_code < 300:
continue
try:
receipt = json.loads(response.body)
except (TypeError, ValueError):
continue
if _valid_topup_receipt(receipt):
return cast("dict[str, Any]", receipt)
return None

361
strix/interface/cloud/http.py Normal file
View file

@ -0,0 +1,361 @@
"""HTTP client for the managed Strix platform API (app.strix.ai)."""
from __future__ import annotations
import ipaddress
import math
import os
import re
from typing import TYPE_CHECKING, Any, cast
from urllib.parse import SplitResult, urlsplit
import requests
from strix.config import load_settings
from strix.interface.platform_cli import read_record
if TYPE_CHECKING:
from pathlib import Path
_DEFAULT_TIMEOUT_S = 120
_SUPABASE_STORAGE_HOST = re.compile(r"^[a-z0-9-]+\.supabase\.co$")
_STORAGE_PATH_PREFIX = "/storage/v1/"
_app_url_override: str | None = None
_token_override_active = False
_workspace_id_override: str | None = None
_timeout_s: float = _DEFAULT_TIMEOUT_S
EXIT_OK = 0
EXIT_ERROR = 1
EXIT_USAGE = 2
EXIT_AUTH = 4
EXIT_PAYMENT = 5
class CloudError(Exception):
"""A failed cloud command. Carries the process exit code."""
def __init__(self, message: str, *, exit_code: int = EXIT_ERROR, payload: Any = None) -> None:
super().__init__(message)
self.exit_code = exit_code
self.payload = payload
class CloudTransportError(CloudError):
"""A request may have reached the platform, but no response was received."""
def configure(
*,
base_url: str | None = None,
timeout: float | None = None,
token_override: bool = False,
workspace_id: str | None = None,
) -> None:
"""Set the platform URL and the request timeout for this process."""
global _app_url_override, _timeout_s, _token_override_active # noqa: PLW0603
global _workspace_id_override # noqa: PLW0603
_app_url_override = base_url.rstrip("/") if base_url else None
_token_override_active = token_override
explicit_workspace = workspace_id or os.environ.get("STRIX_WORKSPACE_ID")
if explicit_workspace:
_workspace_id_override = explicit_workspace.strip()
elif not token_override and not os.environ.get("STRIX_API_TOKEN"):
record = read_record()
stored_workspace = record.get("organization_id") if record is not None else None
_workspace_id_override = (
stored_workspace.strip()
if isinstance(stored_workspace, str) and stored_workspace.strip()
else None
)
else:
_workspace_id_override = None
if timeout is not None:
if not math.isfinite(timeout) or timeout <= 0:
raise CloudError(
"request timeout must be a finite number greater than 0.",
exit_code=EXIT_USAGE,
)
_timeout_s = timeout
def app_url() -> str:
if _app_url_override:
return _app_url_override
viewer = load_settings().viewer
configured = viewer.app_url.rstrip("/")
explicitly_configured = bool(os.environ.get("STRIX_APP_URL")) or "app_url" in getattr(
viewer, "model_fields_set", set[str]()
)
if explicitly_configured or _token_override_active or os.environ.get("STRIX_API_TOKEN"):
return configured
record = read_record()
stored = record.get("app_url") if record is not None else None
if isinstance(stored, str) and stored:
try:
_parse_origin_url(stored, label="stored platform URL")
except CloudError:
pass
else:
return stored.rstrip("/")
return configured
def api_token(override: str | None = None) -> str:
token = override or os.environ.get("STRIX_API_TOKEN")
if not token:
record = read_record()
if record is not None:
stored = record.get("api_token")
if isinstance(stored, str):
_validate_stored_token_origin(record)
token = stored
if not token or not token.strip():
raise CloudError(
"not signed in. Run `strix cloud login`, or set STRIX_API_TOKEN.",
exit_code=EXIT_AUTH,
)
return token.strip()
def _validate_stored_token_origin(record: dict[str, Any]) -> None:
"""Never send a stored bearer token to an origin other than its issuer."""
stored_url = record.get("app_url")
if not isinstance(stored_url, str) or not stored_url:
raise CloudError(
"the stored sign-in is not bound to a trusted platform. Run `strix cloud login` "
"again before using it.",
exit_code=EXIT_AUTH,
)
try:
stored_origin = _origin(_parse_origin_url(stored_url, label="stored platform URL"))
active_origin = _origin(_parse_origin_url(app_url(), label="configured platform URL"))
except CloudError as exc:
raise CloudError(
"the stored sign-in has an invalid platform binding. Run `strix cloud login` again.",
exit_code=EXIT_AUTH,
) from exc
if stored_origin != active_origin:
raise CloudError(
"the stored sign-in belongs to a different platform. Refusing to send its token; "
"run `strix cloud login` for the configured platform or supply an explicit token.",
exit_code=EXIT_AUTH,
)
def request(
method: str,
path: str,
*,
token: str | None = None,
query: dict[str, Any] | None = None,
body: dict[str, Any] | None = None,
stream: bool = False,
idempotency_key: str | None = None,
) -> requests.Response:
url = f"{app_url()}/api/v1{path}"
headers = {
"Authorization": f"Bearer {api_token(token)}",
}
workspace_id = _expected_workspace_id(token_override=token is not None)
if workspace_id:
headers["X-Strix-Workspace"] = workspace_id
if idempotency_key is not None:
headers["Idempotency-Key"] = idempotency_key
try:
response = requests.request(
method,
url,
headers=headers,
params={
key: ("true" if value else "false") if isinstance(value, bool) else value
for key, value in (query or {}).items()
if value is not None
}
or None,
json=body,
timeout=_timeout_s,
stream=stream,
allow_redirects=False,
)
except requests.RequestException as exc:
raise CloudTransportError(f"could not reach {app_url()}: {exc}") from exc
return response
def _expected_workspace_id(*, token_override: bool) -> str | None:
"""Pin every request in this process to the workspace selected at startup."""
if _workspace_id_override:
return _workspace_id_override
if token_override or _token_override_active or os.environ.get("STRIX_API_TOKEN"):
return None
return None
def upload_file(signed_url: str, upload_token: str, path: Path) -> None:
"""Stream a file to a platform-issued storage URL."""
_validate_upload_url(signed_url)
response: requests.Response | None = None
try:
with path.open("rb") as stream:
response = requests.put(
signed_url,
data=stream,
headers={
"Authorization": f"Bearer {upload_token}",
"Content-Type": "application/zip",
},
timeout=_timeout_s,
allow_redirects=False,
)
except (OSError, requests.RequestException) as exc:
raise CloudError(f"source upload failed: {exc}") from exc
try:
if 300 <= response.status_code < 400:
raise CloudError("source upload refused an unexpected redirect")
if not response.ok:
detail = ""
try:
payload = response.json()
if isinstance(payload, dict):
fields = cast("dict[str, Any]", payload)
detail = str(fields.get("message") or fields.get("error") or "")
except ValueError:
pass
raise CloudError(detail or f"source upload failed (HTTP {response.status_code})")
finally:
response.close()
def _validate_upload_url(signed_url: str) -> None:
"""Allow uploads only to the trusted app origin or managed Supabase storage."""
# Supabase signed upload URLs carry their signature in the query string.
# Keep every origin/path restriction below, but allow that opaque query on
# this one platform-issued URL type.
target = _parse_origin_url(
signed_url,
label="source upload URL",
allow_query=True,
)
if not target.path.startswith(_STORAGE_PATH_PREFIX):
raise CloudError("source upload refused a URL outside the storage API")
configured_app = _parse_origin_url(app_url(), label="configured platform URL")
if _origin(target) == _origin(configured_app):
return
if _is_loopback_host(configured_app.hostname or "") and _is_loopback_host(
target.hostname or ""
):
return
hostname = target.hostname or ""
if (
target.scheme == "https"
and target.port in (None, 443)
and _SUPABASE_STORAGE_HOST.fullmatch(hostname)
):
return
raise CloudError(
"source upload refused an untrusted storage origin; only the configured platform "
"origin and managed Supabase storage are allowed"
)
def _parse_origin_url(
value: str,
*,
label: str,
allow_query: bool = False,
) -> SplitResult:
try:
parsed = urlsplit(value)
port = parsed.port
except (TypeError, ValueError) as exc:
raise CloudError(f"{label} is invalid") from exc
hostname = parsed.hostname
if (
parsed.scheme not in {"http", "https"}
or not hostname
or parsed.username is not None
or parsed.password is not None
or (parsed.query and not allow_query)
or parsed.fragment
or "\\" in value
or any(character.isspace() for character in value)
or "%" in parsed.netloc
):
raise CloudError(f"{label} is invalid")
try:
hostname.encode("ascii")
except UnicodeEncodeError as exc:
raise CloudError(f"{label} contains a non-ASCII hostname") from exc
if port is not None and not 1 <= port <= 65535:
raise CloudError(f"{label} is invalid")
return parsed
def _origin(parsed: SplitResult) -> tuple[str, str, int]:
default_port = 443 if parsed.scheme == "https" else 80
return parsed.scheme, (parsed.hostname or "").lower(), parsed.port or default_port
def _is_loopback_host(hostname: str) -> bool:
normalized = hostname.lower().rstrip(".")
if normalized == "localhost" or normalized.endswith(".localhost"):
return True
try:
return ipaddress.ip_address(normalized).is_loopback
except ValueError:
return False
def parsed(response: requests.Response) -> Any:
content_type = response.headers.get("content-type", "")
if "application/json" in content_type:
try:
return response.json()
except ValueError:
return response.text
return response.text
def check(response: requests.Response) -> Any:
data = parsed(response)
if 200 <= response.status_code < 300:
content_type = response.headers.get("content-type", "").lower()
if "application/json" not in content_type:
raise CloudError(
"the server returned a non-JSON response. Check STRIX_APP_URL and preview "
"access, then retry."
)
try:
return response.json()
except ValueError as exc:
raise CloudError(
"the server returned malformed JSON. Check STRIX_APP_URL and preview "
"access, then retry."
) from exc
detail = ""
error_code = ""
if isinstance(data, dict):
raw = cast("dict[str, Any]", data)
detail = str(raw.get("detail") or raw.get("error") or "")
error_code = str(raw.get("code") or raw.get("error_code") or "")
nested_error = raw.get("error")
if isinstance(nested_error, dict):
nested = cast("dict[str, Any]", nested_error)
error_code = error_code or str(nested.get("code") or "")
detail = str(nested.get("message") or detail)
message = detail or f"HTTP {response.status_code}"
if error_code == "scan_credit_limit_reached":
raise CloudError(message, exit_code=EXIT_PAYMENT, payload=data)
if response.status_code in (401, 403):
raise CloudError(message, exit_code=EXIT_AUTH, payload=data)
if response.status_code == 402:
hint = detail or (
"not enough credits. Run `strix cloud billing topup --credits N` to buy credits."
)
raise CloudError(hint, exit_code=EXIT_PAYMENT, payload=data)
raise CloudError(message, exit_code=EXIT_ERROR, payload=data)

280
strix/interface/cloud/payment_proxy.py Normal file
View file

@ -0,0 +1,280 @@
"""Loopback bridge for wallet clients that only accept secrets in argv.
The ``mppx`` CLI accepts custom HTTP headers through ``-H`` only. Passing a
Strix API token that way exposes it to process-listing tools. This module keeps
the token in the Strix process and injects it while forwarding the wallet's two
requests (challenge and paid retry) to the fixed billing endpoint.
"""
from __future__ import annotations
import secrets
import threading
from contextlib import contextmanager, suppress
from dataclasses import dataclass, field
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import TYPE_CHECKING, Any
import requests
if TYPE_CHECKING:
from collections.abc import Callable, Generator
_DEFAULT_REQUEST_TIMEOUT_S = 120.0
_MAX_REQUEST_BODY_BYTES = 64 * 1024
_MAX_UPSTREAM_RESPONSE_BYTES = 1024 * 1024
_MAX_WALLET_REQUESTS = 2
_HOP_BY_HOP_HEADERS = frozenset(
{
"connection",
"keep-alive",
"proxy-authenticate",
"proxy-authorization",
"proxy-connection",
"te",
"trailer",
"transfer-encoding",
"upgrade",
}
)
@dataclass
class _BridgeState:
upstream_url: str
authorization: str
expected_body: bytes
path: str
timeout: float
response_observer: Callable[[WalletUpstreamResponse], None] | None = None
request_count: int = 0
lock: threading.Lock = field(default_factory=threading.Lock)
def claim_request(self) -> bool:
"""Allow only the challenge request and its paid retry."""
with self.lock:
if self.request_count >= _MAX_WALLET_REQUESTS:
return False
self.request_count += 1
return True
class _ResponseTooLargeError(Exception):
"""The fixed billing endpoint returned more data than a wallet needs."""
@dataclass(frozen=True)
class WalletUpstreamResponse:
"""A bounded upstream response observed by the trusted loopback bridge."""
status_code: int
body: bytes
def _bounded_response_body(response: requests.Response) -> bytes:
content_length = response.headers.get("Content-Length")
if content_length:
try:
if int(content_length) > _MAX_UPSTREAM_RESPONSE_BYTES:
raise _ResponseTooLargeError
except ValueError:
pass
chunks: list[bytes] = []
total = 0
for chunk in response.iter_content(chunk_size=64 * 1024):
if not chunk:
continue
total += len(chunk)
if total > _MAX_UPSTREAM_RESPONSE_BYTES:
raise _ResponseTooLargeError
chunks.append(chunk)
return b"".join(chunks)
def _connection_header_names(handler: BaseHTTPRequestHandler) -> set[str]:
value = handler.headers.get("Connection", "")
return {item.strip().lower() for item in value.split(",") if item.strip()}
def _forward_request_headers(handler: BaseHTTPRequestHandler) -> dict[str, str]:
blocked = {
*_HOP_BY_HOP_HEADERS,
*_connection_header_names(handler),
"content-length",
"forwarded",
"host",
"true-client-ip",
"x-forwarded-for",
"x-forwarded-host",
"x-forwarded-proto",
"x-real-ip",
"x-strix-authorization",
"x-vercel-forwarded-for",
}
return {name: value for name, value in handler.headers.items() if name.lower() not in blocked}
def _send_json_error(handler: BaseHTTPRequestHandler, status: int, message: str) -> None:
body = f'{{"error": "{message}"}}'.encode()
handler.close_connection = True
handler.send_response(status)
handler.send_header("Content-Type", "application/json")
handler.send_header("Content-Length", str(len(body)))
handler.send_header("Cache-Control", "no-store")
handler.send_header("Connection", "close")
handler.end_headers()
with suppress(BrokenPipeError, ConnectionResetError):
handler.wfile.write(body)
def _make_handler(state: _BridgeState) -> type[BaseHTTPRequestHandler]:
class WalletBridgeHandler(BaseHTTPRequestHandler):
protocol_version = "HTTP/1.1"
def log_message(self, format: str, *args: Any) -> None: # noqa: A002
"""Do not write wallet request metadata to stderr."""
del format, args
def do_POST(self) -> None: # noqa: PLR0911, PLR0912
if self.path != state.path:
_send_json_error(self, 404, "Not found")
return
if self.headers.get("Transfer-Encoding"):
_send_json_error(self, 400, "Chunked request bodies are not supported")
return
try:
content_length = int(self.headers.get("Content-Length", ""))
except ValueError:
_send_json_error(self, 411, "A valid Content-Length is required")
return
if content_length < 0 or content_length > _MAX_REQUEST_BODY_BYTES:
_send_json_error(self, 413, "Request body is too large")
return
body = self.rfile.read(content_length)
if body != state.expected_body:
_send_json_error(self, 403, "Request body did not match the approved top-up")
return
if not state.claim_request():
_send_json_error(self, 429, "Wallet request limit reached")
return
headers = _forward_request_headers(self)
headers["X-Strix-Authorization"] = state.authorization
try:
response = requests.request(
"POST",
state.upstream_url,
headers=headers,
data=body,
timeout=state.timeout,
allow_redirects=False,
stream=True,
)
try:
response_body = _bounded_response_body(response)
response_status = response.status_code
response_headers = dict(response.headers)
finally:
response.close()
except _ResponseTooLargeError:
_send_json_error(self, 502, "Strix billing response was too large")
return
except requests.RequestException:
_send_json_error(self, 502, "Could not reach the Strix billing endpoint")
return
if state.response_observer is not None:
with suppress(Exception):
state.response_observer(
WalletUpstreamResponse(status_code=response_status, body=response_body)
)
if 300 <= response_status < 400:
_send_json_error(self, 502, "Strix billing refused an unexpected redirect")
return
self.send_response(response_status)
response_connection_headers = {
item.strip().lower()
for item in response_headers.get("Connection", "").split(",")
if item.strip()
}
blocked_response_headers = {
*_HOP_BY_HOP_HEADERS,
*response_connection_headers,
"cache-control",
"content-encoding",
"content-length",
"location",
}
for name, value in response_headers.items():
if (
name.lower() not in blocked_response_headers
and "\r" not in value
and "\n" not in value
):
self.send_header(name, value)
self.send_header("Content-Length", str(len(response_body)))
self.send_header("Cache-Control", "no-store")
self.end_headers()
with suppress(BrokenPipeError, ConnectionResetError):
self.wfile.write(response_body)
def do_GET(self) -> None:
_send_json_error(self, 405, "Method not allowed")
def do_PUT(self) -> None:
_send_json_error(self, 405, "Method not allowed")
def do_PATCH(self) -> None:
_send_json_error(self, 405, "Method not allowed")
def do_DELETE(self) -> None:
_send_json_error(self, 405, "Method not allowed")
return WalletBridgeHandler
@contextmanager
def wallet_payment_bridge(
*,
upstream_url: str,
api_token: str,
expected_body: bytes,
timeout: float | None = None,
response_observer: Callable[[WalletUpstreamResponse], None] | None = None,
) -> Generator[str]:
"""Yield a one-run loopback URL that injects the Strix API token upstream.
The random path prevents accidental cross-process requests and limits local
denial-of-service races. It is not an authentication boundary against a
same-user process that can inspect another process's argv.
"""
capability = secrets.token_urlsafe(32)
path = f"/topup/{capability}"
state = _BridgeState(
upstream_url=upstream_url,
authorization=f"Bearer {api_token}",
expected_body=expected_body,
path=path,
timeout=timeout or _DEFAULT_REQUEST_TIMEOUT_S,
response_observer=response_observer,
)
server = ThreadingHTTPServer(("127.0.0.1", 0), _make_handler(state))
server.daemon_threads = True
thread = threading.Thread(
target=server.serve_forever,
kwargs={"poll_interval": 0.05},
name="strix-wallet-bridge",
daemon=True,
)
thread.start()
try:
yield f"http://127.0.0.1:{server.server_port}{path}"
finally:
server.shutdown()
server.server_close()
thread.join(timeout=1)

1759
strix/interface/cloud/render.py Normal file
View file

File diff suppressed because it is too large Load diff

1127
strix/interface/cloud/runner.py Normal file
View file

File diff suppressed because it is too large Load diff

167
strix/interface/cloud/session.py Normal file
View file

@ -0,0 +1,167 @@
"""Inspect and safely narrow a managed Strix CLI session."""
from __future__ import annotations
import os
from typing import TYPE_CHECKING, Any, cast
from rich.console import Console
from rich.markup import escape
import strix.interface.cloud.http as http # noqa: PLR0402
from strix.interface.cloud.arguments import CloudArgumentParser
from strix.interface.cloud.render import emit, json_mode
from strix.interface.platform_cli import read_record, save_record
from strix.interface.terminal_text import sanitize_terminal_text
if TYPE_CHECKING:
import argparse
def run_session(argv: list[str]) -> int:
console = Console()
normalized = ["show", *argv] if not argv or argv[0].startswith("-") else list(argv)
if normalized[0] == "help":
normalized = ["--help", *normalized[1:]]
if normalized[0] in {"-h", "--help"}:
_print_help(console)
return 0
verb = normalized.pop(0)
if verb == "scopes" and normalized and normalized[0] == "set":
normalized.pop(0)
return _run_scopes_set(console, normalized)
if verb not in {"show", "scopes"}:
console.print(f"[red]Unknown session command:[/] {escape(sanitize_terminal_text(verb))}")
_print_help(console)
return http.EXIT_USAGE
return _run_show(console, normalized, scopes_only=verb == "scopes")
def _common(parser: argparse.ArgumentParser) -> None:
parser.add_argument("--json", action="store_true", help="Print the raw JSON response.")
parser.add_argument("--show-scopes", action="store_true", help="Print every granted scope.")
parser.add_argument("--token", default=None, help="API token override.")
parser.add_argument("--workspace-id", default=None, metavar="ORG_ID")
parser.add_argument("--app-url", default=None, metavar="URL")
parser.add_argument("--timeout", default=None, type=float, metavar="SECONDS")
def _configure(args: argparse.Namespace) -> bool:
external = args.token is not None or bool(os.environ.get("STRIX_API_TOKEN", "").strip())
http.configure(
base_url=args.app_url,
timeout=args.timeout,
token_override=bool(args.token),
workspace_id=args.workspace_id,
)
return external
def _run_show(console: Console, argv: list[str], *, scopes_only: bool) -> int:
parser = CloudArgumentParser(prog=f"strix cloud session {'scopes' if scopes_only else 'show'}")
_common(parser)
as_json = json_mode(flag="--json" in argv)
try:
args = parser.parse_args(argv)
_configure(args)
payload = http.check(http.request("GET", "/cli/session", token=args.token))
except SystemExit as exc:
return int(exc.code or 0)
except http.CloudError as exc:
return _error(console, exc, as_json=as_json)
if not isinstance(payload, dict):
return _error(console, http.CloudError("invalid CLI session response"), as_json=as_json)
record = cast("dict[str, Any]", payload)
if as_json:
emit(console, record, as_json=True)
return http.EXIT_OK
scopes = _string_list(record.get("scopes"))
ceiling = _string_list(record.get("scope_ceiling"))
profile = str(record.get("scope_profile") or "custom").title()
if not scopes_only:
device_name = escape(str(record.get("device_name") or "this device"))
console.print(f"[green]Active CLI session[/] on [bold]{device_name}[/]")
console.print(f" Workspace: {escape(str(record.get('organization_id') or 'unknown'))}")
console.print(f" Access: {profile} · {len(scopes)} scopes granted · {len(ceiling)} maximum")
if args.show_scopes or scopes_only:
console.print(f" Granted: [dim]{escape(' '.join(scopes))}[/]")
console.print(f" Ceiling: [dim]{escape(' '.join(ceiling))}[/]")
return http.EXIT_OK
def _run_scopes_set(console: Console, argv: list[str]) -> int:
parser = CloudArgumentParser(
prog="strix cloud session scopes set",
description="Change scopes within the access approved at browser sign-in.",
)
mode = parser.add_mutually_exclusive_group(required=True)
mode.add_argument("profile", nargs="?", choices=("minimal", "recommended", "full"))
mode.add_argument("--scopes", nargs="+", metavar="SCOPE")
_common(parser)
as_json = json_mode(flag="--json" in argv)
try:
args = parser.parse_args(argv)
external = _configure(args)
body = (
{"scope_profile": args.profile}
if args.profile
else {"scope_profile": "custom", "scopes": args.scopes}
)
payload = http.check(http.request("PATCH", "/cli/session", token=args.token, body=body))
except SystemExit as exc:
return int(exc.code or 0)
except http.CloudError as exc:
return _error(console, exc, as_json=as_json)
if not isinstance(payload, dict):
return _error(console, http.CloudError("invalid CLI session response"), as_json=as_json)
result = cast("dict[str, Any]", payload)
if not external:
stored = read_record()
if stored is not None:
stored.update(
{
key: result[key]
for key in ("scopes", "requested_scopes", "scope_ceiling", "scope_profile")
if key in result
}
)
save_record(stored)
if as_json:
emit(console, result, as_json=True)
else:
scopes = _string_list(result.get("scopes"))
profile = str(result.get("scope_profile") or "custom").title()
console.print(f"[green]✓ CLI access updated.[/] {profile} · {len(scopes)} scopes granted")
if args.show_scopes:
console.print(f" Scopes: [dim]{escape(' '.join(scopes))}[/]")
return http.EXIT_OK
def _string_list(value: Any) -> list[str]:
if not isinstance(value, list):
return []
items = cast("list[Any]", cast("Any", value))
return [str(item) for item in items]
def _error(console: Console, error: http.CloudError, *, as_json: bool) -> int:
if as_json:
raw_payload: Any = error.payload
error_payload = cast("dict[str, Any]", raw_payload)
payload = dict(error_payload) if isinstance(raw_payload, dict) else {}
payload["error"] = str(error)
if payload.get("detail") == payload.get("error"):
payload.pop("detail", None)
emit(console, payload, as_json=True)
else:
console.print(f"[red]Error:[/] {escape(sanitize_terminal_text(error))}")
return error.exit_code
def _print_help(console: Console) -> None:
console.print("[bold]strix cloud session[/] commands:")
console.print(" show Show the remote CLI session (default).")
console.print(" scopes Show granted scopes and consent ceiling.")
console.print(" scopes set PROFILE Use minimal, recommended, or full.")
console.print(" scopes set --scopes SCOPE… Use a custom set within the ceiling.")

403
strix/interface/cloud/source_scan.py Normal file
View file

@ -0,0 +1,403 @@
"""Local-source approval, upload, and scan-launch lifecycle."""
from __future__ import annotations
import re
import sys
from dataclasses import dataclass
from typing import TYPE_CHECKING, Any, cast
from urllib.parse import quote
from rich.markup import escape
import strix.interface.cloud.http as http # noqa: PLR0402
from strix.interface.cloud.render import emit
from strix.interface.cloud.source_upload import prepare_source, remove_bundle
from strix.interface.terminal_text import sanitize_terminal_text
if TYPE_CHECKING:
import argparse
from typing import NoReturn
from rich.console import Console
from strix.interface.cloud.source_upload import SourceBundle
_SHA256 = re.compile(r"^[0-9a-fA-F]{64}$")
@dataclass
class LocalSourceScan:
"""Own one local bundle and its staged upload through a scan launch."""
bundle: SourceBundle | None = None
upload_id: str | None = None
idempotency_key: str | None = None
_launch_started: bool = False
def prepare_and_attach(
self,
console: Console,
args: argparse.Namespace,
body: dict[str, Any],
*,
as_json: bool,
token: str | None,
) -> bool:
"""Prepare source, emit a dry run, or upload and attach it to ``body``.
Returns ``True`` when a dry run was emitted and request execution should stop.
"""
self.bundle = prepare_scan_source(console, args, as_json=as_json)
if self.bundle is None:
return False
if getattr(args, "dry_run", False):
emit(
console,
{"source": self.bundle.summary(show_files=getattr(args, "show_files", False))},
as_json=as_json,
view="source_manifest",
)
return True
self.upload_id = _upload_scan_source(self.bundle, token=token)
existing = body.get("upload_ids")
body["upload_ids"] = [
*(existing if isinstance(existing, list) else []),
self.upload_id,
]
return False
def mark_launch_started(self) -> None:
"""Record that the scan-creation request may have reached the platform."""
self._launch_started = self.upload_id is not None
def handle_request_failure(self, error: BaseException, *, token: str | None) -> None:
"""Clean or retain a staged upload according to request ambiguity."""
if self.upload_id is None:
return
if self._launch_started:
if isinstance(error, KeyboardInterrupt):
raise _interrupted_source_upload_error(
self.upload_id, self.idempotency_key
) from None
if isinstance(error, Exception):
raise _retained_source_upload_error(
self.upload_id, error, self.idempotency_key
) from error
return
try:
_delete_upload(self.upload_id, token=token)
except (http.CloudError, KeyboardInterrupt) as cleanup_error:
if isinstance(error, Exception):
raise _source_cleanup_error(self.upload_id, error, cleanup_error) from error
interrupted = http.CloudError("source upload interrupted.", exit_code=130)
raise _source_cleanup_error(self.upload_id, interrupted, cleanup_error) from None
def handle_response_failure(
self,
error: BaseException,
*,
definitive: bool,
token: str | None,
) -> None:
"""Clean a rejected upload or retain one whose scan result is ambiguous."""
if self.upload_id is None:
return
if definitive:
try:
_delete_upload(self.upload_id, token=token)
except (http.CloudError, KeyboardInterrupt) as cleanup_error:
if isinstance(error, Exception):
raise _source_cleanup_error(self.upload_id, error, cleanup_error) from error
interrupted = http.CloudError("source upload interrupted.", exit_code=130)
raise _source_cleanup_error(self.upload_id, interrupted, cleanup_error) from None
return
if isinstance(error, Exception):
raise _retained_source_upload_error(
self.upload_id, error, self.idempotency_key
) from error
def wrap_result(self, result: Any, args: argparse.Namespace) -> Any:
"""Attach the approved source manifest to a successful scan response."""
if self.bundle is None:
return result
return {
"source": self.bundle.summary(show_files=getattr(args, "show_files", False)),
"upload_id": self.upload_id,
"scan": result,
}
def close(self) -> None:
"""Remove the private temporary bundle, if one was built."""
if self.bundle is not None:
remove_bundle(self.bundle)
def prepare_scan_source(
console: Console, args: argparse.Namespace, *, as_json: bool
) -> SourceBundle | None:
"""Build and approve the exact local-source snapshot for one invocation."""
source = getattr(args, "source", None)
source_flags = (
"dry_run",
"show_files",
"include_hidden",
"include_sensitive",
"include_archives",
"approve_sha256",
)
if source is None:
if any(getattr(args, name, False) for name in source_flags) or getattr(args, "exclude", []):
raise http.CloudError("source upload options require --source DIRECTORY.")
return None
bundle = prepare_source(
source,
include_hidden=bool(getattr(args, "include_hidden", False)),
include_sensitive=bool(getattr(args, "include_sensitive", False)),
include_archives=bool(getattr(args, "include_archives", False)),
exclude=cast("list[str]", getattr(args, "exclude", [])),
)
keep_bundle = False
try:
approved_digest = _validate_source_digest_approval(args, bundle)
if getattr(args, "dry_run", False):
keep_bundle = True
return bundle
if getattr(args, "yes", False) or approved_digest is not None:
keep_bundle = True
return bundle
if as_json or not (sys.stdin.isatty() and sys.stdout.isatty()):
_source_approval_error(
"source upload requires explicit approval in non-interactive mode. "
"Review with --dry-run --show-files, then rerun with "
"--approve-sha256 <reviewed hash>; use --yes only for a deliberate "
"one-shot approval of the snapshot built by that invocation."
)
console.print(
"[bold]Local source upload[/]\n"
f" {len(bundle.manifest.files):,} file(s), "
f"{_format_bytes(bundle.manifest.total_bytes)} "
f"({_format_bytes(bundle.archive_bytes)} compressed)\n"
f" {sum(bundle.manifest.excluded.values()):,} path(s) excluded\n"
" Only the selected files will be sent to Strix Cloud."
)
if getattr(args, "show_files", False):
console.print(f"\n[bold]Selected files ({len(bundle.manifest.files):,})[/]")
for selected in bundle.manifest.files:
console.print(
f" {escape(sanitize_terminal_text(selected.archive_name))}", soft_wrap=True
)
answer = (
console.input("Upload this source and start the scan? [y/N]: ", markup=False)
.strip()
.lower()
)
if answer not in ("y", "yes"):
_source_approval_error("source upload cancelled.")
keep_bundle = True
return bundle
finally:
if not keep_bundle:
remove_bundle(bundle)
def _validate_source_digest_approval(args: argparse.Namespace, bundle: SourceBundle) -> str | None:
approved_digest = getattr(args, "approve_sha256", None)
if approved_digest is None:
return None
if not isinstance(approved_digest, str) or not _SHA256.fullmatch(approved_digest):
_source_approval_error("--approve-sha256 must be exactly 64 hexadecimal characters.")
if bundle.archive_sha256 != approved_digest.lower():
_source_approval_error(
"source archive SHA-256 does not match --approve-sha256; review a fresh "
"--dry-run before uploading."
)
return approved_digest
def _source_approval_error(message: str) -> NoReturn:
raise http.CloudError(message)
def _upload_scan_source(bundle: SourceBundle, *, token: str | None) -> str:
file_name = f"strix-source-{bundle.archive_sha256[:12]}.zip"
requested = http.check(
http.request(
"POST",
"/uploads/request",
token=token,
body={
"file_name": file_name,
"file_size": bundle.archive_bytes,
"category": "repository",
},
)
)
if not isinstance(requested, dict):
raise http.CloudError("the platform returned an invalid source upload response.")
fields = cast("dict[str, Any]", requested)
upload_id = fields.get("upload_id")
signed_url = fields.get("signed_url")
upload_token = fields.get("token")
if not all(isinstance(value, str) and value for value in (upload_id, signed_url, upload_token)):
error = http.CloudError("the platform did not return complete source upload credentials.")
if isinstance(upload_id, str) and upload_id:
try:
_delete_upload(upload_id, token=token)
except (http.CloudError, KeyboardInterrupt) as cleanup_error:
raise _source_cleanup_error(upload_id, error, cleanup_error) from error
raise error
try:
http.upload_file(cast("str", signed_url), cast("str", upload_token), bundle.archive_path)
completed = http.check(
http.request(
"POST",
"/uploads/complete",
token=token,
body={"upload_id": upload_id},
)
)
_validate_completed_upload(completed, expected_id=cast("str", upload_id))
except BaseException as error:
try:
_delete_upload(cast("str", upload_id), token=token)
except (http.CloudError, KeyboardInterrupt) as cleanup_error:
if isinstance(error, Exception):
raise _source_cleanup_error(cast("str", upload_id), error, cleanup_error) from error
interrupted = http.CloudError("source upload interrupted.", exit_code=130)
raise _source_cleanup_error(
cast("str", upload_id), interrupted, cleanup_error
) from None
raise
return cast("str", upload_id)
def _validate_completed_upload(completed: Any, *, expected_id: str) -> None:
fields = cast("dict[str, Any]", completed) if isinstance(completed, dict) else {}
if fields.get("id") != expected_id:
raise http.CloudError("the platform returned an invalid source upload completion response.")
def _delete_upload(upload_id: str, *, token: str | None) -> None:
response = http.request("DELETE", f"/uploads/{quote(upload_id, safe='')}", token=token)
if response.status_code == 404 or 200 <= response.status_code < 300:
return
http.check(response)
def _source_cleanup_note(upload_id: str, cleanup_error: BaseException) -> str:
return (
f"Cleanup of source upload {upload_id} could not be confirmed: {cleanup_error}. "
f"Retry with `strix cloud uploads delete {upload_id}`."
)
def _source_cleanup_error(
upload_id: str, error: Exception, cleanup_error: BaseException
) -> http.CloudError:
"""Report a staged source object whenever automatic deletion is uncertain."""
message = f"{error} {_source_cleanup_note(upload_id, cleanup_error)}"
payload: dict[str, Any] = {}
exit_code = http.EXIT_ERROR
if isinstance(error, http.CloudError):
exit_code = error.exit_code
raw_payload: Any = error.payload
if isinstance(raw_payload, dict):
payload.update(cast("dict[str, Any]", raw_payload))
elif raw_payload is not None:
payload["detail"] = raw_payload
payload.update(
{
"error": message,
"upload_id": upload_id,
"upload_retained": True,
"cleanup_unknown": True,
}
)
return http.CloudError(message, exit_code=exit_code, payload=payload)
def _interrupted_source_upload_error(
upload_id: str, idempotency_key: str | None = None
) -> http.CloudError:
retry_note = _idempotency_retry_note(idempotency_key)
message = (
"Interrupted while starting the scan. The launch outcome is unknown, so source upload "
f"{upload_id} was retained. Check `strix cloud scans list` before retrying; if no scan "
f"was created, run `strix cloud uploads delete {upload_id}`.{retry_note}"
)
payload: dict[str, Any] = {
"error": message,
"interrupted": True,
"upload_id": upload_id,
"upload_retained": True,
"launch_outcome_unknown": True,
}
_attach_idempotency_recovery(payload, idempotency_key)
return http.CloudError(message, exit_code=130, payload=payload)
def _retained_source_upload_error(
upload_id: str,
error: Exception,
idempotency_key: str | None = None,
) -> http.CloudError:
"""Preserve source when the platform may already have accepted its scan."""
retry_note = _idempotency_retry_note(idempotency_key)
message = (
f"{error} The scan launch outcome is unknown, so source upload {upload_id} was retained. "
"Check `strix cloud scans list` before retrying; if no scan was created, clean it up "
f"with `strix cloud uploads delete {upload_id}`. Linked uploads cannot be deleted."
f"{retry_note}"
)
payload: dict[str, Any] = {}
exit_code = http.EXIT_ERROR
if isinstance(error, http.CloudError):
exit_code = error.exit_code
raw_payload: Any = error.payload
error_payload = cast("dict[str, Any]", raw_payload)
if isinstance(raw_payload, dict):
payload.update(error_payload)
elif raw_payload is not None:
payload["detail"] = raw_payload
payload.update(
{
"error": message,
"upload_id": upload_id,
"upload_retained": True,
"launch_outcome_unknown": True,
}
)
_attach_idempotency_recovery(payload, idempotency_key)
return http.CloudError(message, exit_code=exit_code, payload=payload)
def _idempotency_retry_note(idempotency_key: str | None) -> str:
if not idempotency_key:
return ""
return (
" An exact retry is safe only with the same request body and "
f"`--idempotency-key {idempotency_key}`."
)
def _attach_idempotency_recovery(payload: dict[str, Any], idempotency_key: str | None) -> None:
if not idempotency_key:
return
payload.update(
{
"idempotency_key": idempotency_key,
"retry_safe": True,
"retry_same_request": True,
}
)
def _format_bytes(value: int) -> str:
if value < 1024:
return f"{value} B"
if value < 1024 * 1024:
return f"{value / 1024:.1f} KB"
return f"{value / (1024 * 1024):.1f} MB"

703
strix/interface/cloud/source_upload.py Normal file
View file

@ -0,0 +1,703 @@
"""Privacy-conscious local source packaging for managed scans."""
from __future__ import annotations
import fnmatch
import hashlib
import os
import shutil
import stat
import subprocess # nosec B404
import tempfile
import zipfile
from collections import Counter
from dataclasses import dataclass
from pathlib import Path, PurePosixPath
from typing import TYPE_CHECKING
import strix.interface.cloud.http as http # noqa: PLR0402
if TYPE_CHECKING:
from collections.abc import Iterator
from typing import Protocol
class _ScandirIterator(Iterator[os.DirEntry[str]], Protocol):
def close(self) -> None: ...
MAX_FILES = 20_000
MAX_FILE_BYTES = 25 * 1024 * 1024
MAX_TOTAL_BYTES = 250 * 1024 * 1024
MAX_ARCHIVE_BYTES = 50 * 1024 * 1024
MAX_CANDIDATE_PATHS = 200_000
MAX_IGNORE_BYTES = 64 * 1024
MAX_IGNORE_PATTERNS = 1_000
MAX_IGNORE_PATTERN_CHARS = 1_024
_ALWAYS_EXCLUDED_DIRS = frozenset(
{
".git",
".hg",
".svn",
"node_modules",
"vendor",
"venv",
".venv",
"env",
"__pycache__",
".tox",
".pytest_cache",
".mypy_cache",
".ruff_cache",
"dist",
"build",
"coverage",
"target",
".next",
".nuxt",
".gradle",
}
)
_SENSITIVE_NAMES = frozenset(
{
"id_rsa",
"id_dsa",
"id_ecdsa",
"id_ed25519",
"credentials.json",
"service-account.json",
"service_account.json",
".env",
".npmrc",
".pypirc",
".netrc",
".git-credentials",
"application_default_credentials.json",
}
)
_SENSITIVE_PATTERNS = (
"*.pem",
"*.key",
"*.p12",
"*.pfx",
"*.keystore",
"*.jks",
"secrets.*",
"secret.*",
".env.*",
)
_SENSITIVE_PATH_SUFFIXES = (
(".aws", "credentials"),
(".aws", "config"),
(".docker", "config.json"),
(".config", "gcloud", "credentials.db"),
(".azure", "accesstokens.json"),
(".azure", "azureprofile.json"),
(".kube", "config"),
)
_ARCHIVE_SUFFIXES = (
".zip",
".tar",
".tgz",
".tar.gz",
".tar.bz2",
".tar.xz",
".7z",
".rar",
".gz",
".bz2",
".xz",
".jar",
".war",
".whl",
".nupkg",
".apk",
".ipa",
)
_ARCHIVE_MAGIC_PREFIXES = (
b"PK\x03\x04",
b"PK\x05\x06",
b"PK\x07\x08",
b"\x1f\x8b",
b"BZh",
b"\xfd7zXZ\x00",
b"7z\xbc\xaf\x27\x1c",
b"Rar!\x1a\x07",
)
@dataclass(frozen=True)
class SelectedFile:
path: Path
archive_name: str
size: int
device: int
inode: int
mtime_ns: int
ctime_ns: int
@dataclass(frozen=True)
class SourceManifest:
source: Path
files: tuple[SelectedFile, ...]
excluded: Counter[str]
include_hidden: bool
include_sensitive: bool
include_archives: bool
@property
def total_bytes(self) -> int:
return sum(item.size for item in self.files)
def as_dict(
self,
*,
show_files: bool,
archive_bytes: int | None = None,
archive_sha256: str | None = None,
) -> dict[str, object]:
result: dict[str, object] = {
"source": str(self.source),
"file_count": len(self.files),
"uncompressed_bytes": self.total_bytes,
"excluded_count": sum(self.excluded.values()),
"excluded_by_reason": dict(sorted(self.excluded.items())),
"include_hidden": self.include_hidden,
"include_sensitive": self.include_sensitive,
"include_archives": self.include_archives,
}
if archive_bytes is not None:
result["archive_bytes"] = archive_bytes
if archive_sha256 is not None:
result["archive_sha256"] = archive_sha256
if show_files:
result["files"] = [item.archive_name for item in self.files]
return result
@dataclass(frozen=True)
class SourceBundle:
manifest: SourceManifest
archive_path: Path
archive_bytes: int
archive_sha256: str
def summary(self, *, show_files: bool) -> dict[str, object]:
return self.manifest.as_dict(
show_files=show_files,
archive_bytes=self.archive_bytes,
archive_sha256=self.archive_sha256,
)
def prepare_source(
value: str,
*,
include_hidden: bool,
include_sensitive: bool,
include_archives: bool,
exclude: list[str],
) -> SourceBundle:
"""Select safe source files and build a bounded temporary ZIP archive."""
source = Path(value).expanduser().resolve()
if not source.is_dir():
raise http.CloudError(f"--source must be a directory: {source}")
manifest = select_source(
source,
include_hidden=include_hidden,
include_sensitive=include_sensitive,
include_archives=include_archives,
exclude=exclude,
)
if not manifest.files:
raise http.CloudError("no files remain after applying source upload exclusions.")
with tempfile.NamedTemporaryFile(prefix="strix-source-", suffix=".zip", delete=False) as handle:
archive_path = Path(handle.name)
try:
_write_archive(archive_path, manifest.files)
except BaseException:
archive_path.unlink(missing_ok=True)
raise
archive_bytes = archive_path.stat().st_size
if archive_bytes > MAX_ARCHIVE_BYTES:
archive_path.unlink(missing_ok=True)
raise http.CloudError(
"source archive is larger than the 50 MB upload limit; narrow --source or "
"add --exclude patterns."
)
digest = _sha256(archive_path)
return SourceBundle(manifest, archive_path, archive_bytes, digest)
def select_source(
source: Path,
*,
include_hidden: bool = False,
include_sensitive: bool = False,
include_archives: bool = False,
exclude: list[str] | None = None,
) -> SourceManifest:
excluded: Counter[str] = Counter()
selected: list[SelectedFile] = []
patterns = [*_load_ignore_patterns(source), *(exclude or [])]
_validate_patterns(patterns)
total_bytes = 0
for relative in _candidate_paths(
source,
include_hidden=include_hidden,
patterns=patterns,
excluded=excluded,
):
archive_name = relative.as_posix()
reason = _exclusion_reason(
relative,
include_hidden=include_hidden,
include_sensitive=include_sensitive,
include_archives=include_archives,
patterns=patterns,
)
if reason:
excluded[reason] += 1
continue
path = source / relative
try:
info = path.lstat()
except OSError:
excluded["unreadable"] += 1
continue
if not stat.S_ISREG(info.st_mode):
excluded["symlink_or_non_file"] += 1
continue
if not include_archives and _has_archive_magic(path):
excluded["nested_archive"] += 1
continue
if info.st_size > MAX_FILE_BYTES:
raise http.CloudError(
f"{archive_name} is larger than the 25 MB per-file limit; exclude it explicitly."
)
selected.append(
SelectedFile(
path=path,
archive_name=archive_name,
size=info.st_size,
device=info.st_dev,
inode=info.st_ino,
mtime_ns=info.st_mtime_ns,
ctime_ns=info.st_ctime_ns,
)
)
total_bytes += info.st_size
if len(selected) > MAX_FILES:
raise http.CloudError(
f"source contains more than {MAX_FILES:,} files; narrow --source or add exclusions."
)
if total_bytes > MAX_TOTAL_BYTES:
raise http.CloudError(
"selected source is larger than the 250 MB expanded-size limit; narrow --source "
"or add --exclude patterns."
)
selected.sort(key=lambda item: item.archive_name)
return SourceManifest(
source,
tuple(selected),
excluded,
include_hidden,
include_sensitive,
include_archives,
)
def remove_bundle(bundle: SourceBundle) -> None:
bundle.archive_path.unlink(missing_ok=True)
def _candidate_paths(
source: Path,
*,
include_hidden: bool,
patterns: list[str],
excluded: Counter[str],
) -> Iterator[Path]:
git_root = _git_root(source)
if git_root is not None:
git = shutil.which("git")
if git is not None:
yield from _git_candidate_paths(git, git_root, source)
return
yield from _walk_candidate_paths(
source,
include_hidden=include_hidden,
patterns=patterns,
excluded=excluded,
)
def _git_candidate_paths(git: str, git_root: Path, source: Path) -> Iterator[Path]:
"""Stream Git's NUL-delimited manifest without buffering an unbounded repository."""
relative_source = source.relative_to(git_root)
command = [
git,
"-C",
str(git_root),
"ls-files",
"-z",
"--cached",
"--others",
"--exclude-standard",
"--",
]
if relative_source != Path():
command.append(relative_source.as_posix())
try:
process = subprocess.Popen( # noqa: S603 # nosec B603
command,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
)
except OSError as exc:
raise http.CloudError(f"could not enumerate Git source files: {exc}") from exc
assert process.stdout is not None
buffer = b""
count = 0
try:
while chunk := process.stdout.read(64 * 1024):
buffer += chunk
records = buffer.split(b"\0")
buffer = records.pop()
for raw in records:
relative = _git_relative_path(raw, relative_source)
if relative is None:
continue
count += 1
_check_candidate_limit(count)
yield relative
if buffer:
raise http.CloudError("Git returned a malformed source file manifest.")
if process.wait() != 0:
raise http.CloudError("Git could not enumerate the source directory.")
finally:
process.stdout.close()
if process.poll() is None:
process.terminate()
try:
process.wait(timeout=1)
except subprocess.TimeoutExpired:
process.kill()
process.wait()
def _git_relative_path(raw: bytes, relative_source: Path) -> Path | None:
repo_relative = Path(os.fsdecode(raw))
try:
relative = repo_relative.relative_to(relative_source)
except ValueError:
return None
if relative.is_absolute() or ".." in relative.parts:
raise http.CloudError("Git returned an unsafe source path.")
return relative
def _walk_candidate_paths(
source: Path,
*,
include_hidden: bool,
patterns: list[str],
excluded: Counter[str],
) -> Iterator[Path]:
"""Walk top-down so excluded dependency, VCS, and hidden trees are never traversed."""
count = 0
stack: list[tuple[Path, _ScandirIterator]] = []
try:
stack.append((source, os.scandir(source)))
while stack:
root_path, entries = stack[-1]
try:
entry = next(entries)
except StopIteration:
entries.close()
stack.pop()
continue
count += 1
_check_candidate_limit(count)
path = root_path / entry.name
relative = path.relative_to(source)
try:
is_directory = entry.is_dir(follow_symlinks=False)
is_symlink = entry.is_symlink()
except OSError:
excluded["unreadable"] += 1
continue
if is_directory:
reason = _pruned_directory_reason(
relative,
include_hidden=include_hidden,
patterns=patterns,
)
if reason:
excluded[reason] += 1
continue
try:
stack.append((path, os.scandir(path)))
except OSError:
excluded["unreadable"] += 1
continue
if is_symlink:
excluded["symlink_or_non_file"] += 1
continue
yield relative
except OSError as exc:
raise http.CloudError(f"could not enumerate source directory {source}: {exc}") from exc
finally:
for _, entries in stack:
entries.close()
def _pruned_directory_reason(
relative: Path,
*,
include_hidden: bool,
patterns: list[str],
) -> str | None:
lower_parts = tuple(part.lower() for part in relative.parts)
if any(part == ".git" for part in lower_parts):
return "git_metadata"
if any(part in _ALWAYS_EXCLUDED_DIRS for part in lower_parts):
return "dependency_or_build_output"
if not include_hidden and any(part.startswith(".") for part in relative.parts):
return "hidden"
if any(_matches_user_pattern(relative, pattern) for pattern in patterns):
return "user_pattern"
return None
def _check_candidate_limit(count: int) -> None:
if count > MAX_CANDIDATE_PATHS:
raise http.CloudError(
f"source enumeration exceeded {MAX_CANDIDATE_PATHS:,} paths before filtering; "
"narrow --source or add directory exclusions."
)
def _git_root(source: Path) -> Path | None:
git = shutil.which("git")
if git is None:
return None
result = subprocess.run( # noqa: S603 # nosec B603
[git, "-C", str(source), "rev-parse", "--show-toplevel"],
check=False,
capture_output=True,
text=True,
)
if result.returncode != 0:
return None
try:
return Path(result.stdout.strip()).resolve()
except OSError:
return None
def _exclusion_reason( # noqa: PLR0911
relative: Path,
*,
include_hidden: bool,
include_sensitive: bool,
include_archives: bool,
patterns: list[str],
) -> str | None:
parts = relative.parts
lower_parts = tuple(part.lower() for part in parts)
if any(part == ".git" for part in lower_parts):
return "git_metadata"
if any(part in _ALWAYS_EXCLUDED_DIRS for part in lower_parts[:-1]):
return "dependency_or_build_output"
if not include_hidden and any(part.startswith(".") for part in parts):
return "hidden"
if any(_matches_user_pattern(relative, pattern) for pattern in patterns):
return "user_pattern"
name = relative.name.lower()
if not include_sensitive and (
name in _SENSITIVE_NAMES
or any(fnmatch.fnmatch(name, pattern) for pattern in _SENSITIVE_PATTERNS)
or any(
lower_parts[-len(suffix) :] == suffix
for suffix in _SENSITIVE_PATH_SUFFIXES
if len(lower_parts) >= len(suffix)
)
):
return "sensitive_filename"
if not include_archives and name.endswith(_ARCHIVE_SUFFIXES):
return "nested_archive"
return None
def _matches_user_pattern(relative: Path, pattern: str) -> bool:
"""Match exclude globs, including intuitive trailing-slash directory rules."""
relative_posix = relative.as_posix()
posix = PurePosixPath(relative_posix)
if pattern.endswith("/"):
directory_pattern = pattern.rstrip("/")
if not directory_pattern:
return False
return (
posix.match(directory_pattern)
or fnmatch.fnmatch(relative_posix, directory_pattern)
or any(
PurePosixPath(parent.as_posix()).match(directory_pattern)
or fnmatch.fnmatch(parent.as_posix(), directory_pattern)
for parent in posix.parents
if parent != PurePosixPath(".")
)
)
return posix.match(pattern) or fnmatch.fnmatch(relative_posix, pattern)
def _write_archive(destination: Path, files: tuple[SelectedFile, ...]) -> None:
with zipfile.ZipFile(
destination, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6
) as archive:
for item in files:
flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0)
try:
descriptor = os.open(item.path, flags)
except OSError as exc:
raise http.CloudError(f"could not safely read {item.archive_name}: {exc}") from exc
with os.fdopen(descriptor, "rb") as source_file:
current = os.fstat(source_file.fileno())
if (
not stat.S_ISREG(current.st_mode)
or current.st_size != item.size
or current.st_dev != item.device
or current.st_ino != item.inode
or current.st_mtime_ns != item.mtime_ns
or current.st_ctime_ns != item.ctime_ns
):
raise http.CloudError(
f"{item.archive_name} changed while the source archive was being built; "
"retry."
)
info = zipfile.ZipInfo(item.archive_name)
info.compress_type = zipfile.ZIP_DEFLATED
info.external_attr = 0o100644 << 16
with archive.open(info, "w", force_zip64=True) as target:
remaining = item.size
while remaining:
chunk = source_file.read(min(1024 * 1024, remaining))
if not chunk:
raise http.CloudError(
f"{item.archive_name} changed while the source archive was being "
"built; retry."
)
target.write(chunk)
remaining -= len(chunk)
final = os.fstat(source_file.fileno())
if (
source_file.read(1)
or not stat.S_ISREG(final.st_mode)
or final.st_size != item.size
or final.st_dev != item.device
or final.st_ino != item.inode
or final.st_mtime_ns != item.mtime_ns
or final.st_ctime_ns != item.ctime_ns
):
raise http.CloudError(
f"{item.archive_name} changed while the source archive was being "
"built; retry."
)
def _sha256(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as stream:
for chunk in iter(lambda: stream.read(1024 * 1024), b""):
digest.update(chunk)
return digest.hexdigest()
def _has_archive_magic(path: Path) -> bool:
"""Recognize common archive containers even when their suffix is disguised."""
flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0)
try:
descriptor = os.open(path, flags)
with os.fdopen(descriptor, "rb") as stream:
header = stream.read(512)
except OSError:
return False
return header.startswith(_ARCHIVE_MAGIC_PREFIXES) or header[257:262] == b"ustar"
def _load_ignore_patterns(source: Path) -> list[str]:
path = source / ".strixignore"
raw_text = _read_ignore_file(path)
if raw_text is None:
return []
if len(raw_text) > MAX_IGNORE_BYTES:
raise http.CloudError(f"{path} is larger than the {MAX_IGNORE_BYTES:,}-byte limit.")
try:
lines = raw_text.decode("utf-8").splitlines()
except UnicodeDecodeError as exc:
raise http.CloudError(f"{path} must be UTF-8 text.") from exc
patterns: list[str] = []
for line_number, raw in enumerate(lines, start=1):
value = raw.strip()
if not value or value.startswith("#"):
continue
if value.startswith("!"):
raise http.CloudError(
f"{path}:{line_number}: negated patterns are not supported; use exclude-only globs."
)
patterns.append(value)
if len(patterns) > MAX_IGNORE_PATTERNS:
raise http.CloudError(
f"{path} contains more than {MAX_IGNORE_PATTERNS:,} exclusion patterns."
)
return patterns
def _read_ignore_file(path: Path) -> bytes | None:
"""Read a bounded regular ignore file without blocking on a FIFO or device."""
try:
descriptor = os.open(
path,
os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0),
)
except FileNotFoundError:
return None
except OSError as exc:
raise http.CloudError(f"could not read {path}: {exc}") from exc
try:
info = os.fstat(descriptor)
except OSError as exc:
os.close(descriptor)
raise http.CloudError(f"could not inspect {path}: {exc}") from exc
if not stat.S_ISREG(info.st_mode):
os.close(descriptor)
raise http.CloudError(f"{path} must be a regular file.")
try:
stream = os.fdopen(descriptor, "rb")
except OSError as exc:
os.close(descriptor)
raise http.CloudError(f"could not read {path}: {exc}") from exc
try:
return stream.read(MAX_IGNORE_BYTES + 1)
except OSError as exc:
raise http.CloudError(f"could not read {path}: {exc}") from exc
finally:
stream.close()
def _validate_patterns(patterns: list[str]) -> None:
if len(patterns) > MAX_IGNORE_PATTERNS:
raise http.CloudError(
f"source upload accepts at most {MAX_IGNORE_PATTERNS:,} exclusion patterns."
)
for pattern in patterns:
if len(pattern) > MAX_IGNORE_PATTERN_CHARS:
raise http.CloudError(
"source exclusion patterns must be at most "
f"{MAX_IGNORE_PATTERN_CHARS:,} characters each."
)
if "\x00" in pattern:
raise http.CloudError("source exclusion patterns cannot contain NUL bytes.")

1147
strix/interface/cloud/spec.py Normal file
View file

File diff suppressed because it is too large Load diff

291
strix/interface/cloud/workspaces.py Normal file
View file

@ -0,0 +1,291 @@
"""`strix cloud workspaces use` — switch the stored token to another workspace.
The command lists the workspaces of the account, finds the requested one by
ID or by exact name, asks the platform to rotate that token in place, and
stores the returned workspace metadata. The bearer secret and expiry stay the
same; the account's role in the target workspace limits the granted scopes.
"""
from __future__ import annotations
import os
from typing import TYPE_CHECKING, Any, cast
from rich.console import Console
from rich.markup import escape
import strix.interface.cloud.http as http # noqa: PLR0402
from strix.interface.cloud.arguments import CloudArgumentParser
from strix.interface.cloud.render import emit, json_mode
from strix.interface.platform_cli import AUTH_PATH, read_record, save_record
from strix.interface.platform_identity import read_or_create_identity
from strix.interface.terminal_text import sanitize_terminal_text
if TYPE_CHECKING:
import argparse
def run_workspace_use(argv: list[str]) -> int:
"""Entry point for ``strix cloud workspaces use``. Returns an exit code."""
console = Console()
parser = CloudArgumentParser(
prog="strix cloud workspaces use",
description="Switch the stored API token to another workspace.",
)
parser.add_argument(
"workspace",
metavar="WORKSPACE",
help="Workspace number from `workspaces list`, ID, or exact name.",
)
scope_mode = parser.add_mutually_exclusive_group()
scope_mode.add_argument(
"--scopes",
nargs="+",
metavar="SCOPE",
default=None,
help=(
"Use a custom scope set within the login-approved ceiling. "
"Without this option, preserve the server-side scope preference."
),
)
scope_mode.add_argument(
"--scope-profile",
choices=("minimal", "recommended", "full"),
default=None,
help="Change to a profile within the authority approved at login.",
)
parser.add_argument("--show-scopes", action="store_true", help="Print every granted scope.")
parser.add_argument("--json", action="store_true", help="Print the raw JSON response.")
parser.add_argument("--token", default=None, help="API token override.")
parser.add_argument(
"--workspace-id",
default=None,
metavar="ORG_ID",
help="Expected workspace for an override CLI token.",
)
parser.add_argument("--app-url", default=None, metavar="URL", help="Platform URL override.")
parser.add_argument(
"--timeout", default=None, type=float, metavar="SECONDS", help="Request timeout in seconds."
)
as_json = json_mode(flag="--json" in argv)
try:
args = parser.parse_args(argv)
except SystemExit as exc:
return exc.code if isinstance(exc.code, int) else 2
except http.CloudError as exc:
_emit_cloud_error(console, exc, as_json=as_json)
return exc.exit_code
as_json = json_mode(flag=bool(args.json))
try:
http.configure(
base_url=args.app_url,
timeout=args.timeout,
token_override=bool(args.token),
workspace_id=args.workspace_id,
)
return _use(console, args, as_json=as_json)
except http.CloudError as exc:
_emit_cloud_error(console, exc, as_json=as_json)
return exc.exit_code
def _use( # noqa: PLR0912, PLR0915
console: Console, args: argparse.Namespace, *, as_json: bool
) -> int:
workspace = _find_workspace(args.workspace, token=args.token)
stored_record: dict[str, Any] = read_record() or {}
# An override token may belong to a different account. Never mix its new
# workspace state with identity or scope preferences from the stored sign-in.
external_token = args.token is not None or bool(os.environ.get("STRIX_API_TOKEN", "").strip())
record: dict[str, Any] = {} if external_token else dict(stored_record)
body: dict[str, Any] = {}
if args.scopes:
body["scopes"] = args.scopes
body["scope_profile"] = "custom"
elif args.scope_profile:
body["scope_profile"] = args.scope_profile
if not external_token:
try:
body.update(read_or_create_identity())
except (OSError, ValueError) as exc:
raise http.CloudError(f"could not load the CLI device identity: {exc}") from exc
switched = _switch_workspace_token(
str(workspace["id"]),
token=args.token,
body=body or None,
)
if not isinstance(switched, dict):
raise _workspace_switch_unknown("the platform returned an invalid response")
switched_record = cast("dict[str, Any]", switched)
switched_token = switched_record.get("api_token")
if not isinstance(switched_token, str) or not switched_token.strip():
raise _workspace_switch_unknown("the platform response omitted the token")
switched_scopes = switched_record.get("scopes")
switched_scope_items = cast("list[Any]", cast("Any", switched_scopes))
if not isinstance(switched_scopes, list) or not all(
isinstance(scope, str) for scope in switched_scope_items
):
raise _workspace_switch_unknown("the platform response contained invalid scopes")
validated_scopes = cast("list[str]", switched_scope_items)
record.update(
{
"api_token": switched_token,
"organization_id": switched_record.get("organization_id", workspace["id"]),
"organization_name": switched_record.get(
"organization_name", workspace.get("name", "")
),
"expires_at": switched_record.get("expires_at") or stored_record.get("expires_at"),
"scopes": validated_scopes,
"requested_scopes": switched_record.get("requested_scopes", validated_scopes),
"scope_ceiling": switched_record.get("scope_ceiling", []),
"scope_profile": switched_record.get("scope_profile", "custom"),
"token_id": switched_record.get("token_id"),
"credential_source": switched_record.get("credential_source", "api"),
"device_name": switched_record.get("device_name"),
"app_url": http.app_url(),
}
)
if switched_record.get("email"):
record["email"] = switched_record["email"]
if not external_token:
try:
save_record(record)
except OSError as exc:
raise http.CloudError(
"the platform switched the token, but the local workspace metadata could not be "
f"stored in {AUTH_PATH}: {exc}. The bearer is still valid; fix the file and safely "
"rerun the same workspace use command.",
payload={
"workspace_switched": True,
"local_record_updated": False,
"retry_safe": True,
},
) from exc
result = {
"workspace_id": record["organization_id"],
"workspace_name": record["organization_name"],
"scopes": record["scopes"],
"requested_scopes": record.get("requested_scopes", record["scopes"]),
"scope_ceiling": record.get("scope_ceiling", []),
"scope_profile": record.get("scope_profile", "custom"),
"expires_at": record.get("expires_at"),
"token_id": record.get("token_id"),
"credential_source": record.get("credential_source", "api"),
"device_name": record.get("device_name"),
"stored": not external_token,
}
if as_json:
emit(console, result, as_json=True)
return http.EXIT_OK
workspace_name = escape(sanitize_terminal_text(record["organization_name"]))
console.print(f"[green]✓ Switched to workspace [bold]{workspace_name}[/].[/]")
scopes = record.get("scopes")
if isinstance(scopes, list) and scopes:
scope_items = cast("list[Any]", cast("Any", scopes))
scope_names = [scope for scope in scope_items if isinstance(scope, str)]
if scope_names and args.show_scopes:
rendered_scopes = escape(sanitize_terminal_text(" ".join(scope_names)))
console.print(f" Scopes: [dim]{rendered_scopes}[/]")
elif scope_names:
profile = str(record.get("scope_profile") or "custom").title()
console.print(f" Access: [dim]{profile} · {len(scope_names)} scopes granted[/]")
if external_token:
console.print(" Token: [dim]override used for this command only; not stored[/]")
else:
console.print(f" Token: stored in [dim]{escape(sanitize_terminal_text(AUTH_PATH))}[/]")
return http.EXIT_OK
def _switch_workspace_token(
workspace_id: str,
*,
token: str | None,
body: dict[str, Any] | None,
) -> Any:
"""Switch in place, distinguishing definitive rejections from lost outcomes."""
try:
response = http.request(
"POST",
f"/workspaces/{workspace_id}/token",
token=token,
body=body,
)
except http.CloudError as exc:
raise _workspace_switch_unknown(str(exc)) from exc
# Client/auth/conflict responses prove the rotation did not return success.
# A 5xx or malformed success may arrive after the database commit, but the
# server preserves the bearer so replaying this exact command is safe.
if response.status_code in {400, 401, 403, 404, 409, 422}:
return http.check(response)
try:
return http.check(response)
except http.CloudError as exc:
raise _workspace_switch_unknown(str(exc)) from exc
def _workspace_switch_unknown(detail: str) -> http.CloudError:
return http.CloudError(
"workspace switch outcome is unknown: "
f"{sanitize_terminal_text(detail)}. The bearer secret is unchanged; safely rerun the "
"same workspace use command, or list workspaces to check the current one.",
payload={
"switch_outcome_unknown": True,
"retry_safe": True,
},
)
def _emit_cloud_error(console: Console, error: http.CloudError, *, as_json: bool) -> None:
if as_json:
raw_payload: Any = error.payload
error_payload = cast("dict[str, Any]", raw_payload)
payload = dict(error_payload) if isinstance(raw_payload, dict) else {}
payload["error"] = str(error)
emit(console, payload, as_json=True)
return
console.print(f"[red]Error:[/] {escape(sanitize_terminal_text(error))}")
def _find_workspace(selector: str, *, token: str | None) -> dict[str, Any]:
listed = http.check(http.request("GET", "/workspaces", token=token))
listed_record = cast("dict[str, Any]", listed) if isinstance(listed, dict) else {}
items = listed_record.get("workspaces")
item_values = cast("list[Any]", cast("Any", items)) if isinstance(items, list) else []
workspaces = [
cast("dict[str, Any]", cast("Any", item)) for item in item_values if isinstance(item, dict)
]
if not workspaces:
raise http.CloudError("no workspaces found for this account.")
wanted = selector.strip()
if wanted.isdigit():
index = int(wanted)
if 1 <= index <= len(workspaces):
return workspaces[index - 1]
raise http.CloudError(
f"workspace number must be between 1 and {len(workspaces)}. "
"Run `strix cloud workspaces` to see the numbered list."
)
by_id = [w for w in workspaces if w.get("id") == wanted]
if by_id:
return by_id[0]
by_name = [w for w in workspaces if str(w.get("name", "")).casefold() == wanted.casefold()]
if len(by_name) == 1:
return by_name[0]
if len(by_name) > 1:
numbers = ", ".join(
str(index)
for index, workspace in enumerate(workspaces, start=1)
if workspace in by_name
)
raise http.CloudError(
f"multiple workspaces are named {wanted!r}. Use its list number: {numbers}"
)
names = ", ".join(
f"{index}: {workspace.get('name')}" for index, workspace in enumerate(workspaces, start=1)
)
raise http.CloudError(f"no workspace matches {wanted!r}. Your workspaces: {names}")

373
strix/interface/completions.py Normal file
View file

@ -0,0 +1,373 @@
"""Shell completion scripts and candidates for the Strix CLI."""
from __future__ import annotations
import sys
from pathlib import Path
from typing import Any
from strix.interface.cloud.spec import DEFAULT_VERBS, SPEC, Cmd
from strix.interface.terminal_text import has_terminal_control, sanitize_terminal_text
_ROOT_COMMANDS = ("cloud", "auth", "view", "completions", "completion")
_SESSION_COMMANDS = ("login", "logout", "whoami", "session", "credits")
_COMMON_FLAGS = (
"--json",
"--token",
"--workspace-id",
"--app-url",
"--timeout",
"-h",
"--help",
)
_COMMON_VALUE_FLAGS = frozenset({"--token", "--workspace-id", "--app-url", "--timeout"})
_WORKSPACE_USE_FLAGS = (*_COMMON_FLAGS, "--scopes", "--scope-profile", "--show-scopes")
def run_completions(argv: list[str]) -> int:
"""Print a shell integration script or hidden completion candidates."""
if argv and argv[0] == "--candidates":
for candidate in completion_candidates(argv[1:]):
sys.stdout.write(candidate + "\n")
return 0
if not argv or argv[0] in ("-h", "--help", "help"):
sys.stdout.write(
"Usage: strix completions <zsh|bash|fish>\n\n"
"Enable tab completion for the current shell:\n"
" zsh: source <(strix completions zsh)\n"
" bash: source <(strix completions bash)\n"
" fish: strix completions fish | source\n"
)
return 0
shell = argv[0].lower()
scripts = {"zsh": _zsh_script, "bash": _bash_script, "fish": _fish_script}
generator = scripts.get(shell)
if generator is None:
sys.stderr.write(
f"Unknown shell: {sanitize_terminal_text(shell)}. Choose zsh, bash, or fish.\n"
)
return 2
sys.stdout.write(generator())
return 0
def completion_candidates(words: list[str]) -> list[str]:
"""Return candidates for words after the ``strix`` executable."""
prior, current = _split_cursor(words)
if not prior:
candidates = _matching(_ROOT_COMMANDS, current)
elif prior[0] != "cloud":
candidates = []
else:
candidates = _cloud_candidates(prior[1:], current)
# The line-oriented shell protocol cannot represent these names safely.
# Omitting them is preferable to returning a sanitized path that does not exist.
return [candidate for candidate in candidates if not has_terminal_control(candidate)]
def _split_cursor(words: list[str]) -> tuple[list[str], str]:
if not words:
return [], ""
return words[:-1], words[-1]
def _cloud_candidates(prior: list[str], current: str) -> list[str]: # noqa: PLR0911
groups = (*_SESSION_COMMANDS, *SPEC, "workspace")
if not prior:
return _matching(groups, current)
group = "workspaces" if prior[0] == "workspace" else prior[0]
rest = prior[1:]
if group in _SESSION_COMMANDS:
return _session_candidates(group, rest, current)
commands = SPEC.get(group)
if commands is None:
return _matching(groups, current)
default_verb = DEFAULT_VERBS.get(group)
default_is_active = (rest and rest[0].startswith("-")) or (not rest and current.startswith("-"))
if default_verb is not None and default_is_active:
return _command_candidates(commands[default_verb], rest, current)
command_paths = sorted(
((verb.split(), cmd) for verb, cmd in commands.items()),
key=lambda item: len(item[0]),
reverse=True,
)
for path, cmd in command_paths:
if rest[: len(path)] == path:
command_candidates = _command_candidates(cmd, rest[len(path) :], current)
if rest == path:
nested_words = {
candidate_path[len(path)]
for candidate_path, _candidate_cmd in command_paths
if len(candidate_path) > len(path) and candidate_path[: len(path)] == path
}
return sorted({*command_candidates, *_matching(nested_words, current)})
return command_candidates
if group == "workspaces" and rest[:1] == ["use"]:
return _flag_candidates(
_WORKSPACE_USE_FLAGS,
rest[1:],
current,
value_flags=_COMMON_VALUE_FLAGS | {"--scopes"},
)
verb_paths = [path for path, _cmd in command_paths]
if group == "workspaces":
verb_paths.append(["use"])
matching_paths = [path for path in verb_paths if path[: len(rest)] == rest]
if not matching_paths:
return []
next_words = sorted({path[len(rest)] for path in matching_paths if len(path) > len(rest)})
return _matching(next_words, current)
def _session_candidates(group: str, prior: list[str], current: str) -> list[str]:
if group == "session":
if not prior:
return _matching(("show", "scopes", "help", *_COMMON_FLAGS, "--show-scopes"), current)
if prior[:1] == ["scopes"] and len(prior) == 1:
return _matching(("set", *_COMMON_FLAGS, "--show-scopes"), current)
if prior[:2] == ["scopes", "set"]:
return _matching(
("minimal", "recommended", "full", "--scopes", *_COMMON_FLAGS, "--show-scopes"),
current,
)
return _flag_candidates(
(*_COMMON_FLAGS, "--show-scopes"),
prior,
current,
value_flags=_COMMON_VALUE_FLAGS | {"--scopes"},
)
flags = _session_flags(group)
value_flags: frozenset[str] = frozenset()
if group == "login":
value_flags = frozenset({"--scopes", "--scope-profile", "--workspace", "--device-name"})
elif group == "credits":
value_flags = _COMMON_VALUE_FLAGS
return _flag_candidates(flags, prior, current, value_flags=value_flags)
def _session_flags(group: str) -> tuple[str, ...]:
if group == "login":
return (
"--no-browser",
"--scopes",
"--scope-profile",
"--workspace",
"--device-name",
"-h",
"--help",
)
if group == "whoami":
return ("--json", "--show-scopes", "-h", "--help")
if group == "logout":
return ("--json", "--local-only", "-h", "--help")
if group == "credits":
return _COMMON_FLAGS
return ("-h", "--help")
def _command_candidates(cmd: Cmd, prior: list[str], current: str) -> list[str]:
filesystem = _filesystem_candidates(cmd, prior, current)
if filesystem is not None:
return filesystem
return _flag_candidates(
_command_flags(cmd),
prior,
current,
value_flags=_command_value_flags(cmd),
)
def _flag_candidates(
flags: tuple[str, ...],
prior: list[str],
current: str,
*,
value_flags: frozenset[str],
) -> list[str]:
if prior and prior[-1] in value_flags and not current.startswith("-"):
return []
return _matching(flags, current)
def _command_flags(cmd: Cmd) -> tuple[str, ...]:
flags: list[str] = list(_COMMON_FLAGS)
for param in cmd.query + cmd.body:
flag = "--" + (param.flag or _kebab(param.name))
flags.append(flag)
if param.kind == "bool":
flags.append("--no-" + flag.removeprefix("--"))
if cmd.method in ("POST", "PUT", "PATCH"):
flags.append("--data")
if cmd.idempotent:
flags.append("--idempotency-key")
if cmd.binary or cmd.path == "/audit":
flags.extend(("--output", "--force"))
if cmd.link:
flags.append("--no-browser")
if cmd.wait_path or cmd.wait_self:
flags.extend(("--wait", "--wait-timeout"))
if cmd.path == "/billing/topup":
flags.extend(("--yes", "--no-pay", "--payment-method"))
if cmd.path == "/scans" and cmd.method == "POST":
flags.extend(
(
"--source",
"--approve-sha256",
"--dry-run",
"--yes",
"--show-files",
"--exclude",
"--include-hidden",
"--include-sensitive",
"--include-archives",
)
)
if cmd.path == "/billing/auto-topup" and cmd.method == "PUT":
flags.append("--no-monthly-cap")
return tuple(dict.fromkeys(flags))
def _command_value_flags(cmd: Cmd) -> frozenset[str]:
flags = set(_COMMON_VALUE_FLAGS)
for param in cmd.query + cmd.body:
if param.kind != "bool":
flags.add("--" + (param.flag or _kebab(param.name)))
if cmd.method in ("POST", "PUT", "PATCH"):
flags.add("--data")
if cmd.idempotent:
flags.add("--idempotency-key")
if cmd.binary or cmd.path == "/audit":
flags.add("--output")
if cmd.wait_path or cmd.wait_self:
flags.add("--wait-timeout")
if cmd.path == "/billing/topup":
flags.add("--payment-method")
if cmd.path == "/scans" and cmd.method == "POST":
flags.update(("--source", "--approve-sha256", "--exclude"))
return frozenset(flags)
def _filesystem_candidates( # noqa: PLR0911
cmd: Cmd, prior: list[str], current: str
) -> list[str] | None:
inline = (
("--source=", True, ""),
("--output=", False, ""),
("--data=@", False, "@"),
)
for option, directories_only, marker in inline:
if current.startswith(option):
value = current.removeprefix(option)
return [
option + candidate.removeprefix(marker)
for candidate in _path_candidates(
marker + value,
directories_only=directories_only,
marker=marker,
)
]
if not prior or current.startswith("-"):
return None
option = prior[-1]
if option == "--source" and cmd.path == "/scans" and cmd.method == "POST":
return _path_candidates(current, directories_only=True)
if option == "--output" and (cmd.binary or cmd.path == "/audit"):
return _path_candidates(current)
if option == "--data" and cmd.method in ("POST", "PUT", "PATCH"):
if not current:
return ["@"]
if current.startswith("@"):
return _path_candidates(current, marker="@")
return []
return None
def _path_candidates(
value: str,
*,
directories_only: bool = False,
marker: str = "",
) -> list[str]:
raw = value.removeprefix(marker) if marker else value
ends_with_separator = raw.endswith(("/", "\\"))
expanded = Path(raw or ".").expanduser()
directory = expanded if ends_with_separator else expanded.parent
name_prefix = "" if ends_with_separator else expanded.name
raw_base = raw if ends_with_separator else raw[: len(raw) - len(name_prefix)]
try:
entries = directory.iterdir()
matches = [
entry
for entry in entries
if entry.name.startswith(name_prefix) and (not directories_only or entry.is_dir())
]
except OSError:
return []
candidates: list[str] = []
for entry in sorted(matches, key=lambda item: item.name.casefold()):
candidate = marker + raw_base + entry.name
if entry.is_dir():
candidate += "/"
candidates.append(candidate)
return candidates
def _kebab(value: str) -> str:
output: list[str] = []
for char in value:
if char.isupper():
output.extend(("-", char.lower()))
else:
output.append("-" if char == "_" else char)
return "".join(output)
def _matching(candidates: Any, prefix: str) -> list[str]:
return sorted({str(candidate) for candidate in candidates if str(candidate).startswith(prefix)})
def _zsh_script() -> str:
return r"""#compdef strix
_strix() {
local -a candidates
candidates=("${(@f)$($words[1] completions --candidates "${words[@]:2}")}")
_describe 'strix' candidates
}
compdef _strix strix
"""
def _bash_script() -> str:
return r"""_strix_completion() {
local -a candidates
local candidate
while IFS= read -r candidate; do
candidates+=("$candidate")
done < <(strix completions --candidates "${COMP_WORDS[@]:1:$COMP_CWORD}")
COMPREPLY=("${candidates[@]}")
for candidate in "${COMPREPLY[@]}"; do
if [[ $candidate == */ ]]; then
if type compopt >/dev/null 2>&1; then
compopt -o nospace
fi
break
fi
done
}
complete -F _strix_completion strix
"""
def _fish_script() -> str:
return r"""function __strix_candidates
set -l words (commandline -opc)
set -e words[1]
command strix completions --candidates $words (commandline -ct)
end
complete -c strix -f -a '(__strix_candidates)'
"""

28
strix/interface/main.py
View file

@ -62,6 +62,14 @@ import logging # noqa: E402
logger = logging.getLogger(__name__)
_ROOT_SUBCOMMAND_HELP = """
Additional commands:
strix cloud ... Use the managed Strix platform
strix auth ... Manage model-subscription sign-in
strix view [RUN] View a completed or running scan
strix completions SHELL Generate zsh, bash, or fish tab completion
"""
def _exception_messages(exc: BaseException) -> tuple[str, ...]:
messages: list[str] = []
@ -410,6 +418,13 @@ def main() -> None:
if sys.platform == "win32":
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
if len(sys.argv) == 2 and sys.argv[1] in ("-h", "--help"):
try:
parse_arguments()
except SystemExit as exc:
Console().print(_ROOT_SUBCOMMAND_HELP.strip(), markup=False)
raise SystemExit(exc.code) from None
# `strix view [<run>]` is a viewer-only subcommand, dispatched before the
# scan argument parser (which requires a target) and before any scan setup.
if len(sys.argv) > 1 and sys.argv[1] == "view":
@ -425,6 +440,19 @@ def main() -> None:
sys.exit(run_auth(sys.argv[2:]))
# Generate native shell completion scripts before scan argument parsing.
if len(sys.argv) > 1 and sys.argv[1] in ("completion", "completions"):
from strix.interface.completions import run_completions
sys.exit(run_completions(sys.argv[2:]))
# `strix cloud …` drives the managed platform (app.strix.ai) and exits;
# it needs no target, Docker, or scan setup.
if len(sys.argv) > 1 and sys.argv[1] == "cloud":
from strix.interface.cloud import run_cloud
sys.exit(run_cloud(sys.argv[2:]))
from strix.llm.warmup import start_import_warmup
start_import_warmup()

798
strix/interface/platform_cli.py Normal file
View file

@ -0,0 +1,798 @@
"""`strix cloud login` — managed platform sign-in (app.strix.ai).
Signing in runs an OAuth 2.0 device authorization flow in the browser, creates
the Strix account and workspace when they do not exist yet, and stores a
personal API token in ``~/.strix/platform-auth.json``. The token drives the
managed REST API (scans, credits, top-ups) without a dashboard visit.
"""
from __future__ import annotations
import argparse
import contextlib
import json
import sys
import time
import webbrowser
from pathlib import Path
from typing import Any, NoReturn, cast
from urllib.parse import urlparse, urlsplit, urlunsplit
import requests
from rich.console import Console
from rich.markup import escape
from rich.panel import Panel
from rich.text import Text
from strix.config import load_settings
from strix.interface.platform_identity import read_or_create_identity
from strix.interface.terminal_text import sanitize_terminal_text
from strix.interface.url_safety import is_safe_web_url
from strix.utils.secret_files import write_secret_text
AUTH_PATH = Path.home() / ".strix" / "platform-auth.json"
_HTTP_TIMEOUT_S = 30
_DEFAULT_POLL_INTERVAL_S = 5
_MAX_POLL_INTERVAL_S = 60
_MAX_EXPIRES_IN_S = 30 * 60
_ROLE_RANK = {"viewer": 0, "analyst": 1, "admin": 2}
class PlatformAuthError(Exception):
"""Raised when the device authorization flow fails."""
class _SessionUsageError(Exception):
"""A session subcommand received invalid arguments."""
class _SessionArgumentParser(argparse.ArgumentParser):
def error(self, message: str) -> NoReturn:
raise _SessionUsageError(f"invalid arguments for {self.prog}: {message}")
def _terminal_markup(value: object) -> str:
return escape(sanitize_terminal_text(value))
def _app_url() -> str:
return load_settings().viewer.app_url.rstrip("/")
def read_record() -> dict[str, Any] | None:
try:
data = json.loads(AUTH_PATH.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError):
return None
if not isinstance(data, dict):
return None
record = cast("dict[str, Any]", data)
if not record.get("api_token"):
return None
return record
def save_record(record: dict[str, Any]) -> None:
write_secret_text(AUTH_PATH, json.dumps(record, indent=2))
def logout() -> bool:
try:
AUTH_PATH.unlink()
except FileNotFoundError:
return True
except OSError:
return False
return True
def run_login(argv: list[str]) -> int:
"""Entry point for ``strix cloud login``. Returns a process exit code."""
console = Console()
subcommand = argv[0] if argv else None
if subcommand == "status":
return _status(console, argv[1:])
if subcommand == "logout":
return _logout(console, argv[1:])
return _login(console, argv)
def _login(console: Console, argv: list[str]) -> int:
parser = argparse.ArgumentParser(prog="strix cloud login", add_help=True)
parser.add_argument(
"--no-browser",
action="store_true",
help="Do not open the browser. Print the verification URL instead.",
)
scope_mode = parser.add_mutually_exclusive_group()
scope_mode.add_argument(
"--scopes",
nargs="+",
metavar="SCOPE",
default=None,
help=(
"API scopes for the token, for example scans:read billing:write. "
"The server always includes a minimum scope set. "
"Without this option, an interactive picker opens after the browser step."
),
)
scope_mode.add_argument(
"--scope-profile",
choices=("minimal", "recommended", "full"),
default=None,
help="Scope profile to approve. Defaults to an interactive choice in a TTY.",
)
parser.add_argument(
"--device-name",
default=None,
metavar="NAME",
help="Privacy-safe label shown for this CLI session in the dashboard.",
)
parser.add_argument(
"--workspace",
metavar="WORKSPACE",
default=None,
help=(
"Workspace that receives the token, by ID or by exact name. "
"Without this option, an interactive picker opens when you have "
"more than one workspace."
),
)
previous_record = read_record()
try:
args = parser.parse_args(argv)
except SystemExit as exc: # argparse already printed the message
return exc.code if isinstance(exc.code, int) else 2
console.print()
host = urlparse(_app_url()).netloc or _app_url()
console.print(f"[bold]Signing in to the Strix platform[/] [dim]({_terminal_markup(host)})[/]")
console.print(
"[dim]This creates your account and workspace when needed, and stores an API token.[/]"
)
console.print()
try:
record = _run_device_flow(
console,
open_browser=not args.no_browser,
scopes=args.scopes,
scope_profile=args.scope_profile,
workspace=args.workspace,
device_name=args.device_name,
)
except PlatformAuthError as exc:
console.print(f"[red]Sign-in failed:[/] {_terminal_markup(exc)}")
return 1
except KeyboardInterrupt:
console.print("\n[yellow]Sign-in cancelled.[/]")
return 130
try:
save_record(record)
except OSError as exc:
console.print(
f"[red]Sign-in succeeded, but the token could not be stored:[/] {_terminal_markup(exc)}"
)
console.print(
f"[dim]Check that {_terminal_markup(AUTH_PATH.parent)} is writable, "
"then run `strix cloud login` again.[/]"
)
return 1
_revoke_replaced_legacy_session(previous_record, record)
_print_success(console, record)
return 0
def _run_device_flow( # noqa: PLR0912, PLR0915
console: Console,
*,
open_browser: bool,
scopes: list[str] | None = None,
scope_profile: str | None = None,
workspace: str | None = None,
device_name: str | None = None,
) -> dict[str, Any]:
app_url = _app_url()
interactive = workspace is not None or (
sys.stdin.isatty() and scopes is None and scope_profile is None
)
try:
identity = read_or_create_identity(device_name=device_name)
except (OSError, ValueError) as exc:
raise PlatformAuthError(f"could not prepare the CLI device identity: {exc}") from exc
try:
response = requests.post(
f"{app_url}/api/v1/cli/login",
timeout=_HTTP_TIMEOUT_S,
allow_redirects=False,
)
except requests.RequestException as exc:
raise PlatformAuthError(f"could not reach {app_url}: {exc}") from exc
if not 200 <= response.status_code < 300:
raise PlatformAuthError(_error_detail(response))
authorization = _json_object(response)
user_code = str(authorization.get("user_code") or "")
verification_uri = str(
authorization.get("verification_uri_complete")
or authorization.get("verification_uri")
or ""
)
device_code = str(authorization.get("device_code") or "")
expires_in = _as_positive_int(
authorization.get("expires_in"), default=300, maximum=_MAX_EXPIRES_IN_S
)
interval = _as_positive_int(
authorization.get("interval"),
default=_DEFAULT_POLL_INTERVAL_S,
maximum=_MAX_POLL_INTERVAL_S,
)
if not device_code or not verification_uri:
raise PlatformAuthError("the server returned an incomplete device authorization")
if not is_safe_web_url(verification_uri, trusted_origin=app_url):
raise PlatformAuthError("the server returned an invalid verification URL")
console.print(
Panel.fit(
Text.assemble(
("Confirmation code: ", "dim"),
(sanitize_terminal_text(user_code), "bold cyan"),
),
title="Verify this device",
)
)
console.print("Open this URL in your browser and confirm the code:")
console.print(sanitize_terminal_text(verification_uri), markup=False, soft_wrap=True)
if open_browser:
with contextlib.suppress(Exception):
webbrowser.open(verification_uri)
console.print("[dim]Waiting for browser confirmation…[/]")
poll_body: dict[str, Any] = {"device_code": device_code, **identity}
if interactive:
poll_body["interactive"] = True
elif scopes:
poll_body["scopes"] = scopes
elif scope_profile:
poll_body["scope_profile"] = scope_profile
deadline = time.monotonic() + expires_in
while time.monotonic() < deadline:
remaining = deadline - time.monotonic()
if remaining <= 0:
break
time.sleep(min(interval, remaining))
try:
poll = requests.post(
f"{app_url}/api/v1/cli/login/poll",
json=poll_body,
timeout=_HTTP_TIMEOUT_S,
allow_redirects=False,
)
except requests.RequestException:
continue
if 200 <= poll.status_code < 300:
return _finish_login(
console,
app_url,
poll,
scopes=scopes,
scope_profile=scope_profile,
workspace=workspace,
)
delta = _handle_poll_error(poll)
if delta is None:
break
interval = min(interval + delta, _MAX_POLL_INTERVAL_S)
raise PlatformAuthError("the sign-in request expired. Run `strix cloud login` again.")
def _handle_poll_error(poll: requests.Response) -> int | None:
"""Return the interval increase, or None when the device code expired."""
error = ""
with contextlib.suppress(ValueError, AttributeError):
error = str(poll.json().get("error", ""))
if error == "authorization_pending":
return 0
if error == "slow_down":
return 5
if error == "access_denied":
raise PlatformAuthError("the sign-in request was denied in the browser")
if error == "expired_token":
return None
raise PlatformAuthError(_error_detail(poll))
def _finish_login(
console: Console,
app_url: str,
poll: requests.Response,
*,
scopes: list[str] | None,
scope_profile: str | None,
workspace: str | None,
) -> dict[str, Any]:
result = _json_object(poll)
if result.get("selection_required"):
return _complete_selection(
console,
app_url,
result,
scopes=scopes,
scope_profile=scope_profile,
workspace=workspace,
)
return _bind_login_record(_require_api_token(result), app_url)
def _signed_in_record(
response: requests.Response,
*,
app_url: str,
) -> dict[str, Any]:
return _bind_login_record(
_require_api_token(_json_object(response)),
app_url,
)
def _require_api_token(record: dict[str, Any]) -> dict[str, Any]:
api_token = record.get("api_token")
if not isinstance(api_token, str) or not api_token.strip():
raise PlatformAuthError("the server returned a sign-in response without an API token")
return record
def _bind_login_record(record: dict[str, Any], app_url: str) -> dict[str, Any]:
"""Bind a stored credential to its issuer and preserve its scope preference."""
parsed = urlsplit(app_url)
if (
parsed.scheme not in {"http", "https"}
or not parsed.netloc
or parsed.username is not None
or parsed.password is not None
or parsed.query
or parsed.fragment
or "\\" in app_url
or any(character.isspace() for character in app_url)
or "%" in parsed.netloc
):
raise PlatformAuthError("the configured platform URL is invalid")
bound = dict(record)
bound["app_url"] = urlunsplit(
(parsed.scheme.lower(), parsed.netloc.lower(), parsed.path.rstrip("/"), "", "")
)
preference: Any = record.get("requested_scopes", record.get("scopes"))
preference_items = cast("list[Any]", preference)
if isinstance(preference, list) and all(isinstance(scope, str) for scope in preference_items):
bound["requested_scopes"] = list(dict.fromkeys(cast("list[str]", preference_items)))
return bound
def _complete_selection(
console: Console,
app_url: str,
selection: dict[str, Any],
*,
scopes: list[str] | None,
scope_profile: str | None,
workspace: str | None,
) -> dict[str, Any]:
organizations = _dict_items(selection.get("organizations"))
catalog = _dict_items(selection.get("scopes"))
selection_token = str(selection.get("selection_token") or "")
if not selection_token or not organizations:
raise PlatformAuthError("the server returned an incomplete selection response")
chosen_org = _choose_workspace(console, organizations, workspace)
role = str(chosen_org.get("role") or "admin")
chosen_scopes = scopes
chosen_profile = scope_profile
if chosen_scopes is None and chosen_profile is None and sys.stdin.isatty():
chosen_profile, chosen_scopes = _choose_scopes(console, catalog, role)
body: dict[str, Any] = {
"selection_token": selection_token,
"organization_id": chosen_org.get("id"),
}
if chosen_scopes is not None:
body["scopes"] = chosen_scopes
body["scope_profile"] = "custom"
elif chosen_profile is not None:
body["scope_profile"] = chosen_profile
try:
response = requests.post(
f"{app_url}/api/v1/cli/login/complete",
json=body,
timeout=_HTTP_TIMEOUT_S,
allow_redirects=False,
)
except requests.RequestException as exc:
raise PlatformAuthError(f"could not reach {app_url}: {exc}") from exc
if not 200 <= response.status_code < 300:
raise PlatformAuthError(_error_detail(response))
return _signed_in_record(
response,
app_url=app_url,
)
def _dict_items(value: Any) -> list[dict[str, Any]]:
if not isinstance(value, list):
return []
items = cast("list[Any]", cast("Any", value))
return [cast("dict[str, Any]", cast("Any", item)) for item in items if isinstance(item, dict)]
def _choose_workspace(
console: Console, organizations: list[dict[str, Any]], workspace: str | None
) -> dict[str, Any]:
if workspace is not None:
wanted = workspace.strip().casefold()
by_id = [org for org in organizations if str(org.get("id", "")).casefold() == wanted]
if by_id:
return by_id[0]
by_name = [
org for org in organizations if str(org.get("name", "")).strip().casefold() == wanted
]
if len(by_name) == 1:
return by_name[0]
if len(by_name) > 1:
matching_ids = ", ".join(str(org.get("id", "")) for org in by_name)
raise PlatformAuthError(
f"multiple workspaces are named {workspace!r}; use an exact workspace ID: "
f"{matching_ids}"
)
names = ", ".join(str(org.get("name", "")) for org in organizations)
raise PlatformAuthError(f"no workspace matches {workspace!r}. Your workspaces: {names}")
if len(organizations) == 1:
return organizations[0]
if not sys.stdin.isatty():
choices = ", ".join(f"{org.get('name', '')} ({org.get('id', '')})" for org in organizations)
raise PlatformAuthError(
"more than one workspace is available; rerun with --workspace NAME_OR_ID. "
f"Available workspaces: {choices}"
)
console.print()
console.print("[bold]Select a workspace for the API token:[/]")
for index, org in enumerate(organizations, start=1):
name = _terminal_markup(org.get("name", ""))
org_role = _terminal_markup(org.get("role", ""))
console.print(f" [cyan]{index}[/]. {name} [dim]({org_role})[/]")
while True:
answer = console.input(f"Workspace [1-{len(organizations)}] (1): ").strip() or "1"
if answer.isdigit() and 1 <= int(answer) <= len(organizations):
return organizations[int(answer) - 1]
console.print("[yellow]Enter a number from the list.[/]")
def _choose_scopes(
console: Console, catalog: list[dict[str, Any]], role: str
) -> tuple[str, list[str] | None]:
"""Prompt for a named scope profile or a custom scope list."""
rank = _ROLE_RANK.get(role, 2)
allowed = [
item for item in catalog if _ROLE_RANK.get(str(item.get("min_role", "viewer")), 0) <= rank
]
if not allowed:
return "recommended", None
console.print()
console.print("[bold]Select token scopes:[/]")
console.print(
" [cyan]1[/]. Recommended [dim](scans, findings, schedules, assets, uploads, "
"workspace switching, billing/top-ups; no token creation)[/]"
)
console.print(" [cyan]2[/]. Full access [dim](every scope your role allows)[/]")
console.print(" [cyan]3[/]. Minimal [dim](scan read/write and billing read)[/]")
console.print(" [cyan]4[/]. Custom [dim](pick individual scopes)[/]")
while True:
answer = console.input("Scopes [1-4] (1): ").strip() or "1"
if answer == "1":
return "recommended", None
if answer == "2":
return "full", None
if answer == "3":
return "minimal", None
if answer == "4":
return "custom", _choose_custom_scopes(console, allowed)
console.print("[yellow]Enter a number from 1 to 4.[/]")
def _choose_custom_scopes(console: Console, allowed: list[dict[str, Any]]) -> list[str]:
selected = {
str(item["scope"])
for item in allowed
if item.get("scope") and (item.get("default") or item.get("minimum"))
}
while True:
console.print()
for index, item in enumerate(allowed, start=1):
scope = str(item.get("scope", ""))
mark = "[green]x[/]" if scope in selected else " "
required = " [dim](always included)[/]" if item.get("minimum") else ""
rendered_scope = _terminal_markup(scope)
description = _terminal_markup(item.get("description", ""))
console.print(
f" [{mark}] [cyan]{index:>2}[/]. {rendered_scope}{required}"
f"\n [dim]{description}[/]"
)
answer = console.input(
"Toggle scopes by number (comma separated), or press Enter to confirm: "
).strip()
if not answer:
return sorted(selected)
for part in answer.replace(",", " ").split():
if not part.isdigit() or not 1 <= int(part) <= len(allowed):
console.print(
f"[yellow]Ignored {_terminal_markup(part)!r}: not a number from the list.[/]"
)
continue
item = allowed[int(part) - 1]
scope = str(item.get("scope", ""))
if item.get("minimum"):
console.print(f"[yellow]{_terminal_markup(scope)} is always included.[/]")
continue
if scope in selected:
selected.discard(scope)
else:
selected.add(scope)
def _json_object(response: requests.Response) -> dict[str, Any]:
try:
data = response.json()
except ValueError as exc:
raise PlatformAuthError("the server returned a response that is not JSON") from exc
if not isinstance(data, dict):
raise PlatformAuthError("the server returned an unexpected response shape")
return cast("dict[str, Any]", data)
def _as_positive_int(value: Any, *, default: int, maximum: int) -> int:
try:
parsed = int(value)
except (TypeError, ValueError, OverflowError):
return default
if parsed <= 0:
return default
return min(parsed, maximum)
def _error_detail(response: requests.Response) -> str:
with contextlib.suppress(ValueError, AttributeError):
detail = response.json().get("detail")
if detail:
return str(detail)
return f"HTTP {response.status_code}"
def _session_headers(record: dict[str, Any]) -> dict[str, str]:
headers = {"Authorization": f"Bearer {record['api_token']}"}
workspace_id = record.get("organization_id")
if isinstance(workspace_id, str) and workspace_id:
headers["X-Strix-Workspace"] = workspace_id
return headers
def _revoke_stored_session(record: dict[str, Any]) -> tuple[bool, str | None]:
"""Revoke one server session; return (definitively_inactive, error)."""
app_url = record.get("app_url")
if not isinstance(app_url, str) or not app_url:
return False, (
"the stored sign-in has no trusted platform URL; use --local-only to remove it"
)
try:
response = requests.delete(
f"{app_url.rstrip('/')}/api/v1/cli/session",
headers=_session_headers(record),
timeout=_HTTP_TIMEOUT_S,
allow_redirects=False,
)
except requests.RequestException as exc:
return False, f"could not revoke the remote CLI session: {exc}"
if response.status_code in {200, 204, 401}:
return True, None
return False, f"could not revoke the remote CLI session: {_error_detail(response)}"
def _print_logout_failure(console: Console, message: str, *, as_json: bool) -> int:
if as_json:
sys.stdout.write(json.dumps({"error": message, "removed": False}) + "\n")
else:
console.print(f"[red]Sign-out failed:[/] {_terminal_markup(message)}")
console.print("[dim]The local token was kept so you can safely retry.[/]")
return 1
def _revoke_replaced_legacy_session(
previous: dict[str, Any] | None, current: dict[str, Any]
) -> None:
"""Best-effort cleanup when the first device-aware login replaces a legacy token."""
if not previous or previous.get("api_token") == current.get("api_token"):
return
if previous.get("app_url") != current.get("app_url"):
return
with contextlib.suppress(KeyError, requests.RequestException):
requests.delete(
f"{previous['app_url']}/api/v1/cli/session",
headers=_session_headers(previous),
timeout=_HTTP_TIMEOUT_S,
allow_redirects=False,
)
def _print_success(console: Console, record: dict[str, Any]) -> None:
email = record.get("email", "")
organization = record.get("organization_name") or record.get("organization_id", "")
console.print()
console.print("[green]✓ Signed in to the Strix platform.[/]")
if email:
console.print(f" Account: [bold]{_terminal_markup(email)}[/]")
if organization:
console.print(f" Workspace: [bold]{_terminal_markup(organization)}[/]")
scopes = record.get("scopes")
if isinstance(scopes, list) and scopes:
console.print(f" Access: [dim]{_terminal_markup(_scope_summary(record))}[/]")
console.print(f" Token: stored in [dim]{_terminal_markup(AUTH_PATH)}[/]")
console.print()
console.print(
"[dim]The managed platform is ready. Run `strix cloud` to list the commands. "
"See https://docs.app.strix.ai for the API reference.[/]"
)
def _status(console: Console, argv: list[str]) -> int: # noqa: PLR0912
parser = _SessionArgumentParser(
prog="strix cloud whoami",
description="Show the stored managed-platform account, workspace, scopes, and expiry.",
)
parser.add_argument("--json", action="store_true", help="Print the session as JSON.")
parser.add_argument("--show-scopes", action="store_true", help="Print every granted scope.")
as_json = "--json" in argv or not sys.stdout.isatty()
try:
args = parser.parse_args(argv)
except _SessionUsageError as exc:
if as_json:
sys.stdout.write(json.dumps({"error": str(exc)}) + "\n")
else:
console.print(f"[red]Error:[/] {_terminal_markup(exc)}")
return 2
except SystemExit as exc:
return exc.code if isinstance(exc.code, int) else 2
as_json = bool(args.json) or not sys.stdout.isatty()
record = read_record()
if record is None:
if as_json:
sys.stdout.write(json.dumps({"signed_in": False, "error": "Not signed in"}) + "\n")
return 1
console.print("[yellow]Not signed in.[/] Run [bold]strix cloud login[/] to sign in.")
return 1
email = record.get("email", "unknown")
organization = record.get("organization_name") or record.get("organization_id", "")
expires_at = record.get("expires_at", "")
if as_json:
payload = {
"signed_in": True,
"email": email,
"organization_id": record.get("organization_id"),
"organization_name": record.get("organization_name"),
"scopes": record.get("scopes", []),
"expires_at": expires_at or None,
**({"app_url": record["app_url"]} if record.get("app_url") else {}),
}
sys.stdout.write(json.dumps(payload, indent=2, default=str) + "\n")
return 0
console.print(f"[green]Signed in[/] as [bold]{_terminal_markup(email)}[/]")
if organization:
console.print(f" Workspace: {_terminal_markup(organization)}")
if expires_at:
console.print(f" Token expires: {_terminal_markup(expires_at)}")
if record.get("app_url"):
console.print(f" Platform: {_terminal_markup(record['app_url'])}")
scopes = record.get("scopes")
if isinstance(scopes, list) and scopes:
scope_items = cast("list[Any]", cast("Any", scopes))
if args.show_scopes:
console.print(
f" Scopes: {_terminal_markup(' '.join(str(scope) for scope in scope_items))}"
)
else:
console.print(f" Access: {_terminal_markup(_scope_summary(record))}")
return 0
def _scope_summary(record: dict[str, Any]) -> str:
scopes = record.get("scopes")
scope_items = cast("list[Any]", cast("Any", scopes)) if isinstance(scopes, list) else []
count = len(scope_items)
profile = str(record.get("scope_profile") or "custom").replace("_", " ").title()
return f"{profile} · {count} scope{'s' if count != 1 else ''} granted"
def _logout(console: Console, argv: list[str]) -> int: # noqa: PLR0911, PLR0912
parser = _SessionArgumentParser(
prog="strix cloud logout",
description="Revoke this CLI session and remove its token from this machine.",
)
parser.add_argument("--json", action="store_true", help="Print the result as JSON.")
parser.add_argument(
"--local-only",
action="store_true",
help="Remove only the local token, leaving the remote session active.",
)
as_json = "--json" in argv or not sys.stdout.isatty()
try:
args = parser.parse_args(argv)
except _SessionUsageError as exc:
if as_json:
sys.stdout.write(json.dumps({"error": str(exc)}) + "\n")
else:
console.print(f"[red]Error:[/] {_terminal_markup(exc)}")
return 2
except SystemExit as exc:
return exc.code if isinstance(exc.code, int) else 2
as_json = bool(args.json) or not sys.stdout.isatty()
if read_record() is None and not AUTH_PATH.exists():
if as_json:
sys.stdout.write(json.dumps({"signed_in": False, "removed": False}) + "\n")
return 0
console.print("[yellow]Not signed in.[/]")
return 0
record = read_record()
remotely_revoked = False
if record is not None and not args.local_only:
remotely_revoked, revoke_error = _revoke_stored_session(record)
if revoke_error:
return _print_logout_failure(console, revoke_error, as_json=as_json)
if not logout():
if as_json:
sys.stdout.write(
json.dumps(
{
"error": "Could not remove the stored API token",
"signed_in": True,
"removed": False,
}
)
+ "\n"
)
return 1
console.print(
f"[red]Could not remove the stored API token.[/] Delete "
f"{_terminal_markup(AUTH_PATH)} manually."
)
return 1
if as_json:
sys.stdout.write(
json.dumps(
{
"signed_in": False,
"removed": True,
"remotely_revoked": remotely_revoked,
"local_only": bool(args.local_only),
}
)
+ "\n"
)
return 0
if args.local_only:
console.print(
"[yellow]Local sign-out only.[/] The remote CLI session is still active; "
"revoke it from API Access if needed."
)
else:
console.print("[green]Signed out.[/] The CLI session was revoked and removed locally.")
return 0

46
strix/interface/platform_identity.py Normal file
View file

@ -0,0 +1,46 @@
"""Stable, privacy-safe identity for this Strix CLI installation."""
from __future__ import annotations
import json
import platform
from pathlib import Path
from typing import Any, cast
from uuid import uuid4
from strix.utils.secret_files import write_secret_text
IDENTITY_PATH = Path.home() / ".strix" / "cli-identity.json"
def _default_device_name(instance_id: str) -> str:
system = {"Darwin": "macOS", "Windows": "Windows", "Linux": "Linux"}.get(
platform.system(), "Computer"
)
return f"{system} CLI · {instance_id[:8]}"
def read_or_create_identity(*, device_name: str | None = None) -> dict[str, str]:
"""Return one installation ID, optionally updating its user-facing label."""
record: dict[str, Any] = {}
try:
raw = json.loads(IDENTITY_PATH.read_text(encoding="utf-8"))
if isinstance(raw, dict):
record = cast("dict[str, Any]", raw)
except (OSError, json.JSONDecodeError):
pass
instance_id = record.get("client_instance_id")
if not isinstance(instance_id, str) or len(instance_id) < 8:
instance_id = str(uuid4())
label = device_name.strip() if device_name is not None else record.get("device_name")
if not isinstance(label, str) or not label.strip():
label = _default_device_name(instance_id)
label = " ".join(label.split())
if not 1 <= len(label) <= 80:
raise ValueError("device name must be 1-80 printable characters")
identity = {"client_instance_id": instance_id, "device_name": label}
write_secret_text(IDENTITY_PATH, json.dumps(identity, indent=2))
return identity

21
strix/interface/terminal_text.py Normal file
View file

@ -0,0 +1,21 @@
"""Safe rendering of untrusted text in a terminal."""
from __future__ import annotations
import re
_TERMINAL_CONTROL = re.compile(r"[\x00-\x1f\x7f-\x9f]")
def has_terminal_control(value: object) -> bool:
"""Return whether text contains bytes that can alter terminal state/protocols."""
return _TERMINAL_CONTROL.search(str(value)) is not None
def sanitize_terminal_text(value: object) -> str:
"""Make C0/C1 control bytes visible so they cannot operate a terminal."""
return _TERMINAL_CONTROL.sub(
lambda match: f"\\x{ord(match.group()):02x}",
str(value),
)

85
strix/interface/url_safety.py Normal file
View file

@ -0,0 +1,85 @@
"""Validation for URLs printed or opened on behalf of a remote service."""
from __future__ import annotations
import ipaddress
from urllib.parse import SplitResult, urlsplit
from strix.interface.terminal_text import has_terminal_control
def is_safe_web_url(
value: object,
*,
trusted_origin: str | None = None,
require_trusted_origin: bool = False,
) -> bool:
"""Accept a strict HTTP(S) URL, optionally only on a pre-trusted origin."""
parsed = _parse(value)
if parsed is None:
return False
trusted = _parse(trusted_origin) if trusted_origin is not None else None
same_origin = trusted is not None and _origin(parsed) == _origin(trusted)
if require_trusted_origin:
return same_origin
if same_origin:
return True
return _is_safe_external_https(parsed)
def _is_safe_external_https(parsed: SplitResult) -> bool:
"""Reject local, numeric-looking, or otherwise ambiguous external hosts."""
hostname = (parsed.hostname or "").lower().rstrip(".")
if (
parsed.scheme != "https"
or hostname == "localhost"
or hostname.endswith((".localhost", ".local"))
):
return False
try:
return ipaddress.ip_address(hostname).is_global
except ValueError:
pass
labels = hostname.split(".")
return len(labels) >= 2 and not all(_looks_numeric(label) for label in labels)
def _parse(value: object) -> SplitResult | None:
if not isinstance(value, str) or not value or has_terminal_control(value):
return None
if "\\" in value or any(character.isspace() for character in value):
return None
try:
parsed = urlsplit(value)
port = parsed.port
except ValueError:
return None
hostname = parsed.hostname
if (
parsed.scheme not in {"http", "https"}
or not hostname
or parsed.username is not None
or parsed.password is not None
or parsed.fragment
or "%" in parsed.netloc
):
return None
try:
hostname.encode("ascii")
except UnicodeEncodeError:
return None
return parsed if port is None or 1 <= port <= 65535 else None
def _origin(parsed: SplitResult) -> tuple[str, str, int]:
default_port = 443 if parsed.scheme == "https" else 80
return parsed.scheme, (parsed.hostname or "").lower().rstrip("."), parsed.port or default_port
def _looks_numeric(label: str) -> bool:
lowered = label.lower()
if lowered.startswith("0x"):
return len(lowered) > 2 and all(
character in "0123456789abcdef" for character in lowered[2:]
)
return bool(lowered) and all(character.isdigit() for character in lowered)

25
strix/utils/secret_files.py
View file

@ -23,9 +23,26 @@ def write_secret_text(path: Path, text: str) -> None:
try:
with os.fdopen(fd, "w", encoding="utf-8") as handle:
handle.write(text)
except BaseException:
with contextlib.suppress(OSError):
tmp.unlink()
except BaseException as exc:
_cleanup_tmp(tmp, exc)
raise
tmp.replace(path)
try:
tmp.replace(path)
except BaseException as exc:
_cleanup_tmp(tmp, exc)
raise
def _cleanup_tmp(tmp: Path, cause: BaseException) -> None:
"""Delete the temporary secret file. A failed delete must not stay silent."""
try:
tmp.unlink()
except FileNotFoundError:
pass
except OSError:
message = (
f"could not store the secret, and the temporary file {tmp} "
f"still holds it. Delete the file manually."
)
raise OSError(message) from cause

5
tests/test_cli_target_list.py
View file

@ -228,7 +228,10 @@ def test_resume_still_requires_targets_or_a_workspace(
assert "has no targets_info" in capsys.readouterr().err
def test_resume_non_object_run_json_exits(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
def test_resume_non_object_run_json_exits(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
) -> None:
monkeypatch.chdir(tmp_path)
run_dir = tmp_path / "strix_runs" / "pentest_abcd"
run_dir.mkdir(parents=True)

3569
tests/test_cloud_cli.py Normal file
View file

File diff suppressed because it is too large Load diff

1119
tests/test_cloud_cli_runtime.py Normal file
View file

File diff suppressed because it is too large Load diff

203
tests/test_cloud_idempotency.py Normal file
View file

@ -0,0 +1,203 @@
"""Durable retry behavior for managed scan-launch commands."""
from __future__ import annotations
import json
from typing import Any
import pytest
from strix.interface import cloud
from strix.interface.cloud import http, runner
from strix.interface.completions import completion_candidates
class FakeResponse:
def __init__(self, payload: Any, *, status_code: int = 200) -> None:
self._payload = payload
self.status_code = status_code
self.headers = {"content-type": "application/json"}
self.text = json.dumps(payload)
self.closed = False
def json(self) -> Any:
return self._payload
def close(self) -> None:
self.closed = True
@pytest.fixture(autouse=True)
def _token(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("STRIX_API_TOKEN", "idempotency-test-token")
monkeypatch.setattr(runner.time, "sleep", lambda _seconds: None)
def test_scan_start_generates_and_sends_one_stable_key(
monkeypatch: pytest.MonkeyPatch,
capsys: Any,
) -> None:
seen: list[dict[str, Any]] = []
monkeypatch.setattr(runner, "uuid4", lambda: "generated-key")
def request(_method: str, _path: str, **kwargs: Any) -> FakeResponse:
seen.append(kwargs)
return FakeResponse({"scan_id": "scan-1", "status": "running"})
monkeypatch.setattr(http, "request", request)
assert cloud.run_cloud(["scans", "start", "--domain-ids", "domain-1", "--json"]) == 0
assert json.loads(capsys.readouterr().out)["scan_id"] == "scan-1"
assert len(seen) == 1
assert seen[0]["idempotency_key"] == "generated-key"
assert seen[0]["body"]["engagement_type"] == "live_test"
def test_exact_transport_retry_reuses_key_and_body(
monkeypatch: pytest.MonkeyPatch,
) -> None:
seen: list[tuple[str, dict[str, Any]]] = []
def request(_method: str, _path: str, **kwargs: Any) -> FakeResponse:
seen.append((kwargs["idempotency_key"], kwargs["body"]))
if len(seen) == 1:
raise http.CloudTransportError("response lost")
return FakeResponse({"scan_id": "scan-1", "status": "running"})
monkeypatch.setattr(http, "request", request)
command = [
"scans",
"start",
"--domain-ids",
"domain-1",
"--idempotency-key",
"retry-key",
"--json",
]
assert cloud.run_cloud(command) == 0
assert len(seen) == 2
assert seen[0] == seen[1]
assert seen[0][0] == "retry-key"
@pytest.mark.parametrize(
"payload,status",
[
({"code": "idempotency_request_in_progress", "retry_safe": True}, 409),
({"code": "idempotency_outcome_unknown", "retry_safe": True}, 503),
({"detail": "gateway unavailable"}, 502),
({"detail": "rate limited"}, 429),
],
)
def test_retryable_responses_are_closed_and_replayed(
payload: dict[str, Any],
status: int,
monkeypatch: pytest.MonkeyPatch,
) -> None:
first = FakeResponse(payload, status_code=status)
responses = iter((first, FakeResponse({"scan_id": "scan-1", "status": "running"})))
keys: list[str] = []
def request(_method: str, _path: str, **kwargs: Any) -> FakeResponse:
keys.append(kwargs["idempotency_key"])
return next(responses)
monkeypatch.setattr(http, "request", request)
assert (
cloud.run_cloud(
[
"scans",
"rerun",
"scan-old",
"--idempotency-key",
"same-key",
"--json",
]
)
== 0
)
assert keys == ["same-key", "same-key"]
assert first.closed is True
def test_terminal_key_conflict_is_not_retried(
monkeypatch: pytest.MonkeyPatch,
capsys: Any,
) -> None:
calls = 0
def request(_method: str, _path: str, **_kwargs: Any) -> FakeResponse:
nonlocal calls
calls += 1
return FakeResponse(
{
"detail": "key belongs to another request",
"code": "idempotency_key_conflict",
"terminal": True,
},
status_code=409,
)
monkeypatch.setattr(http, "request", request)
assert (
cloud.run_cloud(["scans", "rerun", "scan-old", "--idempotency-key", "conflict", "--json"])
== http.EXIT_ERROR
)
assert calls == 1
assert json.loads(capsys.readouterr().out)["code"] == "idempotency_key_conflict"
def test_exhausted_ambiguous_launch_reports_safe_recovery_key(
monkeypatch: pytest.MonkeyPatch,
capsys: Any,
) -> None:
monkeypatch.setattr(
http,
"request",
lambda *_args, **_kwargs: (_ for _ in ()).throw(http.CloudTransportError("response lost")),
)
assert (
cloud.run_cloud(["scans", "rerun", "scan-old", "--idempotency-key", "recover-me", "--json"])
== http.EXIT_ERROR
)
payload = json.loads(capsys.readouterr().out)
assert payload["idempotency_key"] == "recover-me"
assert payload["retry_safe"] is True
assert payload["retry_same_request"] is True
assert "--idempotency-key recover-me" in payload["error"]
@pytest.mark.parametrize("key", ["", " white", "bad key", "x\nheader", "x" * 201])
def test_invalid_idempotency_key_is_usage_error_before_request(
key: str,
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setattr(http, "request", lambda *_a, **_k: pytest.fail("must not request"))
assert (
cloud.run_cloud(["scans", "rerun", "scan-old", "--idempotency-key", key, "--json"])
== http.EXIT_USAGE
)
def test_idempotency_flag_is_completed_only_for_keyed_commands() -> None:
assert "--idempotency-key" in completion_candidates(["cloud", "scans", "start", "--idemp"])
assert "--idempotency-key" in completion_candidates(
["cloud", "scans", "rerun", "scan-1", "--idemp"]
)
assert "--idempotency-key" not in completion_candidates(["cloud", "scans", "list", "--idemp"])
assert "--idempotency-key" in completion_candidates(["cloud", "schedules", "create", "--idemp"])
assert "--idempotency-key" in completion_candidates(
["cloud", "schedules", "trigger", "schedule-1", "--idemp"]
)
def test_http_client_places_key_in_the_header(monkeypatch: pytest.MonkeyPatch) -> None:
seen: dict[str, Any] = {}
def request(_method: str, _url: str, **kwargs: Any) -> FakeResponse:
seen.update(kwargs)
return FakeResponse({"ok": True})
monkeypatch.setattr(http.requests, "request", request)
http.request("POST", "/scans", body={}, idempotency_key="header-key")
assert seen["headers"]["Idempotency-Key"] == "header-key"
assert seen["headers"]["Authorization"] == "Bearer idempotency-test-token"

136
tests/test_cloud_payment_proxy.py Normal file
View file

@ -0,0 +1,136 @@
"""Security tests for the wallet payment loopback bridge."""
from __future__ import annotations
import urllib.error
import urllib.request
from typing import TYPE_CHECKING, Any
import pytest
from strix.interface.cloud import payment_proxy
if TYPE_CHECKING:
from collections.abc import Iterator
class _StreamingResponse:
status_code = 200
def __init__(self, chunks: list[bytes]) -> None:
self.chunks = chunks
self.closed = False
self.headers = {"Content-Type": "application/json"}
def iter_content(self, *, chunk_size: int) -> Iterator[bytes]:
assert chunk_size > 0
yield from self.chunks
def close(self) -> None:
self.closed = True
def _post(url: str, body: bytes, headers: dict[str, str] | None = None) -> bytes:
request = urllib.request.Request( # noqa: S310
url,
data=body,
headers={"Content-Type": "application/json", **(headers or {})},
method="POST",
)
with urllib.request.urlopen(request, timeout=2) as response: # noqa: S310
return response.read()
def test_bridge_bounds_decompressed_upstream_response(monkeypatch: pytest.MonkeyPatch) -> None:
response = _StreamingResponse([b"1234", b"5"])
def fake_request(*_args: Any, **kwargs: Any) -> _StreamingResponse:
assert kwargs["stream"] is True
return response
monkeypatch.setattr(payment_proxy, "_MAX_UPSTREAM_RESPONSE_BYTES", 4)
monkeypatch.setattr(payment_proxy.requests, "request", fake_request)
with payment_proxy.wallet_payment_bridge(
upstream_url="https://app.example.test/api/v1/billing/topup",
api_token="strix-secret", # noqa: S106
expected_body=b"{}",
) as wallet_url:
request = urllib.request.Request( # noqa: S310
wallet_url,
data=b"{}",
headers={"Content-Type": "application/json"},
method="POST",
)
with pytest.raises(urllib.error.HTTPError) as exc_info:
urllib.request.urlopen(request, timeout=2) # noqa: S310
assert exc_info.value.code == 502
assert response.closed is True
def test_bridge_forwards_only_the_approved_request_and_protected_headers(
monkeypatch: pytest.MonkeyPatch,
) -> None:
captured: list[dict[str, Any]] = []
observed: list[payment_proxy.WalletUpstreamResponse] = []
def fake_request(*_args: Any, **kwargs: Any) -> _StreamingResponse:
captured.append(kwargs)
return _StreamingResponse([b'{"ok":true}'])
monkeypatch.setattr(payment_proxy.requests, "request", fake_request)
with payment_proxy.wallet_payment_bridge(
upstream_url="https://app.example.test/api/v1/billing/topup",
api_token="strix-secret", # noqa: S106
expected_body=b'{"credits":5}',
response_observer=observed.append,
) as wallet_url:
result = _post(
wallet_url,
b'{"credits":5}',
{
"Authorization": "Payment wallet-proof",
"Proxy-Authorization": "Basic drop-me",
"X-Strix-Authorization": "Bearer attacker",
},
)
assert result == b'{"ok":true}'
headers = captured[0]["headers"]
assert headers["Authorization"] == "Payment wallet-proof"
assert headers["X-Strix-Authorization"] == "Bearer strix-secret"
assert "Proxy-Authorization" not in headers
assert not any(name.lower() in {"host", "content-length"} for name in headers)
assert observed == [
payment_proxy.WalletUpstreamResponse(status_code=200, body=b'{"ok":true}')
]
with pytest.raises(urllib.error.HTTPError) as wrong_body:
_post(wallet_url, b'{"credits":500}')
assert wrong_body.value.code == 403
assert len(captured) == 1
def test_bridge_allows_only_two_valid_wallet_attempts(monkeypatch: pytest.MonkeyPatch) -> None:
calls = 0
def fake_request(*_args: Any, **_kwargs: Any) -> _StreamingResponse:
nonlocal calls
calls += 1
return _StreamingResponse([b"{}"])
monkeypatch.setattr(payment_proxy.requests, "request", fake_request)
with payment_proxy.wallet_payment_bridge(
upstream_url="https://app.example.test/api/v1/billing/topup",
api_token="strix-secret", # noqa: S106
expected_body=b"{}",
) as wallet_url:
assert _post(wallet_url, b"{}") == b"{}"
assert _post(wallet_url, b"{}") == b"{}"
with pytest.raises(urllib.error.HTTPError) as third_request:
_post(wallet_url, b"{}")
assert third_request.value.code == 429
assert calls == 2

165
tests/test_cloud_session.py Normal file
View file

@ -0,0 +1,165 @@
"""CLI-session lifecycle, scope, and workspace-race behavior."""
from __future__ import annotations
import json
from typing import TYPE_CHECKING, Any
import pytest
from rich.console import Console
from strix.interface import cloud, platform_cli, platform_identity
from strix.interface.cloud import http
from strix.interface.cloud import session as cloud_session
if TYPE_CHECKING:
from pathlib import Path
class Response:
def __init__(self, payload: Any = None, status_code: int = 200) -> None:
self._payload = payload
self.status_code = status_code
self.ok = 200 <= status_code < 400
self.text = json.dumps(payload) if payload is not None else ""
self.headers = {"content-type": "application/json"}
def json(self) -> Any:
return self._payload
@pytest.fixture
def auth_path(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
path = tmp_path / "platform-auth.json"
monkeypatch.setattr(platform_cli, "AUTH_PATH", path)
monkeypatch.delenv("STRIX_API_TOKEN", raising=False)
monkeypatch.delenv("STRIX_WORKSPACE_ID", raising=False)
return path
def test_http_workspace_pin_is_captured_once(
auth_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
platform_cli.save_record(
{
"api_token": "secret",
"organization_id": "org_start",
"app_url": "https://app.example.test",
}
)
assert auth_path.exists()
sent: list[dict[str, str]] = []
def fake_request(*_args: Any, **kwargs: Any) -> Response:
sent.append(dict(kwargs["headers"]))
return Response({})
monkeypatch.setattr(http.requests, "request", fake_request)
http.configure()
platform_cli.save_record(
{
"api_token": "secret",
"organization_id": "org_changed_elsewhere",
"app_url": "https://app.example.test",
}
)
http.request("GET", "/scans")
assert sent[0]["X-Strix-Workspace"] == "org_start"
def test_session_scope_update_persists_only_for_stored_session(
auth_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: Any
) -> None:
platform_cli.save_record(
{
"api_token": "secret",
"organization_id": "org_1",
"app_url": "https://app.example.test",
"scopes": ["scans:read"],
}
)
monkeypatch.setattr(
http,
"request",
lambda *_args, **_kwargs: Response(
{
"scopes": ["scans:read", "scans:write", "billing:read"],
"requested_scopes": ["scans:read", "scans:write", "billing:read"],
"scope_ceiling": ["scans:read", "scans:write", "billing:read"],
"scope_profile": "minimal",
}
),
)
assert cloud.run_cloud(["session", "scopes", "set", "minimal", "--json"]) == 0
stored = platform_cli.read_record()
assert stored is not None
assert stored["scope_profile"] == "minimal"
assert json.loads(capsys.readouterr().out)["scope_profile"] == "minimal"
before = auth_path.read_text(encoding="utf-8")
assert (
cloud.run_cloud(["session", "scopes", "set", "minimal", "--token", "override", "--json"])
== 0
)
assert auth_path.read_text(encoding="utf-8") == before
def test_logout_keeps_local_token_when_remote_outcome_is_not_definitive(
auth_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: Any
) -> None:
platform_cli.save_record(
{
"api_token": "secret",
"organization_id": "org_1",
"app_url": "https://app.example.test",
}
)
monkeypatch.setattr(
platform_cli.requests,
"delete",
lambda *_args, **_kwargs: Response({"detail": "unavailable"}, 503),
)
assert cloud.run_cloud(["logout", "--json"]) == 1
assert auth_path.exists()
assert json.loads(capsys.readouterr().out)["removed"] is False
def test_local_only_logout_is_explicit_and_recoverable(auth_path: Path, capsys: Any) -> None:
platform_cli.save_record({"api_token": "secret"})
assert cloud.run_cloud(["logout", "--local-only", "--json"]) == 0
payload = json.loads(capsys.readouterr().out)
assert payload["local_only"] is True
assert payload["remotely_revoked"] is False
assert not auth_path.exists()
def test_session_json_errors_preserve_machine_readable_server_details(capsys: Any) -> None:
error = http.CloudError(
"workspace changed",
payload={
"detail": "workspace changed",
"code": "workspace_session_changed",
"current_organization_id": "org_current",
},
)
assert cloud_session._error(Console(), error, as_json=True) == http.EXIT_ERROR
payload = json.loads(capsys.readouterr().out)
assert payload == {
"code": "workspace_session_changed",
"current_organization_id": "org_current",
"error": "workspace changed",
}
def test_cli_device_identity_is_stable_and_privacy_safe(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
path = tmp_path / "cli-identity.json"
monkeypatch.setattr(platform_identity, "IDENTITY_PATH", path)
first = platform_identity.read_or_create_identity()
second = platform_identity.read_or_create_identity(device_name=" Build laptop ")
assert second["client_instance_id"] == first["client_instance_id"]
assert second["device_name"] == "Build laptop"
assert path.stat().st_mode & 0o777 == 0o600

657
tests/test_cloud_source_upload.py Normal file
View file

@ -0,0 +1,657 @@
"""Local-source packaging and scan upload tests."""
from __future__ import annotations
import json
import os
import shutil
import subprocess
import zipfile
from typing import TYPE_CHECKING, Any
import pytest
from strix.interface import cloud
from strix.interface.cloud import http, source_upload
if TYPE_CHECKING:
from pathlib import Path
class FakeResponse:
def __init__(self, payload: Any, status_code: int = 200) -> None:
self.status_code = status_code
self._payload = payload
self.text = json.dumps(payload)
self.content = b""
self.ok = 200 <= status_code < 400
self.headers = {"content-type": "application/json"}
def json(self) -> Any:
return self._payload
class MalformedJsonResponse(FakeResponse):
def json(self) -> Any:
raise ValueError("malformed JSON")
@pytest.fixture(autouse=True)
def _token_env(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("STRIX_API_TOKEN", "test-token")
def _git_source(tmp_path: Path) -> Path:
git = shutil.which("git")
assert git is not None
subprocess.run([git, "init", "-q", str(tmp_path)], check=True) # noqa: S603
(tmp_path / "app.py").write_text("print('hello')\n", encoding="utf-8")
(tmp_path / "README.md").write_text("hello\n", encoding="utf-8")
(tmp_path / ".gitignore").write_text("ignored.log\n", encoding="utf-8")
(tmp_path / "ignored.log").write_text("ignored\n", encoding="utf-8")
subprocess.run( # noqa: S603
[git, "-C", str(tmp_path), "add", "app.py", ".gitignore"], check=True
)
return tmp_path
def test_source_defaults_are_private_and_git_aware(tmp_path: Path) -> None:
source = _git_source(tmp_path)
(source / ".hidden.py").write_text("hidden\n", encoding="utf-8")
(source / ".env").write_text("TOKEN=secret\n", encoding="utf-8")
(source / "private.pem").write_text("secret\n", encoding="utf-8")
(source / "fixture.zip").write_bytes(b"not really a zip")
(source / "node_modules").mkdir()
(source / "node_modules" / "dep.js").write_text("dep\n", encoding="utf-8")
(source / "linked.py").symlink_to(source / "app.py")
bundle = source_upload.prepare_source(
str(source),
include_hidden=False,
include_sensitive=False,
include_archives=False,
exclude=[],
)
try:
names = [item.archive_name for item in bundle.manifest.files]
assert names == ["README.md", "app.py"]
assert bundle.manifest.total_bytes > 0
assert bundle.archive_bytes <= source_upload.MAX_ARCHIVE_BYTES
assert bundle.manifest.excluded["hidden"] == 3
assert bundle.manifest.excluded["sensitive_filename"] == 1
assert bundle.manifest.excluded["nested_archive"] == 1
assert bundle.manifest.excluded["dependency_or_build_output"] == 1
assert bundle.manifest.excluded["symlink_or_non_file"] == 1
with zipfile.ZipFile(bundle.archive_path) as archive:
assert archive.namelist() == names
finally:
source_upload.remove_bundle(bundle)
def test_hidden_and_sensitive_files_need_separate_opt_ins(tmp_path: Path) -> None:
source = _git_source(tmp_path)
(source / ".env").write_text("TOKEN=secret\n", encoding="utf-8")
(source / ".github").mkdir()
(source / ".github" / "workflow.yml").write_text("name: test\n", encoding="utf-8")
hidden = source_upload.select_source(source, include_hidden=True)
hidden_names = {item.archive_name for item in hidden.files}
assert ".github/workflow.yml" in hidden_names
assert ".env" not in hidden_names
sensitive = source_upload.select_source(source, include_hidden=True, include_sensitive=True)
assert ".env" in {item.archive_name for item in sensitive.files}
assert all(
not name.startswith(".git/") for name in (item.archive_name for item in sensitive.files)
)
def test_hidden_opt_in_still_excludes_common_credential_paths(tmp_path: Path) -> None:
paths = [
".aws/credentials",
".git-credentials",
".docker/config.json",
".config/gcloud/application_default_credentials.json",
".config/gcloud/credentials.db",
".azure/accessTokens.json",
".kube/config",
]
for relative in paths:
path = tmp_path / relative
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text("credential material\n", encoding="utf-8")
hidden_only = source_upload.select_source(tmp_path, include_hidden=True)
assert not ({item.archive_name for item in hidden_only.files} & set(paths))
assert hidden_only.excluded["sensitive_filename"] == len(paths)
explicitly_sensitive = source_upload.select_source(
tmp_path, include_hidden=True, include_sensitive=True
)
assert set(paths) <= {item.archive_name for item in explicitly_sensitive.files}
def test_hidden_opt_in_cannot_reenable_dependency_cache_or_build_dirs(tmp_path: Path) -> None:
excluded_dirs = [
".venv",
"env",
".tox",
".pytest_cache",
".mypy_cache",
".ruff_cache",
".next",
".nuxt",
".gradle",
]
for directory in excluded_dirs:
path = tmp_path / directory / "artifact.txt"
path.parent.mkdir(parents=True)
path.write_text("generated\n", encoding="utf-8")
(tmp_path / ".github" / "workflow.yml").parent.mkdir()
(tmp_path / ".github" / "workflow.yml").write_text("name: test\n", encoding="utf-8")
manifest = source_upload.select_source(tmp_path, include_hidden=True)
names = {item.archive_name for item in manifest.files}
assert ".github/workflow.yml" in names
assert not any(name.split("/", 1)[0] in excluded_dirs for name in names)
assert manifest.excluded["dependency_or_build_output"] == len(excluded_dirs)
def test_strixignore_and_cli_excludes_are_applied(tmp_path: Path) -> None:
(tmp_path / "keep.py").write_text("keep\n", encoding="utf-8")
(tmp_path / "generated.py").write_text("generated\n", encoding="utf-8")
(tmp_path / "test_app.py").write_text("test\n", encoding="utf-8")
(tmp_path / ".strixignore").write_text("generated.py\n", encoding="utf-8")
manifest = source_upload.select_source(tmp_path, exclude=["test_*.py"])
assert [item.archive_name for item in manifest.files] == ["keep.py"]
assert manifest.excluded["user_pattern"] == 2
def test_strixignore_trailing_slash_excludes_the_whole_directory(tmp_path: Path) -> None:
(tmp_path / "keep.py").write_text("keep\n", encoding="utf-8")
private = tmp_path / "private" / "nested"
private.mkdir(parents=True)
(private / "secret.txt").write_text("do not upload\n", encoding="utf-8")
cache = tmp_path / "packages" / "cache"
cache.mkdir(parents=True)
(cache / "artifact.txt").write_text("do not upload\n", encoding="utf-8")
(tmp_path / ".strixignore").write_text("private/\n", encoding="utf-8")
manifest = source_upload.select_source(tmp_path, exclude=["cache/"])
assert [item.archive_name for item in manifest.files] == ["keep.py"]
assert manifest.excluded["user_pattern"] >= 2
def test_source_limits_expanded_bytes_before_compression(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.setattr(source_upload, "MAX_TOTAL_BYTES", 5)
(tmp_path / "large.py").write_bytes(b"a" * 6)
with pytest.raises(http.CloudError, match="expanded-size limit"):
source_upload.select_source(tmp_path)
def test_source_rejects_archives_by_suffix_and_actual_bytes(tmp_path: Path) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
(tmp_path / "dependency.jar").write_bytes(b"not-even-a-valid-archive")
(tmp_path / "renamed-source.txt").write_bytes(b"PK\x03\x04" + b"x" * 32)
tar_header = bytearray(512)
tar_header[257:262] = b"ustar"
(tmp_path / "renamed-tar.bin").write_bytes(tar_header)
manifest = source_upload.select_source(tmp_path)
assert [item.archive_name for item in manifest.files] == ["app.py"]
assert manifest.excluded["nested_archive"] == 3
def test_source_enumeration_is_bounded_before_filtering(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.setattr(source_upload, "MAX_CANDIDATE_PATHS", 2)
for index in range(3):
(tmp_path / f"file-{index}.py").write_text("safe\n", encoding="utf-8")
with pytest.raises(http.CloudError, match="enumeration exceeded 2 paths"):
source_upload.select_source(tmp_path)
def test_strixignore_size_and_pattern_counts_are_bounded(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
ignore = tmp_path / ".strixignore"
monkeypatch.setattr(source_upload, "MAX_IGNORE_BYTES", 4)
ignore.write_text("12345", encoding="utf-8")
with pytest.raises(http.CloudError, match="larger than the 4-byte limit"):
source_upload.select_source(tmp_path)
monkeypatch.setattr(source_upload, "MAX_IGNORE_BYTES", 1_000)
monkeypatch.setattr(source_upload, "MAX_IGNORE_PATTERNS", 1)
ignore.write_text("one\ntwo\n", encoding="utf-8")
with pytest.raises(http.CloudError, match="more than 1 exclusion patterns"):
source_upload.select_source(tmp_path)
@pytest.mark.skipif(not hasattr(os, "mkfifo"), reason="named pipes are not supported")
def test_strixignore_must_be_a_nonblocking_regular_file(tmp_path: Path) -> None:
(tmp_path / "app.py").write_text("print('ok')\n", encoding="utf-8")
os.mkfifo(tmp_path / ".strixignore")
with pytest.raises(http.CloudError, match="must be a regular file"):
source_upload.select_source(tmp_path)
def test_source_archive_rejects_a_path_swapped_after_manifest_review(tmp_path: Path) -> None:
source_path = tmp_path / "app.py"
source_path.write_bytes(b"safe")
manifest = source_upload.select_source(tmp_path)
replacement = tmp_path / "replacement"
replacement.write_bytes(b"oops")
replacement.replace(source_path)
with pytest.raises(http.CloudError, match="changed while the source archive was being built"):
source_upload._write_archive(tmp_path / "source.zip", manifest.files)
def test_source_archive_rejects_same_inode_same_size_change_after_review(tmp_path: Path) -> None:
source_path = tmp_path / "app.py"
source_path.write_bytes(b"safe")
manifest = source_upload.select_source(tmp_path)
source_path.write_bytes(b"evil")
selected = manifest.files[0]
os.utime(
source_path,
ns=(selected.mtime_ns + 1_000_000, selected.mtime_ns + 1_000_000),
)
with pytest.raises(http.CloudError, match="changed while the source archive was being built"):
source_upload._write_archive(tmp_path / "source.zip", manifest.files)
def test_source_dry_run_never_calls_the_api(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: Any
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
def fail_request(*_args: Any, **_kwargs: Any) -> Any:
raise AssertionError("dry-run must not make an API request")
monkeypatch.setattr(http, "request", fail_request)
assert (
cloud.run_cloud(
["scans", "start", "--source", str(tmp_path), "--dry-run", "--show-files", "--json"]
)
== 0
)
payload = json.loads(capsys.readouterr().out)
assert payload["source"]["files"] == ["app.py"]
assert payload["source"]["archive_sha256"]
def test_noninteractive_source_upload_requires_yes(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: Any
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
monkeypatch.setattr(
http,
"request",
lambda *_args, **_kwargs: pytest.fail("approval must happen before any API request"),
)
assert cloud.run_cloud(["scans", "start", "--source", str(tmp_path), "--json"]) == 1
output = capsys.readouterr().out
assert "requires explicit approval" in output
assert "--approve-sha256 <reviewed hash>" in output
assert "--yes" in output
assert "one-shot approval" in output
def test_source_digest_approval_rejects_a_changed_snapshot(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: Any
) -> None:
source = tmp_path / "app.py"
source.write_text("print('reviewed')\n", encoding="utf-8")
assert (
cloud.run_cloud(["scans", "start", "--source", str(tmp_path), "--dry-run", "--json"]) == 0
)
approved = json.loads(capsys.readouterr().out)["source"]["archive_sha256"]
source.write_text("print('changed')\n", encoding="utf-8")
monkeypatch.setattr(
http,
"request",
lambda *_args, **_kwargs: pytest.fail("a changed snapshot must not reach the API"),
)
assert (
cloud.run_cloud(
[
"scans",
"start",
"--source",
str(tmp_path),
"--approve-sha256",
approved,
"--json",
]
)
== http.EXIT_ERROR
)
assert "does not match" in json.loads(capsys.readouterr().out)["error"]
def test_source_upload_is_completed_and_attached_to_scan(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: Any
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
calls: list[tuple[str, str, dict[str, Any]]] = []
uploaded_path: Path | None = None
def fake_request(method: str, path: str, **kwargs: Any) -> FakeResponse:
calls.append((method, path, kwargs))
if path == "/uploads/request":
return FakeResponse(
{
"upload_id": "upload-1",
"signed_url": "https://storage.test/object",
"token": "signed",
}
)
if path == "/uploads/complete":
return FakeResponse({"id": "upload-1"})
if path == "/scans":
return FakeResponse({"scan_id": "scan-1", "status": "pending"})
raise AssertionError(path)
def fake_upload(_url: str, _token: str, path: Path) -> None:
nonlocal uploaded_path
uploaded_path = path
assert path.exists()
monkeypatch.setattr(http, "request", fake_request)
monkeypatch.setattr(http, "upload_file", fake_upload)
assert (
cloud.run_cloud(
["scans", "start", "--source", str(tmp_path), "--yes", "--show-files", "--json"]
)
== 0
)
payload = json.loads(capsys.readouterr().out)
assert payload["upload_id"] == "upload-1"
assert payload["scan"]["scan_id"] == "scan-1"
assert payload["source"]["files"] == ["app.py"]
scan_call = next(call for call in calls if call[1] == "/scans")
assert scan_call[2]["body"] == {
"engagement_type": "code_review",
"upload_ids": ["upload-1"],
}
assert uploaded_path is not None and not uploaded_path.exists()
def test_source_upload_with_domain_is_a_live_test(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: Any
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
calls: list[tuple[str, str, dict[str, Any]]] = []
def fake_request(method: str, path: str, **kwargs: Any) -> FakeResponse:
calls.append((method, path, kwargs))
if path == "/uploads/request":
return FakeResponse(
{
"upload_id": "upload-1",
"signed_url": "https://storage.test/object",
"token": "signed",
}
)
if path == "/uploads/complete":
return FakeResponse({"id": "upload-1"})
if path == "/scans":
return FakeResponse({"scan_id": "scan-1", "status": "pending"})
raise AssertionError(path)
monkeypatch.setattr(http, "request", fake_request)
monkeypatch.setattr(http, "upload_file", lambda *_args, **_kwargs: None)
assert (
cloud.run_cloud(
[
"scans",
"start",
"--source",
str(tmp_path),
"--domain-ids",
"domain-1",
"--yes",
"--json",
]
)
== 0
)
scan_call = next(call for call in calls if call[1] == "/scans")
assert scan_call[2]["body"] == {
"engagement_type": "live_test",
"domain_ids": ["domain-1"],
"upload_ids": ["upload-1"],
}
assert json.loads(capsys.readouterr().out)["scan"]["scan_id"] == "scan-1"
def test_failed_scan_deletes_completed_source_upload(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
paths: list[tuple[str, str]] = []
def fake_request(method: str, path: str, **_kwargs: Any) -> FakeResponse:
paths.append((method, path))
if path == "/uploads/request":
return FakeResponse(
{
"upload_id": "upload-1",
"signed_url": "https://storage.test/object",
"token": "signed",
}
)
if path == "/uploads/complete":
return FakeResponse({"id": "upload-1"})
if path == "/scans":
return FakeResponse({"detail": "not enough credits"}, status_code=402)
if path == "/uploads/upload-1":
return FakeResponse({"ok": True})
raise AssertionError(path)
monkeypatch.setattr(http, "request", fake_request)
monkeypatch.setattr(http, "upload_file", lambda *_args, **_kwargs: None)
assert cloud.run_cloud(["scans", "start", "--source", str(tmp_path), "--yes", "--json"]) == 5
assert ("DELETE", "/uploads/upload-1") in paths
@pytest.mark.parametrize(
"failure",
["network", "server", "malformed_success", "malformed_json_success", "wrong_shape_success"],
)
def test_ambiguous_scan_launch_retains_completed_source_upload(
failure: str,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
capsys: Any,
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
paths: list[tuple[str, str]] = []
def fake_request(method: str, path: str, **_kwargs: Any) -> FakeResponse:
paths.append((method, path))
if path == "/uploads/request":
return FakeResponse(
{
"upload_id": "upload-ambiguous",
"signed_url": "https://storage.test/object",
"token": "signed",
}
)
if path == "/uploads/complete":
return FakeResponse({"id": "upload-ambiguous"})
if path == "/scans":
if failure == "network":
raise http.CloudError("connection closed before a response")
if failure == "server":
return FakeResponse({"detail": "temporary failure"}, status_code=500)
if failure == "malformed_json_success":
return MalformedJsonResponse("accepted")
if failure == "wrong_shape_success":
return FakeResponse({})
response = FakeResponse("accepted")
response.headers = {"content-type": "text/html"}
return response
if path == "/uploads/upload-ambiguous":
pytest.fail("an upload with an ambiguous launch must not be deleted")
raise AssertionError(path)
monkeypatch.setattr(http, "request", fake_request)
monkeypatch.setattr(http, "upload_file", lambda *_args, **_kwargs: None)
assert (
cloud.run_cloud(["scans", "start", "--source", str(tmp_path), "--yes", "--json"])
== http.EXIT_ERROR
)
payload = json.loads(capsys.readouterr().out)
assert payload["upload_id"] == "upload-ambiguous"
assert payload["upload_retained"] is True
assert payload["launch_outcome_unknown"] is True
assert "outcome is unknown" in payload["error"]
assert ("DELETE", "/uploads/upload-ambiguous") not in paths
def test_mismatched_upload_completion_response_is_cleaned_before_launch(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
paths: list[tuple[str, str]] = []
def fake_request(method: str, path: str, **_kwargs: Any) -> FakeResponse:
paths.append((method, path))
if path == "/uploads/request":
return FakeResponse(
{
"upload_id": "upload-expected",
"signed_url": "https://storage.test/object",
"token": "signed",
}
)
if path == "/uploads/complete":
return FakeResponse({"id": "upload-different"})
if path == "/uploads/upload-expected":
return FakeResponse({"ok": True})
if path == "/scans":
pytest.fail("a scan must not launch before upload completion is confirmed")
raise AssertionError(path)
monkeypatch.setattr(http, "request", fake_request)
monkeypatch.setattr(http, "upload_file", lambda *_args, **_kwargs: None)
assert cloud.run_cloud(["scans", "start", "--source", str(tmp_path), "--yes"]) == 1
assert ("DELETE", "/uploads/upload-expected") in paths
def test_interrupted_scan_launch_retains_completed_source_upload(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: Any
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
paths: list[tuple[str, str]] = []
def fake_request(method: str, path: str, **_kwargs: Any) -> FakeResponse:
paths.append((method, path))
if path == "/uploads/request":
return FakeResponse(
{
"upload_id": "upload-interrupted",
"signed_url": "https://storage.test/object",
"token": "signed",
}
)
if path == "/uploads/complete":
return FakeResponse({"id": "upload-interrupted"})
if path == "/scans":
raise KeyboardInterrupt
if path == "/uploads/upload-interrupted":
pytest.fail("an upload with an interrupted launch must not be deleted")
raise AssertionError(path)
monkeypatch.setattr(http, "request", fake_request)
monkeypatch.setattr(http, "upload_file", lambda *_args, **_kwargs: None)
assert cloud.run_cloud(["scans", "start", "--source", str(tmp_path), "--yes", "--json"]) == 130
payload = json.loads(capsys.readouterr().out)
assert payload["interrupted"] is True
assert payload["upload_id"] == "upload-interrupted"
assert payload["upload_retained"] is True
assert payload["launch_outcome_unknown"] is True
assert "scans list" in payload["error"]
assert ("DELETE", "/uploads/upload-interrupted") not in paths
@pytest.mark.parametrize("cleanup_failure", ["timeout", "server"])
def test_failed_automatic_upload_cleanup_reports_retained_id(
cleanup_failure: str,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
capsys: Any,
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
def fake_request(method: str, path: str, **_kwargs: Any) -> FakeResponse:
if path == "/uploads/request":
return FakeResponse(
{
"upload_id": "upload-orphaned",
"signed_url": "https://storage.test/object",
"token": "signed",
}
)
if path == "/uploads/upload-orphaned" and method == "DELETE":
if cleanup_failure == "timeout":
raise http.CloudError("cleanup timed out")
return FakeResponse({"detail": "cleanup unavailable"}, status_code=500)
raise AssertionError((method, path))
monkeypatch.setattr(http, "request", fake_request)
monkeypatch.setattr(
http,
"upload_file",
lambda *_args, **_kwargs: (_ for _ in ()).throw(http.CloudError("upload failed")),
)
assert (
cloud.run_cloud(["scans", "start", "--source", str(tmp_path), "--yes", "--json"])
== http.EXIT_ERROR
)
payload = json.loads(capsys.readouterr().out)
assert payload["upload_id"] == "upload-orphaned"
assert payload["upload_retained"] is True
assert payload["cleanup_unknown"] is True
assert "uploads delete upload-orphaned" in payload["error"]
def test_incomplete_upload_credentials_delete_the_reserved_upload(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
(tmp_path / "app.py").write_text("print('safe')\n", encoding="utf-8")
paths: list[tuple[str, str]] = []
def fake_request(method: str, path: str, **_kwargs: Any) -> FakeResponse:
paths.append((method, path))
if path == "/uploads/request":
return FakeResponse({"upload_id": "upload-incomplete"})
if path == "/uploads/upload-incomplete":
return FakeResponse({"ok": True})
raise AssertionError(path)
monkeypatch.setattr(http, "request", fake_request)
assert cloud.run_cloud(["scans", "start", "--source", str(tmp_path), "--yes", "--json"]) == 1
assert ("DELETE", "/uploads/upload-incomplete") in paths

164
tests/test_completions.py Normal file
View file

@ -0,0 +1,164 @@
from __future__ import annotations
from typing import Any
from strix.interface.completions import completion_candidates, run_completions
def test_root_completion_candidates() -> None:
assert completion_candidates(["cl"]) == ["cloud"]
assert "completions" in completion_candidates([""])
def test_cloud_group_and_alias_candidates() -> None:
candidates = completion_candidates(["cloud", "work"])
assert candidates == ["workspace", "workspaces"]
def test_cloud_verb_candidates_include_multiword_prefixes() -> None:
assert "test-users" in completion_candidates(["cloud", "domains", ""])
assert completion_candidates(["cloud", "domains", "test-users", "in"]) == [
"inbox",
"inbox-message",
]
def test_cloud_leaf_flag_candidates_come_from_command_spec() -> None:
candidates = completion_candidates(["cloud", "scans", "start", "--"])
assert "--domain-ids" in candidates
assert "--json" in candidates
assert "--wait" in candidates
assert "--source" in candidates
assert "--approve-sha256" in candidates
assert "--dry-run" in candidates
assert "--include-hidden" in candidates
def test_boolean_completion_includes_positive_and_negative_flags() -> None:
candidates = completion_candidates(["cloud", "billing", "auto-topup", "update", "--"])
assert "--enabled" in candidates
assert "--no-enabled" in candidates
assert "--no-monthly-cap" in candidates
def test_session_and_workspace_use_completions_include_their_real_flags() -> None:
credit_flags = completion_candidates(["cloud", "credits", "--"])
assert {"--json", "--token", "--app-url", "--timeout", "--help"} <= set(credit_flags)
assert "--json" in completion_candidates(["cloud", "logout", "--"])
workspace_use = completion_candidates(["cloud", "workspace", "use", "--"])
assert {"--scopes", "--json", "--token", "--app-url", "--timeout"} <= set(workspace_use)
def test_leaf_flags_remain_available_after_options_and_positionals() -> None:
after_option = completion_candidates(["cloud", "scans", "list", "--status", "running", "--"])
assert {"--page", "--limit", "--json"} <= set(after_option)
after_positional = completion_candidates(["cloud", "scans", "get", "scan-1", "--"])
assert {"--json", "--token", "--app-url", "--timeout"} <= set(after_positional)
def test_default_verbs_complete_flags_without_an_explicit_verb() -> None:
audit = completion_candidates(["cloud", "audit", "--"])
assert {"--page", "--limit", "--json"} <= set(audit)
after_option = completion_candidates(["cloud", "audit", "--page", "2", "--"])
assert {"--limit", "--format", "--json"} <= set(after_option)
workspaces = completion_candidates(["cloud", "workspace", "--"])
assert {"--json", "--token", "--app-url", "--timeout"} <= set(workspaces)
def test_completion_does_not_offer_flags_while_an_option_value_is_empty() -> None:
assert completion_candidates(["cloud", "scans", "list", "--page", ""]) == []
assert completion_candidates(["cloud", "scans", "start", "--approve-sha256", ""]) == []
def test_exact_verbs_that_are_also_prefixes_keep_their_subverbs() -> None:
candidates = completion_candidates(["cloud", "billing", "auto-topup", ""])
assert "update" in candidates
assert "--json" in candidates
def test_contract_fix_flags_are_completed() -> None:
integration_connect = completion_candidates(
["cloud", "integrations", "connect", "gitlab", "--"]
)
assert {
"--provider-token",
"--instance-url",
"--account-email",
"--installation-id",
} <= set(integration_connect)
disconnect = completion_candidates(["cloud", "integrations", "disconnect", "--"])
assert "--installation-id" in disconnect
connector = completion_candidates(["cloud", "connectors", "get", "connector-1", "--"])
assert "--include-command" in connector
assert "--no-include-command" in connector
scan_wait = completion_candidates(["cloud", "scans", "start", "--"])
assert "--wait-timeout" in scan_wait
audit_export = completion_candidates(["cloud", "audit", "--"])
assert {"--output", "--force"} <= set(audit_export)
token_create = completion_candidates(["cloud", "tokens", "create", "--"])
assert {"--expires-at", "--rbac-scopes"} <= set(token_create)
def test_filesystem_completion_for_source_output_and_data(tmp_path: Any, monkeypatch: Any) -> None:
monkeypatch.chdir(tmp_path)
(tmp_path / "source tree").mkdir()
(tmp_path / "source.txt").write_text("source", encoding="utf-8")
(tmp_path / "request.json").write_text("{}", encoding="utf-8")
source = completion_candidates(["cloud", "scans", "start", "--source", "sou"])
assert source == ["source tree/"]
output = completion_candidates(["cloud", "scans", "report", "scan-1", "--output", "req"])
assert output == ["request.json"]
audit_output = completion_candidates(["cloud", "audit", "--output", "req"])
assert audit_output == ["request.json"]
data = completion_candidates(["cloud", "scans", "start", "--data", "@req"])
assert data == ["@request.json"]
def test_filesystem_completion_omits_terminal_control_names(
tmp_path: Any, monkeypatch: Any, capsys: Any
) -> None:
monkeypatch.chdir(tmp_path)
(tmp_path / "safe.json").write_text("{}", encoding="utf-8")
(tmp_path / "unsafe\nname.json").write_text("{}", encoding="utf-8")
(tmp_path / "unsafe\x1b]52;c;payload\x07.json").write_text("{}", encoding="utf-8")
words = ["cloud", "scans", "start", "--data", "@"]
assert completion_candidates(words) == ["@safe.json"]
assert run_completions(["--candidates", *words]) == 0
assert capsys.readouterr().out == "@safe.json\n"
def test_completion_scripts_cover_supported_shells(capsys: Any) -> None:
for shell in ("zsh", "bash", "fish"):
assert run_completions([shell]) == 0
output = capsys.readouterr().out
assert "completions --candidates" in output
def test_bash_completion_preserves_candidates_with_spaces(capsys: Any) -> None:
assert run_completions(["bash"]) == 0
output = capsys.readouterr().out
assert 'COMPREPLY=("${candidates[@]}")' in output
assert "while IFS= read -r candidate" in output
assert "mapfile" not in output
def test_completion_rejects_unknown_shell(capsys: Any) -> None:
assert run_completions(["powershell\x1b]52;c;payload\x07"]) == 2
error = capsys.readouterr().err
assert "Choose zsh, bash, or fish" in error
assert "\x1b" not in error
assert "\\x1b" in error

5
tests/test_pricing.py
View file

@ -14,7 +14,10 @@ def test_resolves_common_bare_model_names() -> None:
assert resolve_litellm_model("deepseek-v4-flash") == "deepseek/deepseek-v4-flash"
assert resolve_litellm_model("openai/deepseek-v4-flash") == "deepseek/deepseek-v4-flash"
assert resolve_litellm_model("grok-4.5") == "xai/grok-4.5"
assert resolve_litellm_model("MiniMax-M3") == "minimax/MiniMax-M3"
# MiniMax-M3 is sold by several LiteLLM providers at different prices, so
# the resolver must not guess from its bare name. A provider-qualified
# model remains deterministic.
assert resolve_litellm_model("minimax/MiniMax-M3") == "minimax/MiniMax-M3"
def test_resolver_returns_none_for_unresolvable_model() -> None: