Enum Command 

pub enum Command {
    Doctor {
        input: PathBuf,
        only: Option<CapabilityArg>,
        strict: bool,
        format: FormatArg,
    },
    Dev {
        path: PathBuf,
        lock: LockArgs,
        contexts: Vec<String>,
        base_port: Option<u16>,
        inspect: bool,
        inspect_port: u16,
        env: String,
        local_workers: Vec<String>,
        format: DevFormatArg,
        ready_json: Option<PathBuf>,
        wrangler_args: Vec<String>,
    },
    Deploy {

        path: PathBuf,
        lock: LockArgs,
        context: Option<String>,
        env: String,
        dry_run: bool,
        format: DeployFormatArg,
        yes: bool,
        secrets_file: Option<PathBuf>,
        secrets: Vec<String>,
        force: bool,
        prune: bool,
        confirm_delete: Vec<String>,
        wrangler_args: Vec<String>,
    
},
    New {
        path: PathBuf,
        name: Option<String>,
    },
    Check {
        input: PathBuf,
        format: CheckFormatArg,
        lock: LockArgs,
    },
    Fmt {
        args: FmtArgs,
    },
    Test {
        args: TestArgs,
        lock: LockArgs,
        allow_skew: bool,
    },
    Fetch {
        path: PathBuf,
        lock: LockArgs,
    },
    Update {
        names: Vec<String>,
        path: PathBuf,
    },
    Migrate {
        command: MigrateCommand,
    },
    Add {
        package: String,
        alias: Option<String>,
        path: PathBuf,
    },
    Publish {
        path: PathBuf,
        dry_run: bool,
    },
    Yank {
        package: String,
        version: String,
        undo: bool,
        path: PathBuf,
    },
    Login {
        target: AccountTarget,
    },
    Logout {
        target: AccountTarget,
    },
    Org {
        command: OrgCommand,
    },
    Approve {
        package: Option<String>,
        all: bool,
        list: bool,
        path: PathBuf,
    },
    Registry {
        command: RegistryCommand,
    },
    Explain {
        code: String,
    },
}

Variants

Doctor

Check whether your machine is ready to compile, test, and deploy Bynk — and print the exact remedy for anything missing.

Bare bynk doctor is informational: it surveys every capability and exits 0 unless bynkc itself is unusable. --only <capability> gates on one capability (exits non-zero if its tools are missing); --strict turns every warning into a failure, for CI.

Fields

input: PathBuf

Project directory to inspect (for project-local node_modules/.bin resolution). Defaults to the current directory.

only: Option<CapabilityArg>

Scope the check — and the exit code — to one capability.

strict: bool

Treat every warning (optional gaps, npx provisionability, minor version skew) as a failure. For an all-green CI gate.

format: FormatArg

Output format. human (default) is a grouped table; short and json are the stable scriptable surface.

Dev

Build the project and serve it locally with wrangler dev, rebuilding on save — one step in place of the manual compile + cd + wrangler dev recipe.

Compiles into a managed .bynk/dev/ build dir and runs one wrangler dev per context from inside its worker dir, in local mode (Miniflare) — no namespace provisioning needed. Every context is served by default and the service bindings between them are wired (#552), so a cross-context call resolves locally; --context narrows to a subset. While serving, .bynk sources are watched (#524): saving a file rebuilds in place and the running workers hot-reload; a failing rebuild reports errors and keeps serving the last good build. Everything after -- is forwarded to wrangler dev verbatim.

Fields

path: PathBuf

Project directory to serve from (anywhere inside the project; the root is found by walking up for bynk.toml). Defaults to ..

lock: LockArgs

contexts: Vec<String>

Which context to serve, repeatable. Omit to serve every context in the project with the service bindings between them wired (#552); pass one or more to narrow to a subset. Accepts the dotted name or its dasherised worker-dir form.

base_port: Option<u16>

First port of the per-context allocation (context i gets --base-port + i, in sorted order). Defaults to wrangler’s 8787. A single context left on the default keeps -- --port N working.

inspect: bool

Serve with the V8 inspector enabled (slice 3, ADR 0104): wrangler dev starts with --inspector-port so a JavaScript debugger can attach. Breakpoints set in .bynk sources resolve through the emitted source maps, composed into the worker bundle. Prints the inspector URL on start.

inspect_port: u16

First inspector port, allocated per context exactly as --base-port is (default 9229). Used under --inspect, and also whenever several contexts are served, so their always-on inspectors do not collide.

env: String

Which bynk.deploy.lock environment -- --remote reads the KV id from. dev never provisions, so this only selects among what bynk deploy --env NAME already recorded — irrelevant without --remote. Omit for today’s single, unqualified default.

local_workers: Vec<String>

A Worker outside the project, named by a Service instance (@worker("NAME")), to reach in your own locally running wrangler dev of it rather than in the stand-in dev binds by default. Repeatable.

format: DevFormatArg

Output format. human (default) is the readable stream on stderr. json adds one JSON event per line on stdout (serving with each context’s ports, rebuilding, rebuild_ok, rebuild_failed, stopped), the stable scriptable surface for editors and CI.

ready_json: Option<PathBuf>

Once every served context answers an HTTP probe, write { "<worker>": "<url>" } to FILE: the readiness signal for a test runner or CI script. A stale FILE is removed at start, and FILE is removed when the session stops.

wrangler_args: Vec<String>

Arguments after --, forwarded to wrangler dev (e.g. -- --remote). Ports are the driver’s to allocate: use --base-port / --inspect-port.

Deploy

Provision each context’s Cloudflare resources and deploy its Worker. The whole project ships in one command, in Service-Binding dependency order — Cloudflare rejects a Worker uploaded before a Worker it binds to. The generated configuration remains disposable: Cloudflare ids live in the committed bynk.deploy.lock.

Fields

path: PathBuf

Project directory to deploy from. Defaults to the current directory.

lock: LockArgs

context: Option<String>

Deploy this context alone, assuming the contexts it consumes are already live; a dependency that has never been deployed is reported rather than pushed into. Accepts the dotted name or its dasherised worker-dir form. Omit to deploy the whole project in order.

env: String

Target environment. Selects the bynk.deploy.lock section and, for any value other than default, synthesises an environment- scoped Wrangler config section (KV, queues, Service Bindings all qualified) since Cloudflare does not inherit bindings into a named environment. Omit to deploy today’s single, unqualified default.

dry_run: bool

Print the provisioning and deploy plan without changing Cloudflare or writing bynk.deploy.lock.

format: DeployFormatArg

Plan output format. short is line-oriented; json is for CI.

yes: bool

Skip the confirmation required before creating a namespace or publishing a Worker. Required for non-interactive automation.

secrets_file: Option<PathBuf>

Read secret values from a dotenv-style NAME=value file. Supplies both names and values; never committed, never persisted. Values move to wrangler secret put and are dropped.

secrets: Vec<String>

Set this named secret, taking its value from the environment (or a prompt). Repeatable. Use for a bynk.Secrets name, whose spelling the compiler cannot know — an actor’s declared auth secret needs no flag. The environment is never scanned for names.

force: bool

Overwrite a secret that is already set. The default sets only the missing ones, so a re-deploy does not cut a fresh Cloudflare secret version for every secret every time.

prune: bool

Delete every reported orphan — a KV namespace or queue the ledger remembers that the current build no longer declares. Never deletes a Worker. Prompts separately from the creation confirmation unless –yes is also given; omit to report only.

confirm_delete: Vec<String>

Confirm deleting this agent class’s stored data, named as the plan prints it (<context>.<Class>). Repeatable. A removed agent declaration deletes data irreversibly, so --yes never stands in for this.

wrangler_args: Vec<String>

Arguments after --, forwarded to wrangler deploy verbatim.

New

Scaffold a new project: a complete, runnable single-context HTTP service you can serve immediately with bynk dev.

Writes a bynk.toml, a .gitignore, and src/<name>.bynk into a new directory. Pure offline file-writing — it shells nothing and needs no toolchain, so you can run it before bynkc, Node, or wrangler are installed. The project name defaults to the target directory’s final component; --name overrides it and must be a legal Bynk identifier.

Fields

path: PathBuf

Directory to create for the new project (e.g. hello or ./hello).

name: Option<String>

Project name / context identifier. Defaults to PATH’s final component; must be a legal Bynk identifier (a letter followed by letters, digits, or underscores).

Check

Type-check a .bynk file or project without writing output — the bynkc check behaviour through the driver’s compiler resolution (v0.138).

Runs the compiler pipeline in-process (no bynkc binary required); with BYNK_BYNKC set, the pinned compiler is shelled instead so an externally-managed bynkc still governs the result.

Fields

input: PathBuf

Input .bynk file or project root. Defaults to the current directory.

format: CheckFormatArg

Diagnostic output format. rich (default) is the ariadne source-context rendering; short emits one terse path:line:col: severity[category]: message line per diagnostic, for tooling (the VS Code problem-matcher, CI, scripts). In both, path is the file as you’d type it from the working directory (the input you passed, joined with the file’s place in it), the same path fmt reports.

lock: LockArgs

Fmt

Format .bynk source files in place — the bynkc fmt behaviour through the driver (v0.138). Passing - reads from stdin and writes to stdout.

Runs the formatter in-process (no bynkc binary required); with BYNK_BYNKC set, the pinned compiler is shelled instead — the style flags are forwarded to it either way.

--indent, --indent-width, --max-line-width and --no-trailing-comma override the canonical style for this run; with none of them the output is the canonical formatting.

Fields

args: FmtArgs

Test

Discover and run test declarations in a project — the bynkc test behaviour through the driver (v0.138).

Delegates to the bynkc the driver resolves (BYNK_BYNKC → PATH → sibling-of-bynk), so an editor or developer inherits the driver’s richer compiler resolution instead of locating bynkc themselves. Requires tsc (with Node.js) or tsx on PATH, exactly as bynkc test.

Fields

args: TestArgs

lock: LockArgs

allow_skew: bool

Run even when the resolved bynkc is a different major version from bynk (#1675). A minor skew only warns. Also settable as BYNK_ALLOW_SKEW=1.

Fetch

Resolve the project’s dependencies, fetch the git ones missing from the store, and write bynk.lock (#2240). check, test, dev and deploy do this first anyway; fetch does only this — warm the store before an --offline CI step, or after editing [dependencies].

Fields

path: PathBuf

Project (or workspace) directory. Defaults to ..

lock: LockArgs

Update

Re-resolve git dependencies’ revisions — a branch that moved upstream — and rewrite bynk.lock (#2240). Name aliases or packages to update only those; with none, every git dependency is re-resolved.

Fields

names: Vec<String>

The aliases or org/package names to update. All when omitted.

path: PathBuf

Project (or workspace) directory.

Migrate

Where each agent class’s stored state stands, and the sweep that migrates every stored instance so old migrate steps can retire.

Fields

command: MigrateCommand

Add

Add a registry dependency to bynk.toml (#2274): the highest version its registry offers (or one matching @<range>), written as <alias> = { package = "…", version = "^…" }, then resolved and locked.

Fields

package: String

org/package, optionally @<range> (acme/money@^1.4).

alias: Option<String>

The alias to reach it by; defaults to the package segment.

path: PathBuf

Project directory.

Publish

Publish this package to the registry its organisation routes to (#2287): check it, pack it, upload it through the registry’s publish API, and verify the signed line the registry returns.

Fields

path: PathBuf

The package directory.

dry_run: bool

Check and pack, and report what would be published, without uploading.

Yank

Yank a published version through its registry’s publish API (#2287): kept for locked builds, never newly chosen.

Fields

package: String

org/package.

version: String

The version.

undo: bool

Clear the yank instead.

path: PathBuf

The project whose [registries] route the organisation.

Login

Sign in to a registry’s accounts (#2378) through GitHub’s device flow, and keep the account token in the credentials file.

Fields

target: AccountTarget

Logout

Sign out of a registry’s accounts (#2378), here and on the server.

Fields

target: AccountTarget

Org

Manage an organisation on a registry with accounts (#2378): claim and block it, add and remove members, mint and revoke publish tokens.

Fields

command: OrgCommand

Approve

Review and approve the npm packages that git and registry dependencies’ adapters bring into the build (#2296), recording each approval in bynk.lock. With no package, asks about each pending one.

Fields

package: Option<String>

Approve this npm package’s pending requirements.

all: bool

Approve every pending requirement without asking.

list: bool

List pending and approved requirements; change nothing.

path: PathBuf

Project (or workspace) directory.

Registry

Build and maintain a static package registry in a directory (#2274) — served by any static host, or read as a file:// index.

Fields

command: RegistryCommand

Explain

Explain a diagnostic code — the longer-form “what the rule is, why it exists, and how to fix it” behind a bynk.* error code (#853).

Prints a curated blurb, a minimal before/after example, and a link to the relevant Book concept page. The blurb is offline-complete, so the substance is available without network. Codes without a curated explanation report that gracefully; an unrecognised code exits non-zero. The same explanations back the editor’s clickable diagnostic-code links.

Fields

code: String

The diagnostic code to explain, e.g. bynk.resolve.unknown_type.

Trait Implementations

impl Debug for Command

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Command

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Command

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand