Enum Command 

pub enum Command {
    Doctor {
        input: PathBuf,
        only: Option<CapabilityArg>,
        strict: bool,
        format: FormatArg,
    },
    Dev {
        path: PathBuf,
        context: Option<String>,
        inspect: bool,
        inspect_port: u16,
        wrangler_args: Vec<String>,
    },
    New {
        path: PathBuf,
        name: Option<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 — one step in place of the manual compile + cd + wrangler dev recipe.

Compiles into a managed .bynk/dev/ build dir, picks the worker to serve (one context → served; --context to choose; ambiguous → lists them), and runs wrangler dev from inside it in local mode (Miniflare) — no namespace provisioning needed. 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 ..

context: Option<String>

Which context’s worker to serve, for multi-context projects.

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

Inspector port for --inspect (default 9229).

wrangler_args: Vec<String>

Arguments after --, forwarded to wrangler dev (e.g. -- --port 8788).

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).

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