SecureNow CLI Docs

SecureNow CLI

A full-featured command line interface for managing applications, investigating threats, analyzing traces, running forensic queries, and automating security workflows.

⚡

Auto-Instrument

Run any Node.js app with built-in OpenTelemetry tracing.

🔍

Investigate

Natural language forensic queries and IP intelligence lookup.

🛡️

Protect

Manage blocklists, firewall rules, and alert channels.

Quick Start

bash
# Install
npm install -g securenow

# Authenticate
securenow login

# Run your app with auto-instrumentation
securenow run src/index.js

# Check dashboard overview
securenow status

Installation

Install the securenow package globally or as a project dependency. It includes the CLI binary, Node.js SDK, MCP server, and framework integrations (Next.js, Nuxt, Express, Fastify, Koa, Hapi, NestJS, Vite).

Global (recommended for CLI usage)

bash
npm install -g securenow@latest

Project dependency

bash
npm install securenow@latest
npx securenow version

Run without installing

bash
npx securenow help
Requires: Node.js 22.23.4+, 24.22.1+, or 26.12.1+. The CLI is a CommonJS package and works on macOS, Linux, and Windows.

Authentication

Most CLI commands require authentication. The friendly login flow can connect both lanes: admin/control-plane auth is stored in .securenow/admin.json, while SDK runtime app config and the runtime API key are stored in .securenow/runtime.json.

Since v8, the browser runtime flow links the selected app, enables its firewall by default, mints a scoped runtime key for telemetry ingestion and firewall sync, and drops it into your runtime credentials. No SECURENOW_API_KEY env var is required.

securenow login

Authenticate with SecureNow. Opens a browser-based login flow, links the selected app, and connects the firewall by default.

FlagDescription
--token <TOKEN>Skip browser flow and use a token directly
--globalSave to ~/.securenow/ instead of the project-local .securenow/
bash
securenow login
securenow login --global
securenow login --token eyJhbGciOi...

securenow logout

Clear stored credentials from this machine.

bash
securenow logout

securenow whoami

Show current session info: email, user ID, API URL, token expiry, and default app.

bash
securenow whoami

api-key

Manage the runtime API key stored in .securenow/runtime.json. The v8 login/app-connect flow writes this automatically so you do not have to juggleSECURENOW_API_KEY in a .env file. The key must start withsnk_live_ and is required for telemetry ingestion and firewall sync.

securenow api-key set

Save a snk_live_ API key to the credentials file. Validates the prefix and auto-adds .securenow/ to .gitignore.

$ securenow api-key set <snk_live_...> [--global]
FlagDescription
--globalSave to ~/.securenow/ instead of project-local
bash
securenow api-key set snk_live_xxxxxxxxxxxxxxxx
securenow api-key set snk_live_xxxxxxxxxxxxxxxx --global

securenow api-key show

Print the currently-resolved API key (masked) and its source file.

bash
securenow api-key show

securenow api-key clear

Remove just the stored API key; leaves session token and app selection intact.

FlagDescription
--globalClear from ~/.securenow/ instead of project-local
bash
securenow api-key clear
securenow api-key clear --global

Configuration

CLI configuration is stored in ~/.securenow/config.json. You can also set values via environment variables.

Config KeyEnv VariableDefaultDescription
apiUrlSECURENOW_API_URLhttps://api.securenow.aiAPI base URL
appUrlSECURENOW_APP_URLhttps://app.securenow.aiDashboard URL
defaultAppSECURENOW_APP—Default application API key
output—textOutput format (text or json)
bash
# Set default app key
securenow config set defaultApp sk_live_abc123

# Get a config value
securenow config get apiUrl

# Show all config
securenow config get

# Show config file paths
securenow config path

Global Flags

These flags can be used with any command.

FlagShortDescription
--json-jOutput as JSON instead of formatted text
--help—Show help for a command
--verbose-vShow additional details in output
--force-fSkip confirmation prompts
--yes-yAlias for --force

Integration

Framework Setup

SecureNow auto-instruments your app with OpenTelemetry. Most frameworks need zero code changes — just a preload flag or one config line. See also: API Docs → SDK Installation | Download SKILL.md files

Express / Fastify / Koa / Hapi / NestJS

0 lines changed
bash
# Connect once. This writes .securenow/runtime.json.
npx securenow login

# Then add the preload flag — zero code changes.
node -r securenow/register src/index.js

# Or use the CLI
npx securenow run src/index.js

# PM2 ecosystem.config.cjs
module.exports = {
  apps: [{
    script: './app.js',
    node_args: '-r securenow/register',
  }],
};

Runtime Configuration

SecureNow boots from .securenow/runtime.json locally, then legacy/generated runtime credential files. Production should mount the tokenless runtime export as .securenow/credentials.json or .securenow/credentials.<env>.json. See also: API Docs → Runtime Config

VariableDefaultDescription
.securenow/runtime.jsonlocal SDK runtimeGenerated by `npx securenow login` or `npx securenow app connect`. Stores app identity, runtime API key, ingest routing, and SDK defaults.
.securenow/admin.jsonadmin CLI/MCPGenerated by `npx securenow admin login` or the friendly login flow. Stores admin/control-plane auth only.
.securenow/credentials.jsonlegacy/prod mountLegacy combined credentials are still read. Production should mount the tokenless runtime export here when needed.
.securenow/credentials.<env>.jsonproduction exportGenerated by `npx securenow credentials runtime --env production`; accepted directly when credentials.json is absent.

Run & Instrument

securenow run

Run a Node.js application with automatic OpenTelemetry instrumentation. Traces are sent to your configured SecureNow instance. Supports Node.js flags like --watch and --inspect.

$ securenow run [node-flags] [--firewall-only] <script> [app-args]
FlagDescription
--watchPass-through Node.js watch mode
--inspectPass-through Node.js inspector
--firewall-onlyPreload firewall without OTel tracing overhead — pure IP blocking, no spans or logs
bash
securenow run src/index.js
securenow run --watch src/index.js
securenow run --inspect src/server.js --port 3000
securenow run --firewall-only app.js
Implicit mode: If you pass a file path as the first argument (e.g. securenow src/index.js), the CLI automatically treats it as securenow run src/index.js.
--firewall-only: swaps securenow/register for securenow/firewall-only at preload. Loads dotenv + the IP firewall; skips the entire OTel SDK. Ideal when you want zero-overhead IP blocking without observability.

securenow init

Initialize SecureNow instrumentation in your project. Reuses the app, ingest routing, and runtime API key written by securenow login or app connect.

$ securenow init
FlagDescription
--key, --api-keyOptional existing runtime API key to write to .securenow/runtime.json
bash
securenow login
securenow init

Applications

securenow apps

Manage your monitored applications. Create, list, inspect, and delete apps, discover subdomains, and set a default app key for other commands.

$ securenow apps <subcommand> [options]
SubcommandDescriptionFlags
listList all applications--json
create <name>Create a new application--hosts <domains> --instance <id> --json
info <id>Show application details--json
delete <id>Delete an application--force --yes
default <key>Set a default application API key—
discover [appId]Discover subdomains and add as apps--domain <domains> --instance <id>
scanScan all app domains for new subdomains--yes --json
bash
# List all apps
securenow apps list

# Create an app linked to specific hosts
securenow apps create my-api --hosts api.example.com,www.example.com

# Set a default app for other commands
securenow apps default sk_live_abc123

# Discover subdomains
securenow apps discover --domain example.com

securenow status

Show a dashboard overview with app health, trace counts, alert status, and protection status.

$ securenow status [--app <key>]
FlagDescription
--app <key>Show status for a specific application
bash
securenow status
securenow status --app sk_live_abc123

Observe

securenow traces

View and analyze HTTP request traces collected by the SecureNow SDK. List recent traces, inspect individual requests, or trigger AI analysis.

$ securenow traces <subcommand> [options]
SubcommandDescriptionFlags
listList recent traces--app <key> --limit <n> --start <iso> --end <iso> --json
show <traceId>Show trace details (headers, body, timing)--app <key> --json
analyze <traceId>Start AI analysis on a trace--json
bash
# List last 10 traces
securenow traces list --app sk_live_abc --limit 10

# Inspect a specific trace
securenow traces show abc123-def456

# Run AI analysis on a suspicious trace
securenow traces analyze abc123-def456

securenow logs

View application logs. Filter by time window, severity level, or trace ID.

$ securenow logs <subcommand> [options]
SubcommandDescriptionFlags
listList recent logs--app <key> --limit <n> --minutes <n> --start <iso> --end <iso> --level <severity> --verbose --json
errorsWhat is failing: error lines grouped by message (ids and numbers normalized), with counts, first and last seen, and sample traces--app <key> --env <env> --since <1h> --warn --limit <n> --json
trace <traceId>Show logs for a specific trace--json
bash
# What is failing in production, grouped (8.18)
securenow logs errors --app <app-key> --env production --since 6h

# Last 2 hours of ERROR logs
securenow logs list --app sk_live_abc --minutes 120 --level ERROR

# Show logs for a specific trace
securenow logs trace abc123-def456

# Verbose output with trace/span IDs
securenow logs list --app sk_live_abc --verbose

securenow analytics

View aggregated response analytics for your applications. Shows traffic patterns and response code distribution.

$ securenow analytics [--app <key>] [--instance <id>] [--json]
FlagDescription
--app <key>Filter by application
--instance <id>Filter by ClickHouse instance
--jsonOutput as JSON
bash
securenow analytics
securenow analytics --app sk_live_abc --json

Detect & Respond

securenow notifications

Manage security notifications. List, read, or bulk-mark as read.

$ securenow notifications <subcommand> [options]
SubcommandDescriptionFlags
listList notifications--limit <n> --page <n> --json
read <id>Mark a notification as read—
read-allMark all notifications as read—
unreadShow unread notification count—

securenow review

Alert Review asks "is this rule right?". A rule that fired on more than 20 unknown addresses in one run, on 1,000 or more at once, or on one of your own servers is paused and its run waits here. Runs with the same root cause are grouped, so one decision can close a group. Closing never blocks or unblocks anyone.

$ securenow review <list|show|keep|close|dismiss|group> [row|rootCauseKey|notificationId] [options]
SubcommandDescriptionFlags
listOpen runs, grouped by root cause--search <app|rule|route|ip> --page <n> --limit <n> --json
show <row|key|id>One group (row or arc_ key) or one run (notification id)--json
keep <id>The rule is right: turn it back on, stop it pausing itself, close the run--reason <text> --yes
close <id>Close one run with an outcome--outcome <rule_tuning|false_positive|clean|deferred|...> --reason <text> --yes
dismiss <id>Dismiss one run, with a reason--reason <text> --yes
group <row|key>Close every run in a group with one decision--outcome <o> --reason <text> --preview --allow-mixed --yes
bash
# What is waiting, for one app (8.19)
securenow review list --search my-app

# Tune the rule first, then close everything it caused
securenow alerts rules change <rule-id> "ignore 404s from our uptime monitor"
securenow review group 1 --outcome rule_tuning --reason "Guard added in the new version" --preview
securenow review group 1 --outcome rule_tuning --reason "Guard added in the new version" --yes

securenow human

Requires Human asks "what do we do about this IP or plan?". The AI investigated and recommends something it will not do alone (it never blocks on its own verdict), or proposes a plan such as tuning a rule. Approving a tune_rule or create_exclusion plan only records the decision: change the rule first.

$ securenow human <list|show|block|fp|close|report|action|prompt|work|promotions> [row|notificationId:ip] [options]
SubcommandDescriptionFlags
listDecisions waiting, most urgent first--search <app|ip|rule> --limit <n> --json
show <row>The AI report, proofs, investigation steps and trace links--json
block <row>Approve the block--reason <text> --yes
fp <row>Mark a scoped false positive--reason <text> --conditions <json> --rule-scope --yes
close <row>Close without blocking: the row leaves the queue, the reason stays on the case--outcome <deferred|rule_tuning|new_alert_rule|ambiguous|skipped|rate_limited|other> --reason <text> --yes
report <row>Add a note; the row stays in the queue--outcome --summary <text> --yes
action <row>Approve or reject a case-level plan--status <approved|rejected> --reason <text> --yes

securenow agent

The runbook prompts your own coding agent (Claude Code, Codex, Cursor, any MCP client) follows to work both queues: Alert Review first, then Requires Human, a bounded number of groups and rows per pass, a report at the end. Read-only unless you add --confirm-writes; the API key's scopes are the hard limit.

$ securenow agent <prompt|prompts> [patrol|alert-review|human-queue] [options]
SubcommandDescriptionFlags
promptsList the runbook prompts (same as MCP prompts/list)--json
prompt <name>Print one runbook prompt--search <app> --confirm-writes --max-alert-review-groups <n> --max-human-rows <n> --json
bash
# One read-only pass with Claude Code: you get a plan
claude "$(npx securenow agent prompt patrol)"

# Every 30 minutes, allowed to act on one app (crontab)
*/30 * * * * claude -p "$(npx -y securenow@latest agent prompt patrol --search my-app --confirm-writes)" --allowedTools "mcp__securenow"

securenow alerts

Manage alerting rules and notification channels. Create custom detection rules from SQL, view rules, channels, and alert history.

$ securenow alerts <subcommand> [options]
SubcommandDescriptionFlags
rules from-text "<english>"Describe a detection in English; get a rule checked against your app's data (instant or periodic), created in test mode--app <key> --env <env> --instant|--periodic --draft-only --yes --json
rules createCreate a custom detection rule from your own SQL (or instant conditions)--name <name> --sql <sql|@file|-> | --conditions <json> --apps <k1,k2>|--applications-all --severity <level> --schedule <cron> --nlp <text> --channel <ids> --json
rulesList alert rules--mode test|prod --status <s> --json
rules show <id>Show one rule--json
rules runs <id>What each run saw and why it did or didn't notify (throttled, already blocked, trusted, no ip…)--limit <n> --since <1h> --json
rules run <id>Run a periodic rule now and print the run--no-wait --json
rules why <id>Why the rule did or didn't alert on one address: a verdict plus the evidence--ip <ip> --since <1h> --json
rules change <id> "<english>"Change a rule in English: rewritten from its current version and your data, checked, applied as a new version--app <key> --yes --draft-only --json
rules request-promotion <id>For agents: ask a person to promote a test-mode rule (they approve with securenow human approve-promotion)--reason <text> --evidence <text|@file>
rules update <id>Re-scope a rule's applications or change its status--applications-all | --apps <k1,k2> --enable|--disable
rules promote <id>Move a test-mode rule to prod (mitigations become eligible)--yes
rules test <id>Dry-run a rule query on your real data (live inserts 6 synthetic attack requests)--mode dry_run|live --wait --json
channelsList notification channels (Slack, email, webhook)--json
historyView alert history--limit <n> --page <n> --json
bash
# Describe the detection in English (8.16): checked against your app's data, created in test mode
securenow alerts rules from-text "one IP failing 10 sign-ins in 5 minutes" --app <app-key>

# Or create one from SQL. Scope app keys with __USER_APP_KEYS__ and return an "ip" column.
securenow alerts rules create \
  --name "Auth: magic-link brute force" \
  --sql @rule.sql \
  --apps <app-key> \
  --severity high \
  --nlp "single IP flooding /api/auth/signin or /api/auth/callback"

# See every run, and ask why it stayed quiet for an address (8.17)
securenow alerts rules runs <rule-id>
securenow alerts rules why <rule-id> --ip 203.0.113.50 --since 2h

# Change it in plain English (8.18)
securenow alerts rules change <rule-id> "raise the threshold to 20 failed sign-ins"

securenow fp

Manage false-positive exclusion rules. Create, test, dry-run, and AI-generate conditions to reduce alert noise.

$ securenow fp <subcommand> [options]
SubcommandDescriptionFlags
listList exclusion rules--json
show <id>Show rule details--json
createCreate exclusion rule--path <path> --path-op <op> --method <method> --reason <text> --conditions <json> --match-mode <all|any> --rule-scope --target-rules --json
edit <id>Edit an exclusion rule--active <bool> --reason --match-mode --conditions --json
delete <id>Delete a rule--force --yes
test-bodyTest a request body against conditions--body <body|@file> --conditions <json> --json
dry-runDry-run conditions against live traces (3 days)--conditions <json> --match-mode <all|any> --json
ai-fill [desc]AI-generate conditions from description--description --context <json> --json
mark <notif-id> <ip>Mark IP as false positive on a notification--conditions --match-mode --reason --rule-scope --target-rules --create-exclusion --apply-existing --json
bash
# Create a rule for a specific path and method
securenow fp create --path /api/webhook --method POST --reason "Legit traffic"

# AI-generate conditions from a description
securenow fp ai-fill "Health check from uptime monitor"

# Dry-run conditions against real traces
securenow fp dry-run --conditions '[{"field":"path","operator":"equals","value":"/health"}]'

# Mark an IP as false positive from a notification
securenow fp mark notif_abc123 203.0.113.1 --reason "Internal scanner"

Investigate

securenow ip

Look up threat intelligence for any IP address. Get SecureNow Score, AI verdict, bot detection, and SecureNow AI IPDB data. Also view traces from a specific IP.

$ securenow ip <ip-address>
SubcommandDescriptionFlags
lookup <ip>Full IP intelligence report--json
traces <ip>Show traces from this IP--json
bash
# Quick lookup (shorthand)
securenow ip 185.220.101.1

# Full lookup with JSON output
securenow ip lookup 185.220.101.1 --json

# See what requests came from this IP
securenow ip traces 185.220.101.1

securenow forensics

Ask questions about your traces, logs, errors and events in plain English. The forensics chat runs discovery queries, shows its SQL, says what the results show, and remembers the conversation, so a follow-up can say "those IPs". A conversation started in the dashboard can be continued here or by your agent over MCP (securenow_forensics_chat).

$ securenow forensics <query | subcommand> [options]
SubcommandDescriptionFlags
"<natural language query>"One question, no memory--app <key> --instance <id>
query <words...>Same as above (explicit subcommand)--app <key> --instance <id>
chat ["<question>"]Forensics chat with memory: interactive, or one question that prints the conversation id--app <key> | --conversation <id>, --env, --yes, --json
conversations [<id>]List chat conversations (dashboard, CLI and agent ones), or show one in full--app <key> --json
libraryView saved query templates--json
bash
# Start an investigation (prints the conversation id)
securenow forensics chat --app <app-key> "Which accounts had failed logins and then a successful one?"

# Follow up: the chat remembers the accounts, IPs and traces it found
securenow forensics chat --conversation <id> "What else did those IPs do after logging in?"

# Pick up a conversation someone started in the dashboard, interactively
securenow forensics chat --conversation <id>

# List conversations, or print one
securenow forensics conversations
securenow forensics conversations <id>

# One question, no memory
securenow forensics "Top 10 paths with 500 errors" --app <app-key>

securenow api-map

View the automatically discovered API surface map for your application. Shows endpoints, methods, and statistics.

$ securenow api-map [subcommand] [options]
SubcommandDescriptionFlags
listList discovered API endpoints--json
statsShow API map statistics--json

Firewall & Remediation

securenow firewall

Turn enforcement on or off per app environment, test whether a request would be blocked, and see what your blocks, rate limits and challenges actually stopped.

$ securenow firewall <subcommand> [options]
SubcommandDescriptionFlags
statusShow firewall status and active layers--json
enableTurn the firewall ON for an app environment--app --env
disableTurn the firewall OFF for an app environment--app --env
test-ip <ip>Would this IP, path and method be blocked? Sends no traffic--path --method --env --json
hitsWho was blocked, rate limited or challenged, per rule and per IP--since --action --source --rule --ip --env --json
bash
securenow firewall enable --env production

# Would a POST to /api/auth/register from this address be blocked in production?
securenow firewall test-ip 203.0.113.50 --path /api/auth/register --method POST --env production

# What did the firewall stop in the last hour?
securenow firewall hits --since 1h
securenow firewall hits --since 24h --action rate_limited

Guide: block an IP, a range or one route without a deploy.

securenow blocklist

Block an IP or a CIDR range, everywhere or scoped to one route, method, app and environment, for a set time. Running apps pick up changes in about 10 seconds.

$ securenow blocklist <subcommand> [options]
SubcommandDescriptionFlags
listList blocked IPs (full IDs in the first column)--app --env --json
add <ip|cidr>Block an address or range; omit --app/--env to block across all apps and environments--route --mode exact|prefix|regex --method --app --env --duration --reason
unblock <id>Lift a block, keeping its history and block report--reason --yes
statsShow blocklist statistics--json
bash
# Block one address everywhere, for a day
securenow blocklist add 198.51.100.77 --duration 24h --reason "Scraper"

# Block a range on one route and method, in production only
securenow blocklist add 203.0.113.0/24 --route /api/auth/register --mode exact --method POST \
  --env production --duration 24h --reason "Signup flood"

securenow blocklist list
securenow blocklist unblock <id> --reason "Attack over"

securenow ratelimit

Rate limits outside your code: by route and method, counted per IP, per request header (API key), per cookie (session) or globally. Over the limit, requests get a 429 with Retry-After.

$ securenow ratelimit <list|add|parse|from-text|show|test|enable|disable|remove> [options]
SubcommandDescriptionFlags
listList rules, with what each one counts per--app --env --status --json
add [ip|cidr]Create a rule--route --mode --method --limit --window --key-by ip|global|header|cookie --header --cookie --duration --name --reason
parse "<sentence>"Show the rule a plain-English sentence becomes, without creating it--app --env --header --cookie
from-text "<sentence>"Create a rule from plain English--yes --duration --env
test <ip>Which rules would match this request?--path --method --env
show | enable | disable | remove <id>Inspect, toggle or delete a rule--reason --yes
bash
# 5 login attempts per minute per IP, in plain English
securenow ratelimit from-text "rate limit POST /api/auth/login to 5 attempts per minute per IP" --yes

# 600 requests per minute per API key
securenow ratelimit add --route /api/v1 --mode prefix --limit 600 --window 1m --header x-api-key

# 10 exports per minute per signed-in session, for 24 hours
securenow ratelimit add --route /api/notes/export --mode exact --method GET \
  --limit 10 --window 1m --cookie connect.sid --duration 24h

securenow ratelimit test 192.0.2.50 --path /api/auth/login --method POST
securenow ratelimit list --env production

Header and cookie keys need securenow 8.14+. Share counters across processes with config.firewall.rateLimitStore. Guide: rate limit per API key, per session or per IP.

securenow allowlist

Only-allow mode. Once the allowlist has entries, only the listed IPs and ranges can reach the app; every other address gets a 403. Use it to lock an internal tool to known networks. To exempt a few addresses from blocks, use trusted instead.

$ securenow allowlist <subcommand> [options]
SubcommandDescriptionFlags
listList allowed IPs--app --env --json
add <ip|cidr>Allow an address or range--app --env --label --reason
remove <id>Remove an allowed entry--yes
statsAllowlist statistics--json

securenow trusted

Known-safe addresses: your office, CI runners, uptime monitors. Trusted IPs are left out of the block list your apps receive and excluded from threat scoring, but still traced and still rate limited.

$ securenow trusted <subcommand> [options]
SubcommandDescriptionFlags
listList trusted IPs--app --env --json
add <ip>Add a trusted IP--app --env --label
remove <id>Remove a trusted IP
bash
securenow trusted add 198.51.100.10 --label "Uptime monitor"

Telemetry

securenow log send

Emit a structured log record directly to your OTLP collector — without booting the SDK. Mirrors the SDK's getLogger().emit() API. Ideal for cron jobs, shell scripts, and CI pipelines.

$ securenow log send "<message>" [--level info|warn|error] [--attrs k=v,k=v]
bash
securenow log send "Deployment completed" --level info --attrs version=1.2.3,service=api
securenow log send "Backup failed" --level error --attrs host=db-01

Uses the resolved runtime credentials and default SecureNow ingest gateway unless advanced config.otel.* overrides are present. The runtime API key authenticates ingestion. Exits non-zero on HTTP failure so CI/cron can detect problems.

securenow test-span

Emit a single test span to verify your OTLP collector accepts traffic. Replaces the old SECURENOW_TEST_SPAN=1 env trick — works standalone, no SDK required.

$ securenow test-span [<span-name>]
bash
securenow test-span
securenow test-span "ci.smoke-test"
securenow test-span --json

Utilities

securenow redact

Preview sensitive-data redaction on a JSON payload. Mirrors the SDK's redactSensitiveData() — useful for verifying what will (and won't) reach your collector.

$ securenow redact '<json>' [--fields f1,f2] [--json]
bash
securenow redact '{"user":"alice","password":"s3cret","card":"4242"}'
securenow redact @request.json --fields internal_id,sessionHash

Accepts a JSON string or @path/to/file.json. Merges --fields on top of DEFAULT_SENSITIVE_FIELDS(password, token, card, ssn, …) and honors SECURENOW_SENSITIVE_FIELDS.

securenow cidr

CIDR utilities for testing firewall rules and debugging IP ranges. Wraps the SDK's createMatcher() and parseCidr() so you can validate behavior without writing Node.

$ securenow cidr <match|parse> ...
SubcommandDescriptionFlags
match <ip> <cidrs>Check if an IP matches a CIDR list — exit 0 on hit, 2 on miss (scriptable)--json
parse <cidr>Parse a CIDR — print network, broadcast, mask, size--json

bash
securenow cidr match 10.0.0.5 10.0.0.0/8,192.168.1.0/24
securenow cidr parse 10.0.0.0/24

securenow env

Print the resolved SecureNow configuration — service name, trace/log endpoints, firewall layers, and every relevant environment variable (with the API key masked).

$ securenow env [--json]
bash
securenow env
securenow env --json | jq .resolved

securenow doctor

End-to-end diagnostic. Probes your OTLP traces endpoint, OTLP logs endpoint, and the SecureNow API. Flags missing APPID, legacy collector addresses, and orphan firewall config. Exits 1 on any failure — wire it into CI healthchecks.

$ securenow doctor [--json]
bash
securenow doctor
securenow doctor --json

Settings

securenow instances

Manage ClickHouse instances used for trace storage and analytics.

$ securenow instances <subcommand> [options]
SubcommandDescriptionFlags
listList configured instances--json
test <id>Test connection to an instance--json

securenow config

View and manage CLI configuration. Settings are stored in ~/.securenow/config.json.

$ securenow config <subcommand> [key] [value]
SubcommandDescriptionFlags
set <key> <value>Set a configuration value—
get [key]Get a value (or show all if no key)—
pathShow config and credentials file paths—

securenow version

Print the installed CLI version.

$ securenow version
bash
securenow version

Ready to get started?

Install the CLI, authenticate, and start protecting your applications in minutes.