Help › Reference

Command reference

Reqlyn 0.5.1 is not released yet. This help describes it ahead of release.

Every command of reqlyn, the command line, as reqlyn help gives it, with its examples. This page is written by the program from its own usage (reqlyn help --reference), and a test fails when the two differ. How the commands are used is in The command line.

reqlyn list

reqlyn list

The stored operations: id, then name.

Examples:

reqlyn list

reqlyn run

reqlyn run <operation> [--input <json> | --input-file <path>] [--junit <path>]
    [--preview [--read-first]] [--var <name>=<value>]...
    [--keep-case <name>] [--data <file> [--parallel <n>]]

Runs a stored operation on this computer, by its name or id, and prints its output as JSON. The input is a JSON object of the operation's inputs; without one it is {}. With --junit, a JUnit XML report of the run is written to that file: a test case for each step and one for the output contract. With --preview, nothing is sent: it says what a run would send, step by step. With --read-first too, the reads its steps name for what they write to are sent, once each, and what each finds is printed beside what the write would send. With --var, that variable has that value for this run, in place of the selected environment's; it may not be secret, nor have a name that looks secret. A variable no environment sets takes the default the operation's descriptions give it, where they give one. With --data, it runs once for each row of a CSV file (its first line names the columns) or a JSON array of objects, each column one of the operation's inputs, a cell read as its input's kind; --parallel runs that many rows at a time (1 unless given). It prints a line for each row and a summary, and ends with 1 when a row's run failed; with --junit, the report has a test case for each row.

Examples:

reqlyn run "Device overview" --input '{"deviceId": 4831}'
reqlyn run "Device overview" --input-file input.json --junit report.xml
reqlyn run "Device overview" --input '{"deviceId": 4831}' --keep-case pe01
reqlyn run "Update address" --input '{"address": "10.24.10.11"}' --preview --read-first
reqlyn run "Device overview" --input '{"deviceId": 4831}' --var inventory=https://inventory.lab.example

reqlyn test

reqlyn test <operation> [--junit <path>] [--pack <file>] [--remove <name>]
    [--rename <name> <new name>] [--ignore <name> <place,place>]
    [--generate <n> [--writes] [--plausible]]

Replays the operation's regression cases, as it is saved now, and holds each output against the one the case kept. Nothing is sent. A case is kept from a live run with run --keep-case <name>; secrets are masked first. Ends with 1 when a case does not hold. Exported with the operation, beside its Arazzo source, as <name>.cases.yaml. With --pack, the cases of that file are replayed instead, and nothing is kept. With --remove <name>, that kept case is removed; --rename gives it another name; --ignore sets the places of the output it leaves out (an empty list for none). Each replays nothing. With --generate, that many inputs (1 to 20) are made from the operation's input types and names, each run live where the selected environment points (a mock from a description, typically) and kept as a case named for its input; an operation that may write only with --writes. Ends with 1 when a run gave nothing to keep. With --plausible, the configured model is first asked for plausible values of the string inputs Reqlyn has no words for, sent their names and types only.

Examples:

reqlyn test "Device overview"
reqlyn test "Device overview" --pack device-overview.cases.yaml --junit cases.xml
reqlyn test "Device overview" --ignore pe01 checkedAt
reqlyn test "Device overview" --generate 3

reqlyn requests

reqlyn requests

The saved requests: id, method and name. With --json first, a list with each one's address too, a secret in it masked.

Examples:

reqlyn --json requests

reqlyn send

reqlyn send <request> [--var <name>=<value>]...

Sends a saved request, by its name or id, from this computer, with the selected environment's variables (--var in place of one) and its credential, and prints the status, then the body. With --json first, one object with its headers and time too, a secret-named header's value masked. Ends with 1 when the status is not a success. Under REQLYN_FOLDER, the folder workspace's requests.

Examples:

reqlyn send "Device" --var id=4831
reqlyn --json send "Device"

reqlyn mcp

reqlyn mcp [--folder <path>]

An authoring MCP server on standard input and output, for a coding agent on this computer: it reads and writes the workspace's saved requests, operations, variables and cases, each change saved at once (never a secret), and tests an operation that only reads and replays its cases. With --folder, that folder is the workspace, its files the definitions (changes reviewed in Git), its index kept in .reqlyn inside it unless REQLYN_DATA_DIR names another data folder.

Examples:

reqlyn mcp --folder .

reqlyn migrate

reqlyn migrate <operation> <file> --source <name> [--apply all|<n,n>]

What a newer OpenAPI description of an upstream API suggests for a stored operation whose Arazzo source names it (--source): for each response field it no longer documents, a field it adds in its place, numbered. With --apply, the chosen ones are applied, the operation is saved as its next revision, and its cases are replayed; it ends with 1 when a case does not hold. Nothing is sent or published.

Examples:

reqlyn migrate "Device overview" inventory-v2.yaml --source inventory
reqlyn migrate "Device overview" inventory-v2.yaml --source inventory --apply all

reqlyn mock

reqlyn mock <file> [<file>...] [--port <port>] [--stateful] [--throttle <n>]
    [--expire <n>] [--delay <ms>] [--malformed <n>] [--failing-page <n>]
    [--plausible]

Serves on 127.0.0.1 what HAR recordings answered, by method and path: a path asked as recorded gets its answers in turn, then its last; one that only fits an endpoint's pattern gets that endpoint's first; anything else 404. A file may be an OpenAPI description instead: each of its calls answers its first success, with the media's example or realistic data generated from its schema, the same for the same call; what was recorded comes first. With --plausible, the configured model is first asked for plausible values of the string fields Reqlyn has no words for, sent their names and types only. With --stateful, a POST of a JSON object keeps it (given an id when it has none): a GET of the same path lists what was kept, and a GET, PUT, PATCH or DELETE of the path and an id reads, replaces, changes or removes one, or answers 404. Point an operation's base address at it to run it with no upstream reached. Each request is printed. Without --port, a free port. Faults, counted over every request: --throttle refuses every nth with 429 and Retry-After: 1; --expire refuses every nth that sends a token with 401; --delay waits before each answer; --malformed cuts every nth body in half; --failing-page answers 500 to the page of that number (page=n). Stop it with Ctrl+C.

Examples:

reqlyn mock lookup-1.har lookup-2.har --port 9000
reqlyn mock lookup-1.har --throttle 5 --delay 200

reqlyn demonstrate

reqlyn demonstrate <recording> <recording> [<recording>...] [--save <name>]
    [--check <recording>] [--probe] [--yes] [--describe <file>]

Compares two or more HAR recordings of one task: the calls every recording makes, in order, the values one response gives that a later call sends, and what was set aside as noise. Drafts an operation from them: what differs becomes an input, what one response gives a mapping, what was masked an environment variable; each with what it rests on, and what is assumed. No secret is printed. An example of each call, masked, is printed to review it with; --describe writes the calls described as OpenAPI 3.1 to a file. Nothing is sent or run; with --save the draft is saved as an operation of that name, its requests in a folder of their own. With --check, a third recording of the task, not compared: the inputs it sent and what it ended with are read from it, and the steps that write are named. With --yes as well, the saved draft is run with those inputs on this computer, and its output held to what the example ended with. Ends with 1 when it does not hold. With --probe, the questions the recordings leave open (whether a query value is needed, how a paged list ends, what an item that is not there gives), each with the one GET that answers it, at most ten; nothing else is ever proposed. With --yes they are sent, with the environment's variables, and each answer is said.

Examples:

reqlyn demonstrate lookup-1.har lookup-2.har
reqlyn demonstrate lookup-1.har lookup-2.har --save "Device lookup" --check lookup-3.har --yes
reqlyn demonstrate lookup-1.har lookup-2.har --probe

reqlyn load

reqlyn load <operation> --callers <n> --seconds <n> [--ramp <seconds>]
    [--per-minute <n>] [--input <json> | --input-file <path>]
    [--var <name>=<value>] [--writes]
    [--p95-under <ms>] [--errors-under <percent>] [--junit <path>]

Runs a stored operation again and again on this computer: as many callers as asked, each starting in turn over the ramp, for that long, at most --per-minute runs a minute among them. Each run is live, through the selected environment; its requests are not kept in the history. An operation with a step that may write is loaded only with --writes. At most 50 callers for 600 seconds. Prints its runs, latency percentiles and errors, and each step's; ends with 1 when a run failed. With --p95-under or --errors-under, it ends with 1 only when the runs' p95 time or their share that failed is not under it, and says which; --junit writes a report with a case for each threshold. On a server: reqlyn remote load, which takes the same three.

Examples:

reqlyn load "Lax devices" --callers 5 --seconds 30 --ramp 5
reqlyn load "Lax devices" --callers 2 --seconds 60 --per-minute 120

reqlyn fuzz

reqlyn fuzz <openapi file> [--operation <id>] [--runs <n>] [--seed <n>]
    [--writes] [--with-credentials]

Generates inputs at random within each operation's schemas (every required parameter and field, optional ones sometimes, numbers within their bounds, strings within their lengths and of any characters) and sends them as negatives does, 100 for each operation unless --runs says. The first that the API fails on (a 5xx, or no answer) is made as small as it can be while it still fails, and both are shown; ends with 1 then, and with 2 when nothing was sent. Only through the selected environment when it allows fuzzing; the seed is printed, and --seed gives the same inputs again.

reqlyn environment

reqlyn environment <name> [--create] [--select] [--allows-fuzzing yes|no]

Creates an environment, selects it (runs and sends use its variables), or marks it as allowing fuzzing or not, in that order. None allows fuzzing at first, and the one that always exists never does.

reqlyn negatives

reqlyn negatives <openapi file> [--writes] [--with-credentials] [--keep <file>]
reqlyn negatives --operation <operation> [--writes] [--with-credentials]

Generates, from each operation's schemas, requests that break one rule of the description each: a required parameter or field left out, a string past its length, a number past its bounds, a value outside its enum or of the wrong kind; and for each bound, one exactly at it, which the description allows. Sends each to the description's server with the selected environment's variables, and says what each got; a success to what it forbids, or a 400 or 422 to what it allows, is a finding, and ends with 1. A case that writes is sent only with --writes; one that would carry the credential its operation names, or a secret variable, only with --with-credentials, as the description chose where it goes: first it says where. --keep writes what they got. With --operation, the cases of what a stored operation's steps call, from the descriptions it keeps, are kept beside its regression cases, in place of those sent before; reqlyn test lists them.

Examples:

reqlyn negatives devices.openapi.yaml --keep devices.negatives.yaml
reqlyn negatives --operation "Device lookup" --writes

reqlyn draft

reqlyn draft <openapi file> --prompt <what it is to do> [--yes]

Asks Claude to draft an operation over that API, with assistance turned on in the desktop's Settings and its key. Only the request and the description's shape are sent: each operation's id, method and path, its parameters and the names and kinds of its fields; no example, server or prose. Without --yes the question is printed and nothing is sent. With it, the Arazzo document Claude drafts is saved as an operation with the description, its first lines saying the request, the model and what it assumed, if it compiles; nothing is run.

Examples:

reqlyn draft netbox.openapi.yaml --prompt "Find a device's primary address by its name" --yes

reqlyn arazzo check

reqlyn arazzo check <file>

Reads an Arazzo 1.0 or 1.1 document, in YAML or JSON, and says what is wrong with it, each at its place, or that it is valid and each workflow compiles with the descriptions beside it, as compile and saving it do. Nothing in it is run. Ends with 0 when it is valid and compiles, 1 when it is not.

Examples:

reqlyn arazzo check device-overview.arazzo.yaml

reqlyn arazzo compile

reqlyn arazzo compile <file> [--workflow <id>]

Compiles a workflow of an Arazzo document to the operation Reqlyn would run, and prints its requests and the operation as Reqlyn definitions. Each OpenAPI source description is read from its url, a path beside the document; nothing is fetched. What Reqlyn cannot run yet is named at its place, and the command ends with 1.

Examples:

reqlyn arazzo compile device-overview.arazzo.yaml --workflow deviceOverview

reqlyn arazzo save

reqlyn arazzo save <file>

Compiles the document's workflow as compile does and stores it as a new operation whose source is the document and its OpenAPI descriptions, read from beside it; prints its id and name. The regression cases in <name>.cases.yaml beside it, as export writes them, are kept with it, masked again. Nothing is run. Ends with 1, storing nothing, when it does not compile.

Examples:

reqlyn arazzo save device-overview.arazzo.yaml

reqlyn arazzo run

reqlyn arazzo run <file> [--workflow <id>] [--input <json> | --input-file <path>]
    [--var <name>=<value>]...

Compiles the workflow as compile does and runs it on this computer, as run runs a stored operation, with the same output and exit status. The requests are sent with the selected environment's variables, each --var in place of one, and a server variable no environment sets takes its description's default. Nothing is stored.

Examples:

reqlyn arazzo run device-overview.arazzo.yaml --input '{"deviceId": 4831}'
reqlyn arazzo run device-overview.arazzo.yaml --input '{"deviceId": 4831}' --var inventory=http://127.0.0.1:8787

reqlyn arazzo export

reqlyn arazzo export <operation> [--out <folder>]

Writes a stored operation as an Arazzo document, and an OpenAPI description for each origin its requests are sent to, into the folder (here unless given). What Arazzo cannot carry yet is named at its place, and nothing is written. A file already there is not overwritten.

Examples:

reqlyn arazzo export "Device overview" --out exported

reqlyn lint

reqlyn lint <description> | --operation <operation> [--ruleset <file>]
    [--json] [--fail-severity error|warn|info|hint]

Holds an OpenAPI or AsyncAPI description to a ruleset written as Spectral writes them: the one named, or .spectral.yaml, .yml or .json in this folder, or else Spectral's rules for an OpenAPI or AsyncAPI description (spectral:oas, spectral:asyncapi). With --operation, a stored operation and the requests it sends are held to Reqlyn's own rules (reqlyn:operations): a name, a description and an owner, each request named, a secret header kept as a credential, a write with a read named first. Its rules' JSONPath, core functions, severities, messages and formats are read; it extends files beside it, never an address, and a function written in JavaScript is not run. Prints each finding: where, severity, rule and why; --json as Spectral's JSON. Ends with 1 when a finding is at or above --fail-severity (error unless given).

reqlyn check save

reqlyn check save <file> | list | run <name>

Reconciliation checks: two stored operations' records, from the list a step of each received, matched by an exact key, each field held to the side that owns it. save keeps the check written in a file (reqlyn: 1, check: name, left, right, fields, fresh); run runs both operations here and prints what matched, what is missing on either side, what is held twice, which owned fields disagree and which records are stale, each with its record. Nothing is written to either system.

Examples:

reqlyn check save inventory-ipam.yaml
reqlyn check list
reqlyn check run "inventory against ipam"

reqlyn workspace-key

reqlyn workspace-key [create | conflicts | keep <id> | take <id>]
reqlyn workspace-key folder <path> publish | join <workspace> | devices
    | approve <device> --code <code> | accept --code <code> | sync
    | revoke <device> | recover

The workspace key for encrypted sync: which workspace and device this is, and whether its keyring is in the secret store. create makes it and prints its recovery kit once, to keep offline; Reqlyn keeps no copy. conflicts lists each definition changed here and on another device since it was last synchronized, both versions; keep sends mine as the next revision at the next synchronizing, take saves theirs here. folder does what remote workspace-key does, through a folder you synchronize yourself instead of a server: the same sealed files, each device checking every approval itself.

Examples:

reqlyn workspace-key create
reqlyn workspace-key conflicts
reqlyn workspace-key folder "D:\OneDrive\Reqlyn" sync

reqlyn snippet

reqlyn snippet <request> [--language curl|python|rust|typescript]

Prints a saved request, by name or id, as code that sends it: curl, Python with httpx, Rust with reqwest, or TypeScript with fetch. Variables stay as {{name}}, a likely secret is masked, and a credential is left out; what is left out is said. Nothing is sent.

Examples:

reqlyn snippet "Devices" --language python

reqlyn connector key

reqlyn connector key <name>

Makes a publisher key to sign connector packages with, keeps its private half in this computer's secret store, and prints its public half: what a workspace that installs your packages lists as trusted.

Examples:

reqlyn connector key "Network team"

reqlyn connector pack

reqlyn connector pack <operation>... --name <name> --version <version>
    --publisher <who> --key <key name> [--readme <file>] --out <file>

Packs stored operations into one signed connector package: each with the requests it sends, written as definitions with no secret value, its output contract, its Arazzo source when it has one, and its regression cases as fixtures (masked when they were kept), with the readme as its documentation. A file already there is not overwritten.

Examples:

reqlyn connector pack "Device overview" --name inventory --version 1.0.0 --publisher "Network team" --key "Network team" --out inventory-1.0.0.connector.yaml

reqlyn connector check

reqlyn connector check <file>

Reads a connector package, checks its signature with the publisher key it names, and says what it holds. Ends with 1 when the signature does not verify. Nothing in it is run or installed.

Examples:

reqlyn connector check inventory-1.0.0.connector.yaml

reqlyn connector install

reqlyn connector install <index address> <name> [--version <version>]
    [--allow-once]

Installs a package from a public registry: the index read over HTTPS and its signature checked, the package fetched beside it and held to the digest the index gives, then installed as a file is (below). The latest version unless --version says.

Examples:

reqlyn connector install inventory-1.0.0.connector.yaml
reqlyn connector install https://packages.example/reqlyn inventory --version 1.0.0
reqlyn connector search <index address> [<words>]

What a public registry's index names: each package, its version, publisher, key and summary; with words, those that match.

reqlyn connector index

reqlyn connector index <folder> --name <who keeps it> --key <key name>

Writes reqlyn-index.yaml into a folder of package files: each named with its version, publisher, key and digest, the index signed with the publisher key. Host the folder over HTTPS as it is.

reqlyn connector install

reqlyn connector install <file> [--allow-once]

Installs a connector package once its signature verifies and its publisher key is one this computer trusts (or, with --allow-once, for this install only): each operation saved as new, with its requests and cases. No request saved here is written over, and nothing is installed when an operation of the same name is here. A credential its requests name is this computer's of that name.

reqlyn connector trust

reqlyn connector trust <public key> <name> | distrust <public key>

Trusts a publisher key under a name, or stops trusting it.

Examples:

reqlyn connector trust 505bbc83c08d1447652167b4385e7308cbc7d3972d71970b0459abd5a9a1471a "Reqlyn curated"

reqlyn connector trusted

reqlyn connector trusted

The publisher keys trusted here, and their names.

reqlyn plugin pack

reqlyn plugin pack <script> --name <name> --kind auth|importer|template
    --version <version> --publisher <who> --key <key name> [--readme <file>]
    [--out <file>]

Signs a plugin's JavaScript with the publisher key of that name (made with reqlyn connector key), as a plugin file: <name>.reqlyn-plugin unless --out. Its script runs in the sandbox, with no network and no file: an auth plugin's sign(asked) is given each request and its credential's detail and secret, and gives { headers, query } to add.

Examples:

reqlyn plugin pack sign.js --name acme-sign --kind auth --version 1.0.0 --publisher Acme --key acme

reqlyn plugin install

reqlyn plugin install <file> [--allow-once]

Installs a plugin file: its signature checked, its publisher key one this computer trusts (reqlyn connector trust), unless --allow-once. One of the same name is replaced. A credential of kind plugin names an auth plugin to sign its requests.

Examples:

reqlyn plugin install acme-sign.reqlyn-plugin

reqlyn plugin list

reqlyn plugin list | remove <name>

The plugins installed here: name, kind, version and publisher; or one removed, after which a credential naming it cannot be sent with.

reqlyn account

reqlyn account [status] | sign-in | check | sign-out

Your Converged Innovations account on this computer and Reqlyn's license. Reqlyn is free for one person; a license, a 30-day trial first, also allows sync between computers, curated packs, and load tests and fuzzing. sign-in opens the browser and activates this computer; check asks for the license again.

Examples:

reqlyn account
reqlyn account sign-in

reqlyn credential origins

reqlyn credential origins <name> | allow <name> <origin>

The origins a credential of this computer may be sent to, or one more. A request whose credential has not gone to its origin before is not sent until it is allowed, here or in the desktop's Connections.

reqlyn plugin import

reqlyn plugin import <importer> <file>

Reads the file with an installed importer plugin, whose parse(text) gives the requests in it, and saves each; a secret-named header's value is kept as a variable of its name instead. A template plugin's functions are called from a request as {{plugin.function(args)}}.

Examples:

reqlyn plugin import acme-collection requests.acme

reqlyn remote list

reqlyn remote list [<words>]

What the server's workspace has published: id, latest version, where that version stands, name; under it, the most requests a run can send beside its limit, and beside each limit the deployment manifest sets for an environment. With words, only the operations whose id, name, owner, publisher or description holds them.

Examples:

reqlyn remote list device

reqlyn remote environments

reqlyn remote environments

Where it can be run: each environment and its latest revision.

reqlyn remote activate

reqlyn remote activate <operation id> <version> <environment>

Checks that the environment binds what the version needs, and lets the version be run there. Nothing is sent to any API.

Examples:

reqlyn remote activate device-overview 3 lab

reqlyn remote version

reqlyn remote version <operation id> <version> active|retired|disabled

Says where a version stands from now on. Retired, it still runs where it is activated and is activated nowhere new. Disabled, no run of it is accepted and none that was waiting is started.

reqlyn remote tool

reqlyn remote tool <operation id> <version> allow|disallow

Allows a version that writes to be offered as an MCP tool, or takes that back. A version that only reads is offered without it. For the workspace's administrators.

reqlyn remote run

reqlyn remote run <operation id> <version> --environment <name>
    [--input <json> | --input-file <path>] [--key <text>]
    [--max-age <seconds>] [--no-wait]
    [--data <file> [--parallel <n>] [--junit <path>]]

Asks a Reqlyn server to run a published version in an environment, waits for the run and prints its output as JSON. With --key, asking again with the same key and input within a day gives the same run and makes no other. With --max-age, a result that young, where the deployment manifest lets one be taken for that version, is given in place of a new run. With --no-wait, prints the run's id and stops. With --data, asks for a run for each row of a CSV or JSON file, as reqlyn run --data does, --parallel of them at a time, and waits for each: a line for each row, a summary, and with --junit a report with a test case for each row.

Examples:

reqlyn remote run device-overview 3 --environment lab --input '{"deviceId": 4831}'
reqlyn remote run device-overview 3 --environment lab --input '{"deviceId": 4831}' --key nightly-2026-10-21 --no-wait

reqlyn remote load

reqlyn remote load <operation id> <version> --environment <name>
    --callers <n> --seconds <n> [--ramp <seconds>] [--per-minute <n>]
    [--input <json> | --input-file <path>] [--writes] [--no-wait]
    [--p95-under <ms>] [--errors-under <percent>] [--junit <path>]

Runs a published version again and again on the server: as many callers as asked, each starting in turn over the ramp, for that long, at most --per-minute runs a minute among them. Every request waits its turn under the workspace's shared rate limits. Only where an administrator lets the environment take load, within its ceiling; a version with a step that may write, only with --writes. Waits for its end and prints its runs, latency percentiles and errors, and each step's; ends with 1 when a run failed. With --no-wait, prints its id. remote load-status <id> shows it, remote load-stop <id> stops it after the runs under way.

Examples:

reqlyn remote load-policy lab on --callers 20 --seconds 300
reqlyn remote load device-overview 3 --environment lab --callers 10 --seconds 60 --ramp 10

reqlyn remote load-policy

reqlyn remote load-policy <environment> [on | off] [--callers <n>] [--seconds <n>]

Shows whether an environment takes load and its ceiling; with on or off, an administrator lets it take load or not, at most --callers callers for --seconds seconds (50 and 600 unless set).

reqlyn remote explain

reqlyn remote explain <run>

Asks the workspace's model why a failed run failed, where an administrator turned assistance on: the server sends the run's record, every secret masked, with the version's Arazzo source and its descriptions' shape. A change it proposes that compiles is saved as a new draft, <operation>-fix, to review; nothing is run or changed.

reqlyn remote draft

reqlyn remote draft <openapi file> --prompt <what it is to do> [--yes]

Prints what the server would ask Claude, the request and the description's shape only; with --yes, the server asks it, where an administrator turned assistance on, and saves what Claude drafts as a new draft to review and publish as any draft is. Nothing is run.

reqlyn remote demonstrate

reqlyn remote demonstrate <recording> <recording> [...] [--draft <id> [--name <name>]]
    [--describe <file>] [--explain [--yes]]

Uploads two or more HAR recordings of one task and has the server compare them, as reqlyn demonstrate does here; with --draft, the operation they draft is saved as a new draft of that id, and its review before publishing shows the calls described and an example of each. With --explain, prints what Claude would be sent about the task, its shape only; with --yes too, the server sends it, where an administrator turned assistance on, and prints what Claude suggests. Nothing suggested is applied. An editor's.

reqlyn remote assistance

reqlyn remote assistance [on --secret <id> [--model <model>] [--endpoint <address>] | off]

Says whether the workspace asks Claude, with which model; on or off sets it, the key being the workspace secret named (set it first with the secrets API). With --endpoint, the model is asked at that OpenAI-compatible endpoint, https or on the server's own computer, in place of Anthropic's. An administrator's. Only a task's or a description's shape is ever sent.

reqlyn remote upload

reqlyn remote upload <file>

Gives the server a file for a run to send, and prints its id. The id is the value of a file input, for whoever uploaded it, until the server lets it expire.

reqlyn remote status

reqlyn remote status <run id>

Prints a run as the server tells it, as JSON.

reqlyn remote events

reqlyn remote events <run id>

What the run did, in order: each step, and each request with its status, size and time. No header and no body.

Examples:

reqlyn remote events 0f6c2a1e-…

reqlyn remote audit

reqlyn remote audit [--actor <who>] [--action <what>] [--json]

The workspace's audit trail, oldest first: id, time, who, what, to what, and its detail. An action is given whole (secret.set) or by its first part (secret). With --json, one event a line, to keep in a file. For the workspace's administrators.

reqlyn remote preview

reqlyn remote preview <operation id> <version> [--input <json>]
    [--read-first <environment>]

What a run of the version with this input would send, step by step: each method and address filled from the input, its body, what earlier steps would give it, and which steps write. Nothing is sent. With --read-first, a run in that environment sends only the reads its steps name for what they write to, once each, through its runner, and what each finds is printed beside what the write would send. No write is sent. For whoever may run the version there.

reqlyn remote resume

reqlyn remote resume <run id> [--from <step>] [--yes]

Resumes a run that failed, as a new run: the steps before the one it failed at (or --from) answer from what it received and are not sent, for a day after it failed. A step that does not only read is sent again only with --yes, once you have seen what it did. Not for runs an agent carries.

reqlyn remote undo

reqlyn remote undo <run id> <step> --yes

Undoes a step of a run that failed or was cancelled: a new run sends the request the step names to undo it, once, filled from the run's input and from what its steps received (kept a day). Waits for it and prints how it ended. Nothing is undone by itself. Not for runs an agent carries.

reqlyn remote cancel

reqlyn remote cancel <run id>

Cancels a run, and prints it as it then stands. What it has already done is not undone.

reqlyn remote apply

reqlyn remote apply <manifest> [--yes]

Makes a deployment manifest the workspace's: its routes, and how each version is hosted in an environment (run limits, fields never kept, reads only, keeps bodies, how old a result may be taken), and nothing else. Says the plan first, each added (+), changed (~) or removed (-); applies it only with --yes. For the workspace's administrators. A route answers under the server's /routes, as GET /routes/devices/4831/health.

Examples:

reqlyn remote apply deployment.yaml
reqlyn remote apply deployment.yaml --yes

reqlyn remote webhook

reqlyn remote webhook <address> | --remove

Where the workspace's drift alerts are posted: once for each change to a place a version reads, or a new failing status, and again only after it stopped and came back. The address has to be one the server's operator allows (REQLYN_ALLOWED_DESTINATIONS). For the workspace's administrators.

reqlyn remote drift

reqlyn remote drift <operation> <version>

Where what the version's steps receive has parted from what its first 20 responses showed: a field gone or of another type, a new field, a new status. Field names and types only; no value is kept. Under each change, the other published versions that call the same endpoint and read that place; then every version calling it, with its state and where it is activated. A version published with its Arazzo source is also compared with the OpenAPI descriptions it was imported with, from its first response. Ends with 1 when a place this version reads has changed.

Examples:

reqlyn remote drift device-overview 3

reqlyn remote impact

reqlyn remote impact <file or address> --source <name>

What a newer OpenAPI description of an upstream API would change for each published version whose Arazzo source names that description (--source, as the source names it): an operation gone or moved, an input now required, other security, a status or a response field no longer documented or of another type. An address is fetched by the server, through its allowlist. Ends with 1 when a run could fail or give something else because of it.

Examples:

reqlyn remote impact inventory-v2.yaml --source inventory

reqlyn remote approvals

reqlyn remote approvals

The activations waiting for a second person's approval: in an environment the deployment manifest names under approval:, activating a version asks for it.

reqlyn remote approve

reqlyn remote approve <request> | refuse <request>

Approves an activation request, which activates the version as you would, or refuses it. For a publisher or administrator signed in as a person, other than whoever asked and whoever issued the token that asked; never a service token.

reqlyn remote workspace-key publish

reqlyn remote workspace-key publish | join <workspace> | devices
reqlyn remote workspace-key approve <device> --code <code> | accept --code <code>
reqlyn remote workspace-key sync | revoke <device> | recover
reqlyn remote workspace-key history <name or id> | restore <name or id> <revision>

The workspace key on the server, which holds public keys and ciphertext only. publish puts this computer's key there; join enrolls this device and prints the code each approved device should show for it; devices lists them, with the code of each waiting one. approve gives a waiting device the keyring, sealed to it and signed, only when the code typed is the one shown here; accept takes it on the joining device, its signature checked and only when the code typed is the one shown here for the approver. sync takes the requests and operations other devices sent since the last time, and sends each changed here, each sealed with the workspace key: one changed here and elsewhere since it was last synchronized is kept as it is here and named. revoke re-keys: a new epoch's keyring for every other approved device and the recovery kit, so the revoked device cannot read anything synchronized after; its access to the server is revoked separately, with its token or membership. recover, on a computer that joined after every device was lost, reads the recovery kit from standard input (never from the command line), opens the workspace key with it, and is approved by the kit's signature. history opens every revision of a synchronized definition the server keeps (the last fifty) and shows what each changed from the one before; restore saves one here, to be sent as the next revision.

reqlyn remote check publish

reqlyn remote check publish <file> --environment <name> --versions <left> <right>

Publishes a reconciliation check over two published versions that only read: reconciled on the server each time either side's run in that environment succeeds, against the other side's last records. Schedule both to keep it fresh. A publisher's.

reqlyn remote checks

reqlyn remote checks | check show <name>

The workspace's checks, each with its last findings and when each side's records were read. For an editor or above.

reqlyn remote check plan

reqlyn remote check plan <name>

Proposes a plan correcting the check's last conflicts, each through the fix its owned field names, previewed: nothing is sent. What it does not correct is said, with why. For an editor or above.

reqlyn remote plan show

reqlyn remote plan show <id> | approve <id> | refuse <id>

A plan, or its decision. Approved by a person signed in as a publisher, other than whoever proposed it, each write's run is asked for, once.

reqlyn remote plan outcome

reqlyn remote plan outcome <id>

What became of a decided plan, finding by finding: resolved, unresolved, skipped or uncertain, with why, and how many of each.

reqlyn remote connector publish

reqlyn remote connector publish <file> [--allow-once]

Publishes a connector package to the workspace's registry: signed by a publisher key the workspace trusts (or, with --allow-once, by an administrator's leave for this package only), later than every version before it, and, when it may break their callers, a new major version. What changed since the version before is said. A published version is never changed. A publisher's.

reqlyn remote connectors

reqlyn remote connectors

The packages in the registry, each with its versions, latest first.

reqlyn remote connector get

reqlyn remote connector get <name> <version> --out <file>

Writes a published version's package file, to install here with reqlyn connector install.

reqlyn remote connector install

reqlyn remote connector install <name> <version>

Installs a published version into the workspace: each of its operations saved as a new draft, to review, publish and activate in your own environments. Says the credentials its requests name, to bind there. Nothing is published or run. An editor's.

reqlyn remote connector trust

reqlyn remote connector trust <public key> <name> | distrust <public key>
    | keys

The publisher keys the workspace trusts. Trusting and distrusting are an administrator's.

reqlyn remote sdk

reqlyn remote sdk --language python|rust|typescript|go|csharp|java|powershell|ruby|php|kotlin|swift
    --out <folder> [--package <name>] [--version <x.y.z>]

Writes a typed client of every version the workspace has published, from its OpenAPI description, as a package ready to build: Python, Rust, TypeScript, Go, C#, Java, a PowerShell module, a Ruby gem, a PHP Composer package, Kotlin or a Swift package. Each version is a method (in PowerShell a cmdlet) with typed inputs that asks for a run, waits for it to end, and gives its typed output or the failure the server said. A file already there is not overwritten.

Examples:

reqlyn remote sdk --language python --out client

reqlyn remote portal export

reqlyn remote portal export --out <folder>

Writes the workspace's public portal, the versions an administrator made public, as plain HTML and CSS in its look: index.html, a page for each and a search. Only what anyone reads without signing in. A file already there is not overwritten.

Examples:

reqlyn remote portal export --out portal

reqlyn remote portal set

reqlyn remote portal set [--domain <domain> | --no-domain] [--title <text>]
    [--look signal|blueprint] [--accent <#rrggbb> | --no-accent]
reqlyn remote portal show

The public portal's domain, title, look and accent; set, by an administrator. On its domain the server answers with the portal alone: its index, pages and search, in its look. What set is not given stays as it was.

Examples:

reqlyn remote portal set --domain docs.example.net --look blueprint --accent "#0b7a75"

reqlyn remote portal counts

reqlyn remote portal counts [--days <n>]

How the portal was read, by day and page: views and searches, counts only (the last 30 days unless --days says). For administrators.

Examples:

reqlyn remote portal counts --days 7

reqlyn remote agent add

reqlyn remote agent add <name>

Adds a private agent to the workspace and prints its token, once. An agent runs inside a network the server cannot reach, connecting out to it, and takes the runs of the environments the deployment manifest assigns it (agents:). For the workspace's administrators.

Examples:

reqlyn remote agent add site-a

reqlyn remote agent revoke

reqlyn remote agent revoke <name>

Revokes an agent: its token is refused from now on, and its runs under way fail with AGENT_REVOKED, never sent again. Runs waiting in its environments wait for another agent.

reqlyn remote agents

reqlyn remote agents

The workspace's agents, the environments each takes, and when each was last heard from.

reqlyn remote release

reqlyn remote release

Whether a newer Reqlyn is out, as the server's signed release feed says. Nothing is installed by itself. An administrator's.

reqlyn remote license

reqlyn remote license

What the server's license grants and how many seats are used. An administrator's. Nothing stops for a license.

reqlyn remote changes

reqlyn remote changes <operation> <from> <to>

What changed from one published version to another: inputs, output, steps, requests, limits, records, owner, name. Then whether a caller of the earlier version is still accepted and still finds what it reads, and where each output field comes from in each version: the step, the place in its response and the endpoint it calls. Ends with 1 when a check is broken.

Examples:

reqlyn remote changes device-overview 2 3

reqlyn docs

reqlyn docs <folder> [--public]

Writes the documentation as a website to the folder: a page a file, a search, and manual.html, every page as one to print. It needs no network: open index.html in a browser. With --public, only what people using Reqlyn read: nothing of installing or running a server. The same pages are in the desktop's Help and at a server's /help.

Examples:

reqlyn docs reqlyn-docs
reqlyn docs reqlyn-docs-public --public

reqlyn help

reqlyn help <command> | exit | environment

One command's help, with examples: reqlyn help run, reqlyn help remote run. exit says what each exit status means, environment where the commands find their data and their server. --reference prints every command as Markdown, the documentation's command reference.

reqlyn

reqlyn --help | --version
reqlyn --json <command> [<argument>...]

--json first carries out the command and prints one JSON object for it, for a program or a coding agent to read: ok and exit, its exit status; result, what it printed when that is JSON (list, run and test print JSON then), else output, what it printed; said, what it said on standard error. It exits as the command does.

Exit status and environment

Exit status: 0 the run returned its whole output; 1 it failed, or was cancelled or interrupted; 2 it was not run (no such operation, an input that is not JSON, or a server that refused or could not be reached); 3 it returned part of its output, having gone on without a step that failed. status and cancel end with 0 when the server answered.

The data folder is the desktop application's, or REQLYN_DATA_DIR. The remote commands use no data folder: the server is REQLYN_SERVER, such as https://reqlyn.example, and the service token is REQLYN_TOKEN. The token is never given as an argument. Where no secret store can be reached, as in the CI image, a secret variable's value is read from REQLYN_SECRET_<NAME>, its name in capitals.

Help for Reqlyn 0.5.1. All help topics