driggsby 0.1.41 → 0.2.0

package/README.md

@@ -29,6 +29,65 @@ OAuth-based remote MCP at:
 https://app.driggsby.com/mcp
 ```
 
+Some driggsby commands work with your Driggsby account directly and need
+an app token saved on your machine: run
+`npx driggsby@latest login` and approve the page it opens. The token is
+stored in your platform keychain when one is available, otherwise in
+`~/.driggsby/credentials.json`, and is never printed.
+`npx driggsby@latest logout` removes it.
+
+## Building an app
+
+Driggsby hosts small static apps — dashboards, visualizations — each at
+its own `driggsby.dev` address. Start one with:
+
+```bash
+npx driggsby@latest init your-app-name
+```
+
+This creates a working app — `index.html`, `app.js`, `styles.css`, and the
+`driggsby.json` that names it. The app reads live data with one call,
+`driggsby.watch(tool, params, callback)`, and shows sample data when opened
+on its own.
+
+Preview it with your real Driggsby data:
+
+```bash
+npx driggsby@latest dev
+```
+
+This runs the app locally, embedded exactly the way Driggsby embeds it
+after a deploy, and reloads the page when you save a file. While dev runs,
+the preview serves your financial data to this machine — other websites
+can't reach it, but anything running locally can, so stop it when you're
+done.
+
+## Deploying an app
+
+From a folder holding a `driggsby.json`
+(`{ "slug": "your-app-name", "serve": "." }`) and an `index.html`:
+
+```bash
+npx driggsby@latest deploy
+```
+
+The first deploy creates the app: Driggsby assigns its address — the name
+you picked plus a unique ending, like
+`your-app-name-x7k2qf.driggsby.dev` — and saves the assigned name back
+into `driggsby.json`, so any readable name works and names never collide.
+If the project lives in git, commit the updated `driggsby.json` — it is the
+only record of your app's address, and a fresh checkout without it would
+create a second app.
+Every deploy after that uploads only the files that changed. Deploy with
+`--preview` to upload a version without
+changing what visitors see, `npx driggsby@latest versions` to list every
+kept version, and `npx driggsby@latest rollback` to switch which one is
+live — switching re-uploads nothing.
+
+The CLI is pure TypeScript and installs from the npm registry alone — no
+binary downloads, no install scripts — and runs on macOS, Linux, and Windows
+with Node.js 18 or newer.
+
 See the [GitHub repo](https://github.com/driggsby/driggsby) for
 tools, examples, and full documentation.
 

package/bin/driggsby.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/main.js";

package/dist/api/base-url.js

@@ -0,0 +1,31 @@
+// Where the CLI's own API calls go. DRIGGSBY_BASE_URL is a maintainer/test
+// override (pointing e2e runs at a local server); it is deliberately absent
+// from public documentation. The policy itself — which URLs are acceptable,
+// and which may receive credentials — lives once, in @driggsby/deploy's
+// base-url module; this file only maps its failures to this CLI's error
+// type.
+import { DeployError, isLoopbackBaseUrl, PUBLIC_BASE_URL, resolveBaseUrl } from "@driggsby/deploy";
+import { CliError } from "../cli-error.js";
+export function apiBaseUrl(env = process.env) {
+    try {
+        return resolveBaseUrl(env);
+    }
+    catch (error) {
+        if (error instanceof DeployError) {
+            throw new CliError(error.message, 1);
+        }
+        throw error;
+    }
+}
+export function apiHost(baseUrl) {
+    return new URL(baseUrl).host;
+}
+// Whether the machine's SAVED sign-in (keychain/keyring/credentials file)
+// may be sent to this base URL: Driggsby itself, or a dev server on this
+// machine. Any other DRIGGSBY_BASE_URL must bring its own token via
+// DRIGGSBY_TOKEN — otherwise setting a single environment variable (a
+// .envrc in a cloned repo is enough) would redirect the saved credential,
+// which unlocks the person's financial data, to an arbitrary host.
+export function baseUrlMayReceiveSavedSignIn(baseUrl) {
+    return baseUrl === PUBLIC_BASE_URL || isLoopbackBaseUrl(baseUrl);
+}

package/dist/api/network-error.js

@@ -0,0 +1,55 @@
+// Turns a failed fetch to the Driggsby API into one exact-fix message for
+// restricted-network environments (agent sandboxes with egress allowlists
+// are the common case). Written for a zero-context agent: it names the one
+// domain to allow and the one command to rerun. Anything that is not a
+// connection-level failure returns null so the caller's own handling runs.
+import { CliError } from "../cli-error.js";
+import { wrapProse } from "../terminal-text.js";
+const CONNECTION_FAILURE_CODES = new Set([
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ETIMEDOUT",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EPIPE",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_SOCKET",
+]);
+export function blockedNetworkError(error, context) {
+    if (!hasConnectionFailure(error, 0)) {
+        return null;
+    }
+    // The host is dynamic, so both sentences go through wrapProse: an agent
+    // reading this to build an egress allowlist must never see the hostname
+    // split across a soft-wrapped line.
+    return new CliError(`${wrapProse(`We couldn't reach ${context.host} from this machine.`)}\n\n` +
+        `${wrapProse(`If this environment restricts network access, allow HTTPS access to ${context.host} and try again:`)}\n` +
+        `  ${context.retryCommand}`, 1);
+}
+// Walks the error's cause chain (and AggregateError members — undici reports
+// multi-address connection failures that way) looking for a known
+// connection-level errno code.
+function hasConnectionFailure(error, depth) {
+    if (depth > 6 || typeof error !== "object" || error === null) {
+        return false;
+    }
+    const code = error.code;
+    if (typeof code === "string" && CONNECTION_FAILURE_CODES.has(code)) {
+        return true;
+    }
+    // An AbortSignal.timeout fires as a DOMException named TimeoutError: the
+    // stalled-but-connected shape (an egress proxy that accepts and never
+    // replies) that the errno codes above don't cover.
+    if (error.name === "TimeoutError") {
+        return true;
+    }
+    if (error instanceof AggregateError && error.errors.some((inner) => hasConnectionFailure(inner, depth + 1))) {
+        return true;
+    }
+    const cause = error.cause;
+    return hasConnectionFailure(cause, depth + 1);
+}

package/dist/args-deploy.js

@@ -0,0 +1,94 @@
+// Argv parsing for the deploy command family: deploy, rollback, versions.
+// Same behavior contract as the rest of the tree — help on -h/--help, usage
+// errors exit 2, echoed argv is sanitized — without chasing clap byte quirks.
+import { unexpectedArgument, unexpectedFlagValue, } from "./args-shared.js";
+import { CliError } from "./cli-error.js";
+import { DEPLOY_HELP, ROLLBACK_HELP, VERSIONS_HELP } from "./help.js";
+import { sanitizeForTerminal } from "./terminal-text.js";
+const DEPLOY_USAGE = "Usage: npx driggsby@latest deploy [--preview]";
+const ROLLBACK_USAGE = "Usage: npx driggsby@latest rollback [--to <VERSION>]";
+const VERSIONS_USAGE = "Usage: npx driggsby@latest versions";
+export function parseDeploy(argv) {
+    let preview = false;
+    let optionsEnded = false;
+    for (const token of argv) {
+        if (!optionsEnded && token === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (!optionsEnded && (token === "-h" || token === "--help")) {
+            return helpCommand(DEPLOY_HELP);
+        }
+        if (!optionsEnded && token === "--preview") {
+            preview = true;
+            continue;
+        }
+        if (!optionsEnded && token.startsWith("--preview=")) {
+            throw unexpectedFlagValue("--preview", token.slice("--preview=".length), DEPLOY_USAGE);
+        }
+        throw unexpectedArgument(token, DEPLOY_USAGE);
+    }
+    return { kind: "deploy", preview };
+}
+export function parseRollback(argv) {
+    let toVersion = null;
+    let optionsEnded = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index] ?? "";
+        if (!optionsEnded && token === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (!optionsEnded && (token === "-h" || token === "--help")) {
+            return helpCommand(ROLLBACK_HELP);
+        }
+        if (!optionsEnded && token === "--to") {
+            const value = argv[index + 1];
+            if (value === undefined) {
+                throw missingToValue();
+            }
+            toVersion = parseVersionNumber(value);
+            index += 1;
+            continue;
+        }
+        if (!optionsEnded && token.startsWith("--to=")) {
+            toVersion = parseVersionNumber(token.slice("--to=".length));
+            continue;
+        }
+        throw unexpectedArgument(token, ROLLBACK_USAGE);
+    }
+    return { kind: "rollback", toVersion };
+}
+export function parseVersions(argv) {
+    let optionsEnded = false;
+    for (const token of argv) {
+        if (!optionsEnded && token === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (!optionsEnded && (token === "-h" || token === "--help")) {
+            return helpCommand(VERSIONS_HELP);
+        }
+        throw unexpectedArgument(token, VERSIONS_USAGE);
+    }
+    return { kind: "versions" };
+}
+function helpCommand(text) {
+    return { kind: "print-help", text, stream: "stdout", exitCode: 0 };
+}
+// Version numbers are the small positive integers shown by `versions` (v1,
+// v2, ...). Anything else is a usage mistake, reported like other bad argv —
+// including a digit string too large for an exact integer, which would
+// otherwise serialize in scientific notation and reach the server as
+// something like 1e+23.
+function parseVersionNumber(rawValue) {
+    const parsed = Number.parseInt(rawValue, 10);
+    if (!/^[0-9]+$/.test(rawValue) || !Number.isSafeInteger(parsed) || parsed < 1) {
+        throw new CliError(`error: invalid value '${sanitizeForTerminal(rawValue)}' for '--to': expected a version number like 3\n\n` +
+            `${ROLLBACK_USAGE}\n\nFor more information, try '--help'.`, 2);
+    }
+    return parsed;
+}
+function missingToValue() {
+    return new CliError(`error: a value is required for '--to' but none was supplied\n\n${ROLLBACK_USAGE}\n\nFor more information, try '--help'.`, 2);
+}

package/dist/args-init.js

@@ -0,0 +1,29 @@
+// Argv parsing for driggsby init: one optional positional (the app's name),
+// help, and the shared usage-error shape — usage errors exit 2, echoed argv
+// is sanitized by the shared builders.
+import { unexpectedArgument } from "./args-shared.js";
+import { INIT_HELP } from "./help.js";
+const INIT_USAGE = "Usage: npx driggsby@latest init [NAME]";
+export function parseInit(argv) {
+    let slug = null;
+    let optionsEnded = false;
+    for (const token of argv) {
+        if (!optionsEnded && token === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (!optionsEnded && (token === "-h" || token === "--help")) {
+            return { kind: "print-help", text: INIT_HELP, stream: "stdout", exitCode: 0 };
+        }
+        // Any other flag-looking token is a mistake, not a name; after "--"
+        // everything is positional and slug validation refuses bad names.
+        if (!optionsEnded && token.startsWith("-") && token !== "-") {
+            throw unexpectedArgument(token, INIT_USAGE);
+        }
+        if (slug !== null) {
+            throw unexpectedArgument(token, INIT_USAGE);
+        }
+        slug = token;
+    }
+    return { kind: "init", slug };
+}

package/dist/args-mcp-setup.js

@@ -0,0 +1,258 @@
+// The mcp setup argv parser, byte-matching the original clap 4.6 behavior it
+// was ported from: pending-argument resolution order, matcher-derived usage
+// lines, duplicate detection, and the "--" escape quirks. New commands do NOT
+// copy this style — clap byte-parity is a frozen contract for the mcp setup
+// surface only.
+import { passAsValueTip, similarArgumentTip, unexpectedArgument, unexpectedFlagValue, } from "./args-shared.js";
+import { didYouMean } from "./clap-suggestions.js";
+import { CliError } from "./cli-error.js";
+import { MCP_SETUP_HELP_LONG, MCP_SETUP_HELP_SHORT } from "./help.js";
+import {} from "./mcp-setup/known-client.js";
+import { sanitizeForTerminal } from "./terminal-text.js";
+const SETUP_USAGE = "Usage: npx driggsby@latest mcp setup [OPTIONS] [CLIENT]";
+const SETUP_LONG_FLAGS = ["print", "help"];
+export function parseMcpSetup(argv) {
+    let client;
+    let print = false;
+    let scope;
+    let optionsEnded = false;
+    // The matcher state clap re-renders error usage lines from: flags that have
+    // RESOLVED into the matcher, in argv order. Unknown-long-flag errors render
+    // these (plus <CLIENT> once the positional resolved); "--print=x"/"--help=x"
+    // render the derive group form once anything resolved. Shorts, positionals,
+    // and duplicate errors keep the static usage. A second slot-form -s removes
+    // the earlier "-s <MCP_SCOPE>" entry while its own value is still pending
+    // (clap's Set action self-override), and a duplicate never re-adds it.
+    const seenFlags = [];
+    let committedArgs = 0;
+    let clientInMatcher = false;
+    let pending = null;
+    // Resolution, byte-verified against the Rust binary: recognized argument
+    // starts (--print, -s, --help/-h, an accepted positional, end of argv)
+    // PROPAGATE the pending arg's errors — duplication first, then emptiness,
+    // then value validity — while error paths (unknown long flag) resolve in
+    // DISCARD mode: the token's own error wins, but a non-duplicate entry still
+    // lands in the matcher and shows up in the rebuilt usage line.
+    const resolvePending = (propagateErrors) => {
+        if (pending === null) {
+            return;
+        }
+        const resolved = pending;
+        pending = null;
+        if (resolved.kind === "client") {
+            clientInMatcher = true;
+            committedArgs += 1;
+            return;
+        }
+        if (resolved.kind === "scope-missing-value") {
+            if (propagateErrors) {
+                throw scopeValueRequired();
+            }
+            return;
+        }
+        if (resolved.isDuplicate) {
+            if (propagateErrors) {
+                throw usedMultipleTimes("-s <MCP_SCOPE>");
+            }
+            return;
+        }
+        seenFlags.push("-s <MCP_SCOPE>");
+        committedArgs += 1;
+        if (resolved.value === "") {
+            if (propagateErrors) {
+                throw scopeValueRequired();
+            }
+            return;
+        }
+        if (resolved.value !== "local" && resolved.value !== "user") {
+            if (propagateErrors) {
+                throw invalidScopeValue(resolved.value);
+            }
+            return;
+        }
+        scope = resolved.value;
+    };
+    const acceptPositional = (token) => {
+        // clap flags the extra positional eagerly, before resolving the pending
+        // arg (codex -s bogus -- y reports 'y', not the invalid scope).
+        if (client !== undefined) {
+            throw unexpectedArgument(token, SETUP_USAGE);
+        }
+        resolvePending(true);
+        client = token;
+        pending = { kind: "client" };
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === undefined) {
+            break;
+        }
+        if (optionsEnded) {
+            acceptPositional(token);
+            continue;
+        }
+        if (token === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (token === "--help") {
+            resolvePending(true);
+            return { kind: "print-help", text: MCP_SETUP_HELP_LONG, stream: "stdout", exitCode: 0 };
+        }
+        if (token === "--print") {
+            resolvePending(true);
+            if (print) {
+                throw usedMultipleTimes("--print");
+            }
+            print = true;
+            seenFlags.push("--print");
+            committedArgs += 1;
+            continue;
+        }
+        if (token.startsWith("--help=") || token.startsWith("--print=")) {
+            // clap computes this error's usage BEFORE resolving the pending arg,
+            // so a pending -s or positional never influences the group form.
+            const equalsAt = token.indexOf("=");
+            const flag = token.slice(0, equalsAt);
+            throw unexpectedFlagValue(flag, token.slice(equalsAt + 1), setupEqualsErrorUsage(flag, committedArgs > 0));
+        }
+        if (token.startsWith("-s")) {
+            resolvePending(true);
+            if (token === "-s") {
+                // A MISSING value (nothing next, or a RECOGNIZED flag token next —
+                // "--", exact --help/--print, or a short cluster starting with 'h' or
+                // 's') reports "a value is required"; an UNRECOGNIZED dash-leading
+                // token abandons this -s and is reported through its own error path.
+                const next = argv[index + 1];
+                if (next === undefined) {
+                    throw scopeValueRequired();
+                }
+                if (next === "--") {
+                    // clap's escape does not feed -s: it flips trailing-values mode
+                    // and leaves the -s pending with no value. That error surfaces at
+                    // the next token — propagated while the [CLIENT] slot is free,
+                    // discarded in favor of the extra-positional error once taken.
+                    pending = { kind: "scope-missing-value" };
+                    continue;
+                }
+                if (next !== "-" && next.startsWith("-")) {
+                    if (isRecognizedSetupFlagToken(next)) {
+                        throw scopeValueRequired();
+                    }
+                    continue;
+                }
+                // Slot-form value (bare "-" included): validation is DEFERRED to
+                // resolution. A repeat occurrence also evicts the earlier matcher
+                // entry now, while its own value is still pending.
+                if (scope !== undefined) {
+                    const at = seenFlags.indexOf("-s <MCP_SCOPE>");
+                    if (at !== -1) {
+                        seenFlags.splice(at, 1);
+                    }
+                }
+                pending = { kind: "scope", value: next, isDuplicate: scope !== undefined };
+                index += 1;
+                continue;
+            }
+            // Attached form (-s=x / -sx): duplication, emptiness, and validity all
+            // report eagerly, in that order.
+            const value = token.startsWith("-s=") ? token.slice(3) : token.slice(2);
+            if (scope !== undefined) {
+                throw usedMultipleTimes("-s <MCP_SCOPE>");
+            }
+            if (value === "") {
+                throw scopeValueRequired();
+            }
+            if (value !== "local" && value !== "user") {
+                throw invalidScopeValue(value);
+            }
+            scope = value;
+            seenFlags.push("-s <MCP_SCOPE>");
+            committedArgs += 1;
+            continue;
+        }
+        if (token.startsWith("--")) {
+            resolvePending(false);
+            throw unknownSetupLongFlag(token, seenFlags, clientInMatcher);
+        }
+        if (token.startsWith("-") && token.length > 1) {
+            // Short cluster: -h... prints the short help (after resolving the
+            // pending arg, so -s bogus -h reports the invalid scope); anything else
+            // errors naming the first short (one code point, like Rust's char) with
+            // the pass-as-value tip (-py → '-p'), discarding any pending error.
+            const firstShort = Array.from(token.slice(1))[0] ?? "";
+            if (firstShort === "h") {
+                resolvePending(true);
+                return { kind: "print-help", text: MCP_SETUP_HELP_SHORT, stream: "stdout", exitCode: 0 };
+            }
+            throw unexpectedArgument(`-${firstShort}`, SETUP_USAGE, passAsValueTip(`-${firstShort}`));
+        }
+        acceptPositional(token);
+    }
+    resolvePending(true);
+    return { kind: "mcp-setup", client, print, scope };
+}
+function invalidScopeValue(value) {
+    const shown = sanitizeForTerminal(value);
+    const similar = didYouMean(value, ["local", "user"]);
+    const tip = similar === undefined ? "" : `\n\n  tip: a similar value exists: '${similar}'`;
+    return new CliError(`error: invalid value '${shown}' for '-s <MCP_SCOPE>'\n  [possible values: local, user]${tip}\n\nFor more information, try '--help'.`, 2);
+}
+// A dash-leading token clap would recognize as one of mcp setup's own flags:
+// an exact long flag, or a short cluster led by a known short ('h' or 's').
+// Long forms with an attached =value are NOT recognized here — clap reports
+// those through their own unexpected-value error instead — and "--" is
+// handled separately (it parks the -s as pending-with-no-value).
+function isRecognizedSetupFlagToken(token) {
+    if (token === "--help" || token === "--print") {
+        return true;
+    }
+    if (token.startsWith("--")) {
+        return false;
+    }
+    const firstShort = Array.from(token.slice(1))[0] ?? "";
+    return firstShort === "h" || firstShort === "s";
+}
+function unknownSetupLongFlag(token, seenFlags, clientSeen) {
+    const flagName = token.slice(2).split("=", 1)[0] ?? "";
+    const shown = sanitizeForTerminal(`--${flagName}`);
+    const similar = didYouMean(flagName, SETUP_LONG_FLAGS);
+    if (similar !== undefined) {
+        // clap appends the suggested flag to the seen list unless already there
+        // (--print --pront renders "--print [CLIENT]", not "--print --print ...").
+        const rendered = seenFlags.includes(`--${similar}`) ? seenFlags : [...seenFlags, `--${similar}`];
+        return unexpectedArgument(shown, setupUsageFromSeen(rendered, clientSeen), similarArgumentTip(similar));
+    }
+    return unexpectedArgument(shown, setupUsageFromSeen(seenFlags, clientSeen), passAsValueTip(shown));
+}
+// clap re-renders the usage line on unknown-long-flag errors from what it has
+// already parsed: the completed flags in argv order, then <CLIENT> once the
+// positional was consumed ([CLIENT] otherwise). With nothing consumed and no
+// suggestion it falls back to the generic "[OPTIONS] [CLIENT]" form.
+function setupUsageFromSeen(flags, clientSeen) {
+    if (flags.length === 0 && !clientSeen) {
+        return SETUP_USAGE;
+    }
+    const parts = ["Usage: npx driggsby@latest mcp setup", ...flags, clientSeen ? "<CLIENT>" : "[CLIENT]"];
+    return parts.join(" ");
+}
+// The usage clap renders for "--print=x"/"--help=x" at the setup level: with
+// nothing committed, the errored flag plus "[CLIENT]"; once any setup arg is
+// committed, the derive-generated group "<CLIENT|--print|-s <MCP_SCOPE>>",
+// prefixed by "--help" only (--print is a group member and collapses into it).
+function setupEqualsErrorUsage(flag, anyArgCommitted) {
+    if (!anyArgCommitted) {
+        return `Usage: npx driggsby@latest mcp setup ${flag} [CLIENT]`;
+    }
+    const group = "<CLIENT|--print|-s <MCP_SCOPE>>";
+    const prefix = flag === "--help" ? "--help " : "";
+    return `Usage: npx driggsby@latest mcp setup ${prefix}${group}`;
+}
+function usedMultipleTimes(argumentName) {
+    // Callers pass literals only; sanitizing anyway keeps the module-wide
+    // no-control-bytes guarantee independent of each call site.
+    return new CliError(`error: the argument '${sanitizeForTerminal(argumentName)}' cannot be used multiple times\n\n${SETUP_USAGE}\n\nFor more information, try '--help'.`, 2);
+}
+function scopeValueRequired() {
+    return new CliError(`error: a value is required for '-s <MCP_SCOPE>' but none was supplied\n  [possible values: local, user]\n\nFor more information, try '--help'.`, 2);
+}

package/dist/args-shared.js

@@ -0,0 +1,28 @@
+// The parsed-command union and the CliError builders shared by the level
+// dispatcher (args.ts) and the mcp setup parser (args-mcp-setup.ts). Every
+// builder sanitizes what it interpolates, so no control bytes can reach the
+// terminal through an echoed argument, tip, or usage line.
+import { CliError } from "./cli-error.js";
+import {} from "./mcp-setup/known-client.js";
+import { sanitizeForTerminal } from "./terminal-text.js";
+// "--print=true" / "--help=x" / "--version=x": these flags take no value.
+export function unexpectedFlagValue(flag, rawValue, usage) {
+    const value = sanitizeForTerminal(rawValue);
+    return new CliError(`error: unexpected value '${value}' for '${sanitizeForTerminal(flag)}' found; no more were expected\n\n${sanitizeForTerminal(usage)}\n\nFor more information, try '--help'.`, 2);
+}
+export function unexpectedArgument(argument, usage, tipLine) {
+    const shown = sanitizeForTerminal(argument);
+    // The whole tip line is sanitized here, in one place — its dynamic parts
+    // carry user argv, and the sanitizer leaves the line's own spacing alone.
+    const tip = tipLine === undefined ? "" : `${sanitizeForTerminal(tipLine)}\n\n`;
+    return new CliError(`error: unexpected argument '${shown}' found\n\n${tip}${sanitizeForTerminal(usage)}\n\nFor more information, try '--help'.`, 2);
+}
+export function similarArgumentTip(flagName) {
+    return `  tip: a similar argument exists: '--${flagName}'`;
+}
+export function passAsValueTip(shownArgument) {
+    return `  tip: to pass '${shownArgument}' as a value, use '-- ${shownArgument}'`;
+}
+export function removeDashesTip(subcommand) {
+    return `  tip: subcommand '${subcommand}' exists; to use it, remove the '--' before it`;
+}