@kashdao/cli 0.1.0

package/dist/chunk-UZNSYATZ.js

@@ -0,0 +1,680 @@
+#!/usr/bin/env node
+
+// src/errors.ts
+import {
+  KashAbortedError,
+  KashAuthenticationError,
+  KashAuthorizationError,
+  KashConfigurationError as SdkKashConfigurationError,
+  KashConflictError,
+  KashError,
+  KashMaintenanceError,
+  KashNetworkError,
+  KashNotFoundError,
+  KashRateLimitError,
+  KashServerError,
+  KashTimeoutError,
+  KashValidationError
+} from "@kashdao/sdk";
+
+// src/error-catalog.ts
+var ERROR_CATALOG = [
+  {
+    code: "AUTH_REQUIRED",
+    summary: "No API key was provided, or the key is invalid / expired / revoked.",
+    description: "The Kash public API requires a kash_live_\u2026 or kash_test_\u2026 key on every authenticated route. First-time users should run `kash setup` (interactive wizard). Existing users can `kash auth set-key`, set KASH_API_KEY, or pass --profile to switch to a stored profile.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/authentication",
+    actions: [
+      {
+        type: "run_command",
+        command: "kash setup",
+        description: "First-run wizard \u2014 issues a key, configures profile, validates it."
+      },
+      {
+        type: "run_command",
+        command: "kash auth set-key",
+        description: "Store an API key for the active profile (paste interactively or pipe via stdin)."
+      },
+      {
+        type: "set_env",
+        variable: "KASH_API_KEY",
+        description: "Provide the key via environment variable."
+      },
+      {
+        type: "open_url",
+        url: "mailto:engineering@kash.bot?subject=Kash%20staging%20API%20key%20request",
+        description: "Email `engineering@kash.bot` to request a `kash_test_*` staging key (self-service issuance ships with the production launch)."
+      }
+    ]
+  },
+  {
+    code: "INSUFFICIENT_SCOPE",
+    summary: "The API key is valid but lacks the scope this command requires.",
+    description: "Authentication succeeded but the key's scope (read-only / trade / admin) doesn't cover the route. Request a key with broader scope, or move to a tier that includes it.",
+    recoverable: true,
+    docsUrl: "https://docs.kash.bot/developer-docs/rest-api/authentication",
+    actions: [
+      {
+        type: "open_url",
+        url: "mailto:engineering@kash.bot?subject=Kash%20API%20key%20scope%20request",
+        description: "Email `engineering@kash.bot` for a key with broader scope."
+      }
+    ]
+  },
+  {
+    code: "RATE_LIMITED",
+    summary: "You have exceeded the per-key rate limit for this tier.",
+    description: "Slow down or upgrade for higher limits. The error envelope carries `retryAfterMs`; honor it via `kash --max-retries` or back off in your application.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/api/rate-limits",
+    actions: [
+      {
+        type: "open_url",
+        url: "https://kash.bot/pricing",
+        description: "Upgrade tier for higher rate limits."
+      }
+    ]
+  },
+  {
+    code: "NOT_FOUND",
+    summary: "The requested resource (market, trade, position) does not exist.",
+    description: "Markets and trades are identified by UUID. Confirm the id is correct (especially after copy-paste truncation) and that the resource is visible to the active key.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/api/errors",
+    actions: []
+  },
+  {
+    code: "CONFLICT",
+    summary: "A conflicting request is already in flight or the resource state changed.",
+    description: "Common cases: you sent a duplicate Idempotency-Key, the trade is awaiting high-value confirmation, or the market closed between fetch and trade. Inspect the resource before retrying.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/api/errors",
+    actions: [
+      {
+        type: "run_command",
+        command: "kash trade status <id>",
+        description: "Inspect the conflicting trade resource. Substitute <id> with the trade UUID.",
+        template: true
+      }
+    ]
+  },
+  {
+    code: "INVALID_INPUT",
+    summary: "The request body or arguments failed validation.",
+    description: "Check the field names and types against `kash <command> --help` or `kash schema <command>`. USDC amounts are decimal strings with up to 6 fractional digits.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/commands",
+    actions: [
+      {
+        type: "run_command",
+        command: "kash <command> --help",
+        description: "Inspect the command signature. Substitute <command> with the failing path (e.g. `trade buy`, `markets list`).",
+        template: true
+      },
+      {
+        type: "run_command",
+        command: "kash schema <command>",
+        description: "Get the JSON Schema for the command inputs. Substitute <command> with the failing path.",
+        template: true
+      }
+    ]
+  },
+  {
+    code: "MAINTENANCE",
+    summary: "The Kash trade pipeline is temporarily disabled (kill switch).",
+    description: "API trade processing is halted, typically during incident response or planned maintenance. Read state is unaffected. Honor the `retryAfterMs` and retry once the window closes.",
+    recoverable: true,
+    docsUrl: "https://docs.kash.bot/developer-docs/api-errors/API_TRADE_PROCESSING_HALTED",
+    actions: [
+      {
+        type: "wait_and_retry",
+        delayMs: 3e4,
+        description: "Wait 30s then retry. Surface the requestId if the failure persists."
+      }
+    ]
+  },
+  {
+    code: "TIMEOUT",
+    summary: "The request exceeded the SDK timeout (default 30s).",
+    description: "Either the server is slow or the network path is degraded. Retry, or pass --timeout-ms to raise the cap. Repeated timeouts are worth investigating against the status page.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/troubleshooting",
+    actions: [
+      {
+        type: "run_command",
+        command: "kash --timeout-ms 60000 <same command>",
+        description: "Re-run with a longer timeout. Substitute <same command> with the original invocation tail.",
+        template: true
+      }
+    ]
+  },
+  {
+    code: "NETWORK",
+    summary: "A transport-layer failure (DNS, TLS, connection refused) before any HTTP response.",
+    description: "The SDK never received a response. Check connectivity to api.kash.bot. The CLI retries network errors automatically; this means retries were exhausted.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/troubleshooting",
+    actions: []
+  },
+  {
+    code: "ABORTED",
+    summary: "The request was cancelled by the caller before it completed.",
+    description: "An AbortSignal you passed (or the spinner you cancelled) fired while the request was in flight. The server may or may not have processed the request \u2014 if it did, the side effect already landed. Idempotent requests can be safely retried with the same Idempotency-Key.",
+    recoverable: false,
+    docsUrl: "https://kash.bot/docs/cli/troubleshooting",
+    actions: []
+  },
+  {
+    code: "SERVER_ERROR",
+    summary: "The API returned a 5xx response after retries.",
+    description: "The request is safe to retry. If the issue persists, file a bug at https://github.com/KashDAO/cli/issues with the requestId on the error envelope.",
+    recoverable: true,
+    docsUrl: "https://docs.kash.bot/developer-docs/api-errors/DEPENDENCY_UNAVAILABLE",
+    actions: [
+      {
+        type: "wait_and_retry",
+        delayMs: 5e3,
+        description: "Wait 5s and retry. The CLI may have already exhausted its retry budget."
+      }
+    ]
+  },
+  {
+    code: "CONFIGURATION",
+    summary: "The CLI configuration file or environment is invalid.",
+    description: "The on-disk ~/.kash/config.json failed to parse, an env var (KASH_CHAIN_ID) doesn't match its expected shape, or a per-invocation flag (--max-retries, --timeout-ms, --base-url) was rejected by the SDK. Run `kash config show` to inspect what loaded.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/configuration",
+    actions: [
+      {
+        type: "run_command",
+        command: "kash config show",
+        description: "Inspect the loaded configuration and its sources."
+      }
+    ]
+  },
+  // ─── Direct-mode (kash protocol ...) ─────────────────────────────
+  {
+    code: "DIRECT_CONFIG_MISSING",
+    summary: "Direct-mode configuration is incomplete.",
+    description: "Direct-mode commands (`kash protocol ...`) require RPC URL, smart account address, signer key reference, and chain ID. One or more of these is missing from the active profile and the environment. Run `kash config show` to see what's loaded; set the missing fields with `kash config set rpcUrl \u2026`, `kash config set smartAccount 0x\u2026`, etc.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/direct-mode",
+    actions: [
+      {
+        type: "run_command",
+        command: "kash config show",
+        description: "Inspect the loaded configuration and source attribution."
+      },
+      {
+        type: "run_command",
+        command: "kash config set rpcUrl https://your-rpc.example.com",
+        description: "Set the RPC URL for direct-mode operations."
+      }
+    ]
+  },
+  {
+    code: "SIGNER_FAILED",
+    summary: "The configured signer (file/env/KMS) failed to load or sign.",
+    description: "The signer adapter referenced by `signerKeyRef` couldn't load the private key, or signing the UserOp hash failed. Common causes: missing/unreadable file, missing env var, malformed hex, or a KMS permission denial.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/direct-mode",
+    actions: [
+      {
+        type: "check_input",
+        field: "signerKeyRef",
+        description: "Verify the signer reference (file:<path> or env:<VAR>) and its target."
+      }
+    ]
+  },
+  {
+    code: "RPC_FAILED",
+    summary: "The RPC endpoint refused the request or timed out.",
+    description: "Network call to the configured `rpcUrl` failed. Could be a rate-limit at the RPC provider, a transient network issue, or a misconfigured URL. The protocol-sdk does NOT retry RPC calls \u2014 fail fast so the operator sees the issue.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/troubleshooting",
+    actions: [
+      {
+        type: "check_input",
+        field: "rpcUrl",
+        description: "Verify the RPC URL is reachable and the API key (if any) is valid."
+      }
+    ]
+  },
+  {
+    code: "BUNDLER_REJECTED",
+    summary: "The bundler refused to relay the UserOp.",
+    description: "Common rejection reasons: replacement-underpriced, sender-mempool-full, gas estimation drift, or a UserOp that the bundler suspects will revert. The error message carries the bundler-specific reason verbatim.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/direct-mode",
+    actions: []
+  },
+  {
+    code: "TRANSACTION_REVERTED",
+    summary: "The UserOp executed but the on-chain call reverted.",
+    description: "The transaction landed on-chain but the contract call reverted. The error message carries the decoded revert reason when the protocol-sdk recognises it (e.g. `MarketFrozen`, `InsufficientReserve`). Re-running with `kash protocol simulate` first will catch most reverts before they cost gas.",
+    recoverable: false,
+    docsUrl: "https://kash.bot/docs/cli/direct-mode",
+    actions: [
+      {
+        type: "run_command",
+        command: "kash protocol simulate <market-address> --action <buy|sell> --outcome <i> --amount <n>",
+        description: "Dry-run the trade against current chain state before re-submitting. Substitute every <placeholder>.",
+        template: true
+      }
+    ]
+  },
+  {
+    code: "CHAIN_ERROR",
+    summary: "A protocol-level chain interaction failed.",
+    description: "An on-chain read or simulation returned an unexpected shape, decoded to an unknown revert, or the contract addresses don't match the configured chain ID. Verify the chain ID and that the protocol contracts are deployed at the expected addresses for that chain.",
+    recoverable: false,
+    docsUrl: "https://kash.bot/docs/cli/direct-mode",
+    actions: [
+      {
+        type: "check_input",
+        field: "chainId",
+        description: "Confirm chainId matches the network your RPC and bundler target."
+      }
+    ]
+  },
+  {
+    code: "UNEXPECTED",
+    summary: "An unrecognised error escaped the SDK or the CLI.",
+    description: "This means the CLI's error mapper didn't recognise the underlying failure \u2014 the most likely cause is an SDK or runtime issue. File an issue with the message, the command, and the runtime info from `kash version --json`.",
+    recoverable: false,
+    docsUrl: "https://github.com/KashDAO/cli/issues",
+    actions: [
+      {
+        type: "run_command",
+        command: "kash version --json",
+        description: "Capture runtime info to attach to the bug report."
+      }
+    ]
+  },
+  {
+    code: "NOOP",
+    summary: "No-op exit (Commander emitted output and asked us to stop).",
+    description: "Commander's help/version paths don't represent a failure \u2014 it printed `--help` or `--version` output and signalled the CLI to exit cleanly. This code surfaces in JSON-output contexts so consumers know the run completed without doing real work; the human path exits 0 with no error envelope.",
+    recoverable: true,
+    docsUrl: "https://kash.bot/docs/cli/exit-codes",
+    actions: []
+  }
+];
+var CATALOG_BY_CODE = new Map(
+  ERROR_CATALOG.map((entry) => [entry.code, entry])
+);
+function lookupErrorCode(code) {
+  return CATALOG_BY_CODE.get(code);
+}
+function lookupErrorCodeWithFallback(code) {
+  const entry = CATALOG_BY_CODE.get(code);
+  if (entry) return entry;
+  return CATALOG_BY_CODE.get("UNEXPECTED");
+}
+var ERROR_CODES = new Set(ERROR_CATALOG.map((e) => e.code));
+
+// src/errors.ts
+var EXIT_CODES = {
+  OK: 0,
+  GENERIC: 1,
+  AUTH: 2
+};
+var CliError = class extends Error {
+  code;
+  suggestion;
+  exitCode;
+  requestId;
+  /** True iff a sensible retry/recovery path exists. */
+  recoverable;
+  /** Suggested delay before retrying (rate limit, server error). */
+  retryAfterMs;
+  /** Stable docs URL agents can fetch for richer context. */
+  docsUrl;
+  /** Machine-readable next-step hints. Empty array if none. */
+  actions;
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "CliError";
+    const catalogEntry = lookupErrorCodeWithFallback(options.code);
+    this.code = options.code;
+    this.suggestion = options.suggestion;
+    this.exitCode = options.exitCode ?? EXIT_CODES.GENERIC;
+    this.requestId = options.requestId;
+    this.recoverable = options.recoverable ?? catalogEntry.recoverable;
+    this.retryAfterMs = options.retryAfterMs;
+    this.docsUrl = options.docsUrl ?? catalogEntry.docsUrl;
+    if (options.actionsOverride !== void 0) {
+      this.actions = options.actionsOverride;
+    } else {
+      this.actions = [...options.actions ?? [], ...catalogEntry.actions];
+    }
+    this.cause = options.cause;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  /**
+   * Render the error as the stable JSON envelope agents pin to. Kept
+   * as a method so the index.ts emitError can serialise consistently
+   * regardless of caller.
+   */
+  toEnvelope() {
+    return {
+      ok: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        recoverable: this.recoverable,
+        ...this.suggestion === void 0 ? {} : { suggestion: this.suggestion },
+        ...this.retryAfterMs === void 0 ? {} : { retryAfterMs: this.retryAfterMs },
+        ...this.docsUrl === void 0 ? {} : { docsUrl: this.docsUrl },
+        ...this.requestId === void 0 ? {} : { requestId: this.requestId },
+        actions: this.actions
+      }
+    };
+  }
+};
+var CliValidationError = class extends CliError {
+  constructor(message, suggestion, field) {
+    super(message, {
+      code: "INVALID_INPUT",
+      ...suggestion === void 0 ? {} : { suggestion },
+      ...field === void 0 ? {} : {
+        actions: [
+          {
+            type: "check_input",
+            field,
+            description: `Verify the value of "${field}".`
+          }
+        ]
+      }
+    });
+    this.name = "CliValidationError";
+  }
+};
+var CliConfigurationError = class extends CliError {
+  constructor(message, suggestion) {
+    super(message, {
+      code: "CONFIGURATION",
+      ...suggestion === void 0 ? {} : { suggestion }
+    });
+    this.name = "CliConfigurationError";
+  }
+};
+function toCliError(err) {
+  if (err instanceof CliError) {
+    return err;
+  }
+  const commander = mapCommanderError(err);
+  if (commander) return commander;
+  if (err instanceof KashAuthenticationError) {
+    return new CliError(err.message, {
+      code: "AUTH_REQUIRED",
+      exitCode: EXIT_CODES.AUTH,
+      suggestion: "First-time setup: run 'kash setup' (interactive wizard). Otherwise: 'kash auth set-key' or set KASH_API_KEY.",
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashAuthorizationError) {
+    return new CliError(err.message, {
+      code: "INSUFFICIENT_SCOPE",
+      exitCode: EXIT_CODES.AUTH,
+      suggestion: "The API key is valid but is missing the scope this command needs. Email `engineering@kash.bot` to request a key with broader scope.",
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashRateLimitError) {
+    const retrySec = err.retryAfterSeconds;
+    const retryAfterMs = retrySec === void 0 ? void 0 : retrySec * 1e3;
+    const suggestion = retrySec !== void 0 ? `Retry in ${String(retrySec)}s. Upgrade for higher limits: https://kash.bot/pricing` : "Slow down request rate. Upgrade for higher limits: https://kash.bot/pricing";
+    return new CliError(err.message, {
+      code: "RATE_LIMITED",
+      suggestion,
+      ...retryAfterMs === void 0 ? {} : { retryAfterMs },
+      ...retryAfterMs === void 0 ? {} : {
+        actions: [
+          {
+            type: "wait_and_retry",
+            delayMs: retryAfterMs,
+            description: `Wait ${String(retrySec)}s then re-run the same command.`
+          }
+        ]
+      },
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashNotFoundError) {
+    return new CliError(err.message, {
+      code: "NOT_FOUND",
+      suggestion: "Double-check the resource id (markets and trades use UUIDs).",
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashConflictError) {
+    return new CliError(err.message, {
+      code: "CONFLICT",
+      suggestion: "A conflicting request is already in flight or the resource state changed underneath you. Inspect the trade with `kash trade status <id>` before retrying.",
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashValidationError) {
+    return new CliError(err.message, {
+      code: "INVALID_INPUT",
+      suggestion: "Verify the request shape matches `kash <command> --help`.",
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashMaintenanceError) {
+    const retrySec = err.retryAfterSeconds;
+    const retryAfterMs = retrySec === void 0 ? void 0 : retrySec * 1e3;
+    return new CliError(err.message, {
+      code: "MAINTENANCE",
+      suggestion: "The Kash trade pipeline is temporarily disabled (incident response or planned maintenance). Honor `retryAfterMs` and retry once the window closes.",
+      ...retryAfterMs === void 0 ? {} : { retryAfterMs },
+      ...retryAfterMs === void 0 ? {} : {
+        actions: [
+          {
+            type: "wait_and_retry",
+            delayMs: retryAfterMs,
+            description: `Wait ${String(retrySec)}s before retrying.`
+          }
+        ]
+      },
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashTimeoutError) {
+    return new CliError(err.message, {
+      code: "TIMEOUT",
+      suggestion: "The request exceeded the configured timeout. Retry, or pass --timeout-ms to raise the cap.",
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashNetworkError) {
+    const causeStr = `${String(err.message ?? "")} ${String(err.cause?.message ?? "")}`;
+    const isDnsError = causeStr.includes("ENOTFOUND") || causeStr.includes("getaddrinfo") || causeStr.includes("EAI_AGAIN") || causeStr.includes("Could not resolve");
+    const suggestion = isDnsError ? "The configured API host did not resolve in DNS. For staging, use a `kash_test_*` key \u2014 the CLI auto-routes to `https://api-staging.kash.bot/v1`. For a custom host, pass `--base-url <url>` or set `KASH_BASE_URL`. Production (`https://api.kash.bot/v1`) is not yet live; track launch status at https://docs.kash.bot." : "The request did not reach the API. Check network connectivity and retry.";
+    return new CliError(err.message, {
+      code: "NETWORK",
+      suggestion,
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashAbortedError) {
+    return new CliError(err.message, {
+      code: "ABORTED",
+      suggestion: "The request was cancelled before it completed. If the command is idempotent, you can safely retry with the same Idempotency-Key.",
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof KashServerError) {
+    return new CliError(err.message, {
+      code: "SERVER_ERROR",
+      suggestion: "The API returned a 5xx after retries. The request is safe to retry; if the failure persists, file a bug at https://github.com/KashDAO/cli/issues with the requestId.",
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof SdkKashConfigurationError) {
+    const firstIssue = err.issues[0];
+    const fieldPath = firstIssue?.path.join(".") ?? "";
+    return new CliError(err.message, {
+      code: "CONFIGURATION",
+      suggestion: firstIssue !== void 0 ? `SDK rejected ${fieldPath || "(root)"}: ${firstIssue.message}` : "The SDK rejected the configuration provided to the client.",
+      ...fieldPath ? {
+        actions: [
+          {
+            type: "check_input",
+            field: fieldPath,
+            description: `Fix the value of "${fieldPath}" and re-run.`
+          }
+        ]
+      } : {},
+      cause: err
+    });
+  }
+  const protocolErrorMapping = mapProtocolError(err);
+  if (protocolErrorMapping !== void 0) {
+    return protocolErrorMapping;
+  }
+  if (err instanceof KashError) {
+    return new CliError(err.message, {
+      code: "UNEXPECTED",
+      recoverable: err.isRetryable,
+      ...err.requestId === void 0 ? {} : { requestId: err.requestId },
+      cause: err
+    });
+  }
+  if (err instanceof Error) {
+    return new CliError(err.message, { code: "UNEXPECTED", cause: err });
+  }
+  return new CliError(String(err), { code: "UNEXPECTED", cause: err });
+}
+function isCommanderError(err) {
+  if (!(err instanceof Error)) return false;
+  const candidate = err;
+  return typeof candidate.code === "string" && candidate.code.startsWith("commander.") && typeof candidate.message === "string";
+}
+function mapCommanderError(err) {
+  if (!isCommanderError(err)) return void 0;
+  const { code, message } = err;
+  if (code === "commander.help" || code === "commander.helpDisplayed" || code === "commander.version") {
+    return new CliError("", {
+      code: "NOOP",
+      exitCode: EXIT_CODES.OK,
+      recoverable: false,
+      cause: err
+    });
+  }
+  if (code === "commander.unknownCommand") {
+    const match = /Did you mean (\S+?)\??\)?$/m.exec(message);
+    const suggested = match?.[1];
+    const suggestion = suggested ? `Did you mean \`kash ${suggested}\`? Run \`kash --help\` for the full command tree.` : "Run `kash --help` for the full command tree.";
+    return new CliError(stripTrailingNewlines(message), {
+      code: "INVALID_INPUT",
+      recoverable: true,
+      suggestion,
+      ...suggested === void 0 ? {} : {
+        actions: [
+          {
+            type: "run_command",
+            command: `kash ${suggested}`,
+            description: "Run the suggested command instead."
+          }
+        ]
+      },
+      cause: err
+    });
+  }
+  if (code === "commander.unknownOption") {
+    return new CliError(stripTrailingNewlines(message), {
+      code: "INVALID_INPUT",
+      recoverable: true,
+      suggestion: "Run `kash <command> --help` for the supported flags, or `kash docs --json` for the full surface.",
+      cause: err
+    });
+  }
+  if (code === "commander.missingArgument" || code === "commander.missingMandatoryOptionValue" || code === "commander.optionMissingArgument") {
+    return new CliError(stripTrailingNewlines(message), {
+      code: "INVALID_INPUT",
+      recoverable: true,
+      suggestion: "Run the command with `--help` to see required arguments.",
+      cause: err
+    });
+  }
+  return new CliError(stripTrailingNewlines(message), {
+    code: "INVALID_INPUT",
+    recoverable: true,
+    cause: err
+  });
+}
+function stripTrailingNewlines(s) {
+  return s.replace(/\n+$/, "");
+}
+function mapProtocolError(err) {
+  if (!(err instanceof Error)) return void 0;
+  switch (err.name) {
+    case "KashConfigError": {
+      const cliErr = new CliError(err.message, {
+        code: "DIRECT_CONFIG_MISSING",
+        suggestion: "Set the missing field via `kash config set <field> <value>` (rpcUrl, smartAccount, signerKeyRef, defaultChainId).",
+        cause: err
+      });
+      return cliErr;
+    }
+    case "KashSignerError":
+      return new CliError(err.message, {
+        code: "SIGNER_FAILED",
+        suggestion: "Verify the signerKeyRef target is readable (file:<path>) or set (env:<NAME>).",
+        cause: err
+      });
+    case "KashChainError":
+      return new CliError(err.message, {
+        code: "CHAIN_ERROR",
+        suggestion: "On-chain read or contract interaction failed unexpectedly.",
+        cause: err
+      });
+    case "KashBundlerError":
+      return new CliError(err.message, {
+        code: "BUNDLER_REJECTED",
+        suggestion: "Inspect the bundler-specific reason in the message and adjust.",
+        cause: err
+      });
+    case "KashSimulationRevertedError":
+      return new CliError(err.message, {
+        code: "TRANSACTION_REVERTED",
+        suggestion: "Re-run with `kash protocol simulate` to see the decoded revert reason.",
+        cause: err
+      });
+    case "KashProtocolError":
+      return new CliError(err.message, {
+        code: "CHAIN_ERROR",
+        suggestion: "Unrecognised protocol-sdk error. File an issue with `kash version --json`.",
+        cause: err
+      });
+    default:
+      return void 0;
+  }
+}
+
+export {
+  ERROR_CATALOG,
+  lookupErrorCode,
+  EXIT_CODES,
+  CliError,
+  CliValidationError,
+  CliConfigurationError,
+  toCliError,
+  isCommanderError
+};
+//# sourceMappingURL=chunk-UZNSYATZ.js.map