tenjin-cli 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/{chunk-DXPYFVKG.js → chunk-YN5SHIXQ.js}

@@ -1,12 +1,15 @@
 import { createRequire as __tenjinCreateRequire } from 'node:module'; const require = __tenjinCreateRequire(import.meta.url);
+import {
+  hasCode
+} from "./chunk-2I4QTOLB.js";
 import {
   writeFileAtomicExclusive
-} from "./chunk-ZPZFPVDN.js";
+} from "./chunk-MUBUQVC3.js";
 import {
   CliError,
   external_exports,
   walletPath
-} from "./chunk-YG2DO46P.js";
+} from "./chunk-OYMYCW7J.js";
 
 // src/lib/wallet/store.ts
 import { readFile, stat } from "fs/promises";
@@ -112,9 +115,6 @@ function isPreEncryptionRecord(json) {
 function isNotFound(err) {
   return hasCode(err, "ENOENT");
 }
-function hasCode(err, code) {
-  return typeof err === "object" && err !== null && "code" in err && err.code === code;
-}
 
 export {
   PRIVATE_KEY_RE,
@@ -123,4 +123,4 @@ export {
   readWalletRecord,
   writeWalletRecord
 };
-//# sourceMappingURL=chunk-DXPYFVKG.js.map
+//# sourceMappingURL=chunk-YN5SHIXQ.js.map

package/dist/chunk-YN5SHIXQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/wallet/store.ts"],"sourcesContent":["import { readFile, stat } from 'node:fs/promises';\nimport { z } from 'zod';\nimport * as Keystore from 'ox/Keystore';\nimport { CliError } from '../errors';\nimport { writeFileAtomicExclusive } from '../atomic-json';\nimport { hasCode } from '../errno';\nimport { walletPath } from '../paths';\n\n/** A 0x-prefixed 32-byte hex private key (case-insensitive). */\nexport const PRIVATE_KEY_RE = /^0x[0-9a-f]{64}$/i;\nconst ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;\n\n/**\n * The at-rest shape of a Keystore v3 document (Web3 Secret Storage). Validated\n * structurally on read so an obviously-corrupt keystore fails as\n * WALLET_INVALID_KEY before we ever ask for a passphrase; the real integrity\n * check is the keystore's own MAC, verified by ox at decrypt time. `kdfparams`\n * stays an open object because scrypt and pbkdf2 carry different fields and only\n * ox needs to interpret them.\n */\nconst KeystoreV3Schema = z.object({\n  crypto: z.object({\n    cipher: z.literal('aes-128-ctr'),\n    ciphertext: z.string(),\n    cipherparams: z.object({ iv: z.string() }),\n    kdf: z.enum(['scrypt', 'pbkdf2']),\n    kdfparams: z.record(z.string(), z.unknown()),\n    mac: z.string(),\n  }),\n  id: z.string(),\n  version: z.literal(3),\n});\n\n/**\n * The persisted wallet record (schema v2). The private key is NEVER stored in\n * cleartext: `keystore` is a Keystore v3 document (scrypt + AES-128-CTR) and the\n * key is recovered only by decrypting it with the wallet passphrase. `address`\n * stays top-level in cleartext ON PURPOSE so `show`/`balance`/`doctor` keep\n * working without a passphrase; only signing decrypts. The `provider`\n * discriminator keeps the schema from implying every future wallet embeds a\n * keystore. Validated on read (a corrupt file is WALLET_INVALID_KEY, never a\n * silent partial parse).\n */\nexport const WalletRecordSchema = z.object({\n  schemaVersion: z.literal(2),\n  provider: z.literal('local'),\n  address: z.string().regex(ADDRESS_RE, 'expected a 0x-prefixed 20-byte address'),\n  keystore: KeystoreV3Schema,\n  createdAt: z.string(),\n});\nexport type WalletRecord = Omit<z.infer<typeof WalletRecordSchema>, 'keystore'> & {\n  keystore: Keystore.Keystore;\n};\n\nexport async function walletFileExists(dir: string): Promise<boolean> {\n  return (await walletFileMode(dir)) !== null;\n}\n\n/** File permission bits (`mode & 0o777`), or null when the wallet file is absent. */\nexport async function walletFileMode(dir: string): Promise<number | null> {\n  try {\n    return (await stat(walletPath(dir))).mode & 0o777;\n  } catch (err) {\n    if (isNotFound(err)) return null;\n    throw err;\n  }\n}\n\n/** Read + validate the wallet record; null when absent, WALLET_INVALID_KEY when corrupt. */\nexport async function readWalletRecord(dir: string): Promise<WalletRecord | null> {\n  const path = walletPath(dir);\n  let raw: string;\n  try {\n    raw = await readFile(path, 'utf8');\n  } catch (err) {\n    if (isNotFound(err)) return null;\n    throw new CliError('WALLET_INVALID_KEY', `Could not read the wallet file at ${path}.`, {\n      fix: `Check file permissions on ${path}.`,\n      cause: err,\n    });\n  }\n  let json: unknown;\n  try {\n    json = JSON.parse(raw);\n  } catch (err) {\n    throw new CliError('WALLET_INVALID_KEY', `The wallet file at ${path} is not valid JSON.`, {\n      fix: `Move ${path} aside, then run \\`tenjin wallet create\\`.`,\n      cause: err,\n    });\n  }\n  // A pre-encryption record (schema v1 stored the raw key). There is no in-place\n  // migration: the old key must be swept and a fresh encrypted wallet created.\n  if (isPreEncryptionRecord(json)) {\n    throw new CliError(\n      'WALLET_INVALID_KEY',\n      `The wallet file at ${path} predates encrypted storage.`,\n      {\n        fix: `Move ${path} aside and run \\`tenjin wallet create\\`; sweep any funds from the old address first.`,\n      },\n    );\n  }\n  const parsed = WalletRecordSchema.safeParse(json);\n  if (!parsed.success) {\n    throw new CliError(\n      'WALLET_INVALID_KEY',\n      `The wallet file at ${path} is not a valid wallet record.`,\n      {\n        fix: `Move ${path} aside, then run \\`tenjin wallet create\\`.`,\n        details: parsed.error.issues,\n      },\n    );\n  }\n  return parsed.data as WalletRecord;\n}\n\n/**\n * Persist a validated record at 0600 in a 0700 dir, NO-CLOBBER. The exclusive\n * write — not an earlier existence check — is the authority: two concurrent\n * `create` runs can both pass a pre-check, but only one can win the atomic\n * commit; the loser surfaces as WALLET_EXISTS instead of silently overwriting\n * (and losing) a non-recoverable key.\n */\nexport async function writeWalletRecord(dir: string, record: WalletRecord): Promise<void> {\n  const validated = WalletRecordSchema.parse(record);\n  const path = walletPath(dir);\n  try {\n    await writeFileAtomicExclusive(path, `${JSON.stringify(validated, null, 2)}\\n`, {\n      mode: 0o600,\n      dirMode: 0o700,\n    });\n  } catch (err) {\n    if (hasCode(err, 'EEXIST')) {\n      throw new CliError('WALLET_EXISTS', `A wallet already exists at ${path}.`, {\n        fix: `Keys are non-recoverable; move it aside first (e.g. \\`mv ${path} ${path}.bak\\`) to create a new one.`,\n        cause: err,\n      });\n    }\n    throw err;\n  }\n}\n\n/** A cleartext-key record from before encrypted storage: schema v1 or a bare `privateKey`. */\nfunction isPreEncryptionRecord(json: unknown): boolean {\n  if (typeof json !== 'object' || json === null) return false;\n  const rec = json as Record<string, unknown>;\n  return rec.schemaVersion === 1 || 'privateKey' in rec;\n}\n\nfunction isNotFound(err: unknown): boolean {\n  return hasCode(err, 'ENOENT');\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA,SAAS,UAAU,YAAY;AASxB,IAAM,iBAAiB;AAC9B,IAAM,aAAa;AAUnB,IAAM,mBAAmB,iBAAE,OAAO;AAAA,EAChC,QAAQ,iBAAE,OAAO;AAAA,IACf,QAAQ,iBAAE,QAAQ,aAAa;AAAA,IAC/B,YAAY,iBAAE,OAAO;AAAA,IACrB,cAAc,iBAAE,OAAO,EAAE,IAAI,iBAAE,OAAO,EAAE,CAAC;AAAA,IACzC,KAAK,iBAAE,KAAK,CAAC,UAAU,QAAQ,CAAC;AAAA,IAChC,WAAW,iBAAE,OAAO,iBAAE,OAAO,GAAG,iBAAE,QAAQ,CAAC;AAAA,IAC3C,KAAK,iBAAE,OAAO;AAAA,EAChB,CAAC;AAAA,EACD,IAAI,iBAAE,OAAO;AAAA,EACb,SAAS,iBAAE,QAAQ,CAAC;AACtB,CAAC;AAYM,IAAM,qBAAqB,iBAAE,OAAO;AAAA,EACzC,eAAe,iBAAE,QAAQ,CAAC;AAAA,EAC1B,UAAU,iBAAE,QAAQ,OAAO;AAAA,EAC3B,SAAS,iBAAE,OAAO,EAAE,MAAM,YAAY,wCAAwC;AAAA,EAC9E,UAAU;AAAA,EACV,WAAW,iBAAE,OAAO;AACtB,CAAC;AAKD,eAAsB,iBAAiB,KAA+B;AACpE,SAAQ,MAAM,eAAe,GAAG,MAAO;AACzC;AAGA,eAAsB,eAAe,KAAqC;AACxE,MAAI;AACF,YAAQ,MAAM,KAAK,WAAW,GAAG,CAAC,GAAG,OAAO;AAAA,EAC9C,SAAS,KAAK;AACZ,QAAI,WAAW,GAAG,EAAG,QAAO;AAC5B,UAAM;AAAA,EACR;AACF;AAGA,eAAsB,iBAAiB,KAA2C;AAChF,QAAM,OAAO,WAAW,GAAG;AAC3B,MAAI;AACJ,MAAI;AACF,UAAM,MAAM,SAAS,MAAM,MAAM;AAAA,EACnC,SAAS,KAAK;AACZ,QAAI,WAAW,GAAG,EAAG,QAAO;AAC5B,UAAM,IAAI,SAAS,sBAAsB,qCAAqC,IAAI,KAAK;AAAA,MACrF,KAAK,6BAA6B,IAAI;AAAA,MACtC,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AACA,MAAI;AACJ,MAAI;AACF,WAAO,KAAK,MAAM,GAAG;AAAA,EACvB,SAAS,KAAK;AACZ,UAAM,IAAI,SAAS,sBAAsB,sBAAsB,IAAI,uBAAuB;AAAA,MACxF,KAAK,QAAQ,IAAI;AAAA,MACjB,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AAGA,MAAI,sBAAsB,IAAI,GAAG;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,MACA,sBAAsB,IAAI;AAAA,MAC1B;AAAA,QACE,KAAK,QAAQ,IAAI;AAAA,MACnB;AAAA,IACF;AAAA,EACF;AACA,QAAM,SAAS,mBAAmB,UAAU,IAAI;AAChD,MAAI,CAAC,OAAO,SAAS;AACnB,UAAM,IAAI;AAAA,MACR;AAAA,MACA,sBAAsB,IAAI;AAAA,MAC1B;AAAA,QACE,KAAK,QAAQ,IAAI;AAAA,QACjB,SAAS,OAAO,MAAM;AAAA,MACxB;AAAA,IACF;AAAA,EACF;AACA,SAAO,OAAO;AAChB;AASA,eAAsB,kBAAkB,KAAa,QAAqC;AACxF,QAAM,YAAY,mBAAmB,MAAM,MAAM;AACjD,QAAM,OAAO,WAAW,GAAG;AAC3B,MAAI;AACF,UAAM,yBAAyB,MAAM,GAAG,KAAK,UAAU,WAAW,MAAM,CAAC,CAAC;AAAA,GAAM;AAAA,MAC9E,MAAM;AAAA,MACN,SAAS;AAAA,IACX,CAAC;AAAA,EACH,SAAS,KAAK;AACZ,QAAI,QAAQ,KAAK,QAAQ,GAAG;AAC1B,YAAM,IAAI,SAAS,iBAAiB,8BAA8B,IAAI,KAAK;AAAA,QACzE,KAAK,4DAA4D,IAAI,IAAI,IAAI;AAAA,QAC7E,OAAO;AAAA,MACT,CAAC;AAAA,IACH;AACA,UAAM;AAAA,EACR;AACF;AAGA,SAAS,sBAAsB,MAAwB;AACrD,MAAI,OAAO,SAAS,YAAY,SAAS,KAAM,QAAO;AACtD,QAAM,MAAM;AACZ,SAAO,IAAI,kBAAkB,KAAK,gBAAgB;AACpD;AAEA,SAAS,WAAW,KAAuB;AACzC,SAAO,QAAQ,KAAK,QAAQ;AAC9B;","names":[]}

package/dist/chunk-Z52RA3NC.js

@@ -0,0 +1,137 @@
+import { createRequire as __tenjinCreateRequire } from 'node:module'; const require = __tenjinCreateRequire(import.meta.url);
+import {
+  CliError,
+  external_exports
+} from "./chunk-OYMYCW7J.js";
+
+// src/lib/output.ts
+import { styleText } from "util";
+import { Stream } from "stream";
+
+// src/schemas.ts
+var SCHEMA_VERSION = 1;
+var ErrorCodeSchema = external_exports.enum([
+  "NODE_UNSUPPORTED",
+  "USAGE",
+  "CONFIG_INVALID",
+  "WALLET_EXISTS",
+  "WALLET_MISSING",
+  "WALLET_INVALID_KEY",
+  "PROVIDER_ERROR",
+  "RPC_ERROR",
+  "API_UNREACHABLE",
+  "CONTRACT_MISMATCH",
+  "REFUSED",
+  "NETWORK_ERROR",
+  "INTERNAL",
+  "NOT_IMPLEMENTED",
+  // B2 (lookup/inspect/buy/outcome): a policy refusal (exit 3) has its own code
+  // so an agent can distinguish a spend-cap block from a generic REFUSED; a
+  // payment that failed after approval (exit 4) is PAYMENT_FAILED; the read
+  // route's own coded failures (402 preview parse, 409 gate) surface as these.
+  "POLICY_REFUSED",
+  "PAYMENT_FAILED",
+  "RESOURCE_NOT_FOUND",
+  "LOOKUP_NOT_FOUND",
+  // A 429 from the anonymous lookup/outcome/read limits; error.details carries
+  // retryAfterSeconds so a looping agent can back off instead of hammering.
+  "RATE_LIMITED",
+  // B3 (publish): a publish that needs the human's yes (exit 3) — soft scan
+  // findings, or `review` mode always. NEEDS_CONFIRMATION clears with --yes;
+  // PUBLISH_BLOCKED is a hard-block finding (a live secret) that no mode or --yes
+  // ever clears. PUBLISH_FAILED (exit 4) is a write that failed AFTER approval,
+  // mirroring PAYMENT_FAILED's post-decision failure class.
+  "NEEDS_CONFIRMATION",
+  "PUBLISH_BLOCKED",
+  "PUBLISH_FAILED"
+]);
+var MoneySchema = external_exports.object({
+  atomic: external_exports.string(),
+  usd: external_exports.string()
+});
+var OutputErrorSchema = external_exports.object({
+  code: ErrorCodeSchema,
+  message: external_exports.string(),
+  fix: external_exports.string().optional(),
+  details: external_exports.unknown().optional()
+});
+var SuccessEnvelopeSchema = external_exports.object({
+  schemaVersion: external_exports.literal(SCHEMA_VERSION),
+  command: external_exports.string(),
+  ok: external_exports.literal(true),
+  data: external_exports.unknown()
+});
+var FailureEnvelopeSchema = external_exports.object({
+  schemaVersion: external_exports.literal(SCHEMA_VERSION),
+  command: external_exports.string(),
+  ok: external_exports.literal(false),
+  error: OutputErrorSchema
+});
+var OutputEnvelopeSchema = external_exports.discriminatedUnion("ok", [
+  SuccessEnvelopeSchema,
+  FailureEnvelopeSchema
+]);
+
+// src/lib/output.ts
+function defaultIo() {
+  return {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    isTTY: Boolean(process.stdout.isTTY)
+  };
+}
+function emitSuccess(io, command, data, humanLines = [], opts = {}) {
+  writeJson(io.stdout, { schemaVersion: SCHEMA_VERSION, command, ok: true, data });
+  if (shouldRenderHuman(io, opts) && humanLines.length > 0) {
+    writeLines(io.stderr, humanLines);
+  }
+}
+function emitFailure(io, command, err, opts = {}) {
+  const cliErr = normalizeError(err);
+  const error = {
+    code: cliErr.code,
+    message: cliErr.message,
+    ...cliErr.fix !== void 0 ? { fix: cliErr.fix } : {},
+    ...cliErr.details !== void 0 ? { details: cliErr.details } : {}
+  };
+  writeJson(io.stdout, { schemaVersion: SCHEMA_VERSION, command, ok: false, error });
+  if (shouldRenderHuman(io, opts)) {
+    const lines = [paint(io, "red", `error: ${sanitizeForTerminal(cliErr.message)}`)];
+    if (cliErr.fix !== void 0) {
+      lines.push(paint(io, "dim", `fix: ${sanitizeForTerminal(cliErr.fix)}`));
+    }
+    writeLines(io.stderr, lines);
+  }
+  return cliErr;
+}
+function sanitizeForTerminal(text) {
+  return text.replace(/\x1b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)|[@-Z\\-_])/g, "").replace(/[\x00-\x08\x0a-\x1f\x7f-\x9f]/g, "");
+}
+function normalizeError(err) {
+  if (err instanceof CliError) return err;
+  if (err instanceof Error) return new CliError("INTERNAL", err.message, { cause: err });
+  return new CliError("INTERNAL", "Unexpected error", { details: err });
+}
+function shouldRenderHuman(io, opts) {
+  return io.isTTY && opts.json !== true;
+}
+function writeJson(stream, value) {
+  stream.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function writeLines(stream, lines) {
+  if (lines.length > 0) stream.write(`${lines.join("\n")}
+`);
+}
+function paint(io, format, text) {
+  if (io.stderr instanceof Stream) return styleText(format, text, { stream: io.stderr });
+  return styleText(format, text);
+}
+
+export {
+  defaultIo,
+  emitSuccess,
+  emitFailure,
+  sanitizeForTerminal
+};
+//# sourceMappingURL=chunk-Z52RA3NC.js.map

package/dist/chunk-Z52RA3NC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/output.ts","../src/schemas.ts"],"sourcesContent":["import { styleText } from 'node:util';\nimport { Stream } from 'node:stream';\nimport { CliError } from './errors';\nimport { SCHEMA_VERSION } from '../schemas';\nimport type { OutputError } from '../schemas';\n\n/**\n * Injected streams + TTY fact. Every command receives one via CommandContext,\n * so tests drive the CLI in-process with memory buffers and no child process.\n * `isTTY` is the real terminal fact; the separate `--json` flag (passed to the\n * emit functions) is what suppresses human rendering — the two are ANDed, never\n * conflated, so `--json` on a TTY still yields pure machine output.\n */\nexport interface Io {\n  stdout: NodeJS.WritableStream;\n  stderr: NodeJS.WritableStream;\n  isTTY: boolean;\n}\n\nexport function defaultIo(): Io {\n  return {\n    stdout: process.stdout,\n    stderr: process.stderr,\n    isTTY: Boolean(process.stdout.isTTY),\n  };\n}\n\nexport interface EmitOptions {\n  /** The global --json flag. When true, all stderr human rendering is suppressed. */\n  json?: boolean;\n}\n\n/**\n * Emit exactly one pretty-printed success envelope to stdout. When on a TTY and\n * --json is off, the optional human lines are rendered to stderr (never stdout —\n * stdout stays a clean single JSON object for the agent that piped us).\n */\nexport function emitSuccess(\n  io: Io,\n  command: string,\n  data: unknown,\n  humanLines: string[] = [],\n  opts: EmitOptions = {},\n): void {\n  writeJson(io.stdout, { schemaVersion: SCHEMA_VERSION, command, ok: true, data });\n  if (shouldRenderHuman(io, opts) && humanLines.length > 0) {\n    writeLines(io.stderr, humanLines);\n  }\n}\n\n/**\n * Emit exactly one pretty-printed failure envelope to stdout and (on a TTY, with\n * --json off) a red error line plus a `fix` line to stderr. Accepts a CliError or\n * any thrown value; anything that is not a CliError normalizes to INTERNAL.\n * Returns the normalized CliError so the caller can read its `exitCode`.\n */\nexport function emitFailure(\n  io: Io,\n  command: string,\n  err: unknown,\n  opts: EmitOptions = {},\n): CliError {\n  const cliErr = normalizeError(err);\n  const error: OutputError = {\n    code: cliErr.code,\n    message: cliErr.message,\n    ...(cliErr.fix !== undefined ? { fix: cliErr.fix } : {}),\n    ...(cliErr.details !== undefined ? { details: cliErr.details } : {}),\n  };\n  writeJson(io.stdout, { schemaVersion: SCHEMA_VERSION, command, ok: false, error });\n  if (shouldRenderHuman(io, opts)) {\n    // Error messages can embed server-sourced text (api error passthrough) and\n    // never carry intentional ANSI, so sanitize before painting.\n    const lines = [paint(io, 'red', `error: ${sanitizeForTerminal(cliErr.message)}`)];\n    if (cliErr.fix !== undefined) {\n      lines.push(paint(io, 'dim', `fix: ${sanitizeForTerminal(cliErr.fix)}`));\n    }\n    writeLines(io.stderr, lines);\n  }\n  return cliErr;\n}\n\n/**\n * Strip C0/C1 control characters and ANSI escape sequences from a string headed\n * for a terminal. Commands apply this to every SERVER-sourced string (titles,\n * handles) they put into human lines or the buy confirm prompt; without it a\n * malicious deployment could use cursor-movement escapes to overwrite the very\n * price a human is being asked to confirm. It is not applied to whole human\n * lines here because trusted callers (doctor) paint their own ANSI colors. JSON\n * stdout is untouched (JSON.stringify escapes control characters itself).\n */\nexport function sanitizeForTerminal(text: string): string {\n  return (\n    text\n      // CSI/OSC/charset escape sequences first, then any stray ESC and the rest\n      // of C0 (except \\t) plus DEL and the C1 range.\n      // eslint-disable-next-line no-control-regex\n      .replace(/\\x1b(?:\\[[0-9;?]*[ -/]*[@-~]|\\][^\\x07\\x1b]*(?:\\x07|\\x1b\\\\)|[@-Z\\\\-_])/g, '')\n      // eslint-disable-next-line no-control-regex\n      .replace(/[\\x00-\\x08\\x0a-\\x1f\\x7f-\\x9f]/g, '')\n  );\n}\n\n/** CliError passes through; every other thrown value becomes an INTERNAL CliError. */\nexport function normalizeError(err: unknown): CliError {\n  if (err instanceof CliError) return err;\n  if (err instanceof Error) return new CliError('INTERNAL', err.message, { cause: err });\n  return new CliError('INTERNAL', 'Unexpected error', { details: err });\n}\n\nfunction shouldRenderHuman(io: Io, opts: EmitOptions): boolean {\n  return io.isTTY && opts.json !== true;\n}\n\nfunction writeJson(stream: NodeJS.WritableStream, value: unknown): void {\n  stream.write(`${JSON.stringify(value, null, 2)}\\n`);\n}\n\nfunction writeLines(stream: NodeJS.WritableStream, lines: string[]): void {\n  if (lines.length > 0) stream.write(`${lines.join('\\n')}\\n`);\n}\n\n/**\n * Color the human line for stderr. styleText emits ANSI only when the target\n * stream is color-capable (a real TTY with color depth) and honors\n * NO_COLOR/FORCE_COLOR natively (verified on Node 22/23). The `stream` option is\n * passed only when stderr is a genuine Stream — styleText throws on anything\n * else, and a test/redirected sink is not one, so it falls back to the default\n * (process.stdout) capability check and simply comes out plain.\n */\nfunction paint(io: Io, format: Parameters<typeof styleText>[0], text: string): string {\n  if (io.stderr instanceof Stream) return styleText(format, text, { stream: io.stderr });\n  return styleText(format, text);\n}\n","import { z } from 'zod';\n\n/**\n * Bumped only on a breaking change to any stdout envelope shape. Agents pin on\n * this: a consumer that sees an unexpected value should refuse to parse rather\n * than guess. Every envelope carries it, success or failure.\n */\nexport const SCHEMA_VERSION = 1;\n\n/**\n * The closed set of machine error codes. `error.code` in a failure envelope is\n * always one of these; agents branch on it, humans read `message`/`fix`. The\n * exit-code mapping lives in lib/errors.ts (this enum is the single source of\n * the code names both sides agree on).\n */\nexport const ErrorCodeSchema = z.enum([\n  'NODE_UNSUPPORTED',\n  'USAGE',\n  'CONFIG_INVALID',\n  'WALLET_EXISTS',\n  'WALLET_MISSING',\n  'WALLET_INVALID_KEY',\n  'PROVIDER_ERROR',\n  'RPC_ERROR',\n  'API_UNREACHABLE',\n  'CONTRACT_MISMATCH',\n  'REFUSED',\n  'NETWORK_ERROR',\n  'INTERNAL',\n  'NOT_IMPLEMENTED',\n  // B2 (lookup/inspect/buy/outcome): a policy refusal (exit 3) has its own code\n  // so an agent can distinguish a spend-cap block from a generic REFUSED; a\n  // payment that failed after approval (exit 4) is PAYMENT_FAILED; the read\n  // route's own coded failures (402 preview parse, 409 gate) surface as these.\n  'POLICY_REFUSED',\n  'PAYMENT_FAILED',\n  'RESOURCE_NOT_FOUND',\n  'LOOKUP_NOT_FOUND',\n  // A 429 from the anonymous lookup/outcome/read limits; error.details carries\n  // retryAfterSeconds so a looping agent can back off instead of hammering.\n  'RATE_LIMITED',\n  // B3 (publish): a publish that needs the human's yes (exit 3) — soft scan\n  // findings, or `review` mode always. NEEDS_CONFIRMATION clears with --yes;\n  // PUBLISH_BLOCKED is a hard-block finding (a live secret) that no mode or --yes\n  // ever clears. PUBLISH_FAILED (exit 4) is a write that failed AFTER approval,\n  // mirroring PAYMENT_FAILED's post-decision failure class.\n  'NEEDS_CONFIRMATION',\n  'PUBLISH_BLOCKED',\n  'PUBLISH_FAILED',\n]);\nexport type ErrorCode = z.infer<typeof ErrorCodeSchema>;\n\n/**\n * All money in machine output is dual-form: `atomic` is the 6-decimal USDC base\n * unit as a decimal string (never a JS number — precision), `usd` is the same\n * value formatted as decimal dollars. Emit both so agents compute on `atomic`\n * and humans read `usd` without either side re-deriving the other.\n */\nexport const MoneySchema = z.object({\n  atomic: z.string(),\n  usd: z.string(),\n});\nexport type Money = z.infer<typeof MoneySchema>;\n\nexport const OutputErrorSchema = z.object({\n  code: ErrorCodeSchema,\n  message: z.string(),\n  fix: z.string().optional(),\n  details: z.unknown().optional(),\n});\nexport type OutputError = z.infer<typeof OutputErrorSchema>;\n\nexport const SuccessEnvelopeSchema = z.object({\n  schemaVersion: z.literal(SCHEMA_VERSION),\n  command: z.string(),\n  ok: z.literal(true),\n  data: z.unknown(),\n});\nexport type SuccessEnvelope = z.infer<typeof SuccessEnvelopeSchema>;\n\nexport const FailureEnvelopeSchema = z.object({\n  schemaVersion: z.literal(SCHEMA_VERSION),\n  command: z.string(),\n  ok: z.literal(false),\n  error: OutputErrorSchema,\n});\nexport type FailureEnvelope = z.infer<typeof FailureEnvelopeSchema>;\n\n/** The one thing every invocation prints to stdout, discriminated on `ok`. */\nexport const OutputEnvelopeSchema = z.discriminatedUnion('ok', [\n  SuccessEnvelopeSchema,\n  FailureEnvelopeSchema,\n]);\nexport type OutputEnvelope = z.infer<typeof OutputEnvelopeSchema>;\n"],"mappings":";;;;;;;AAAA,SAAS,iBAAiB;AAC1B,SAAS,cAAc;;;ACMhB,IAAM,iBAAiB;AAQvB,IAAM,kBAAkB,iBAAE,KAAK;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA,EAGA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AASM,IAAM,cAAc,iBAAE,OAAO;AAAA,EAClC,QAAQ,iBAAE,OAAO;AAAA,EACjB,KAAK,iBAAE,OAAO;AAChB,CAAC;AAGM,IAAM,oBAAoB,iBAAE,OAAO;AAAA,EACxC,MAAM;AAAA,EACN,SAAS,iBAAE,OAAO;AAAA,EAClB,KAAK,iBAAE,OAAO,EAAE,SAAS;AAAA,EACzB,SAAS,iBAAE,QAAQ,EAAE,SAAS;AAChC,CAAC;AAGM,IAAM,wBAAwB,iBAAE,OAAO;AAAA,EAC5C,eAAe,iBAAE,QAAQ,cAAc;AAAA,EACvC,SAAS,iBAAE,OAAO;AAAA,EAClB,IAAI,iBAAE,QAAQ,IAAI;AAAA,EAClB,MAAM,iBAAE,QAAQ;AAClB,CAAC;AAGM,IAAM,wBAAwB,iBAAE,OAAO;AAAA,EAC5C,eAAe,iBAAE,QAAQ,cAAc;AAAA,EACvC,SAAS,iBAAE,OAAO;AAAA,EAClB,IAAI,iBAAE,QAAQ,KAAK;AAAA,EACnB,OAAO;AACT,CAAC;AAIM,IAAM,uBAAuB,iBAAE,mBAAmB,MAAM;AAAA,EAC7D;AAAA,EACA;AACF,CAAC;;;ADzEM,SAAS,YAAgB;AAC9B,SAAO;AAAA,IACL,QAAQ,QAAQ;AAAA,IAChB,QAAQ,QAAQ;AAAA,IAChB,OAAO,QAAQ,QAAQ,OAAO,KAAK;AAAA,EACrC;AACF;AAYO,SAAS,YACd,IACA,SACA,MACA,aAAuB,CAAC,GACxB,OAAoB,CAAC,GACf;AACN,YAAU,GAAG,QAAQ,EAAE,eAAe,gBAAgB,SAAS,IAAI,MAAM,KAAK,CAAC;AAC/E,MAAI,kBAAkB,IAAI,IAAI,KAAK,WAAW,SAAS,GAAG;AACxD,eAAW,GAAG,QAAQ,UAAU;AAAA,EAClC;AACF;AAQO,SAAS,YACd,IACA,SACA,KACA,OAAoB,CAAC,GACX;AACV,QAAM,SAAS,eAAe,GAAG;AACjC,QAAM,QAAqB;AAAA,IACzB,MAAM,OAAO;AAAA,IACb,SAAS,OAAO;AAAA,IAChB,GAAI,OAAO,QAAQ,SAAY,EAAE,KAAK,OAAO,IAAI,IAAI,CAAC;AAAA,IACtD,GAAI,OAAO,YAAY,SAAY,EAAE,SAAS,OAAO,QAAQ,IAAI,CAAC;AAAA,EACpE;AACA,YAAU,GAAG,QAAQ,EAAE,eAAe,gBAAgB,SAAS,IAAI,OAAO,MAAM,CAAC;AACjF,MAAI,kBAAkB,IAAI,IAAI,GAAG;AAG/B,UAAM,QAAQ,CAAC,MAAM,IAAI,OAAO,UAAU,oBAAoB,OAAO,OAAO,CAAC,EAAE,CAAC;AAChF,QAAI,OAAO,QAAQ,QAAW;AAC5B,YAAM,KAAK,MAAM,IAAI,OAAO,QAAQ,oBAAoB,OAAO,GAAG,CAAC,EAAE,CAAC;AAAA,IACxE;AACA,eAAW,GAAG,QAAQ,KAAK;AAAA,EAC7B;AACA,SAAO;AACT;AAWO,SAAS,oBAAoB,MAAsB;AACxD,SACE,KAIG,QAAQ,0EAA0E,EAAE,EAEpF,QAAQ,kCAAkC,EAAE;AAEnD;AAGO,SAAS,eAAe,KAAwB;AACrD,MAAI,eAAe,SAAU,QAAO;AACpC,MAAI,eAAe,MAAO,QAAO,IAAI,SAAS,YAAY,IAAI,SAAS,EAAE,OAAO,IAAI,CAAC;AACrF,SAAO,IAAI,SAAS,YAAY,oBAAoB,EAAE,SAAS,IAAI,CAAC;AACtE;AAEA,SAAS,kBAAkB,IAAQ,MAA4B;AAC7D,SAAO,GAAG,SAAS,KAAK,SAAS;AACnC;AAEA,SAAS,UAAU,QAA+B,OAAsB;AACtE,SAAO,MAAM,GAAG,KAAK,UAAU,OAAO,MAAM,CAAC,CAAC;AAAA,CAAI;AACpD;AAEA,SAAS,WAAW,QAA+B,OAAuB;AACxE,MAAI,MAAM,SAAS,EAAG,QAAO,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;AAAA,CAAI;AAC5D;AAUA,SAAS,MAAM,IAAQ,QAAyC,MAAsB;AACpF,MAAI,GAAG,kBAAkB,OAAQ,QAAO,UAAU,QAAQ,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC;AACrF,SAAO,UAAU,QAAQ,IAAI;AAC/B;","names":[]}

package/dist/{chunk-EXBMF5X7.js → chunk-Z6MFJV5Z.js}

@@ -1,4 +1,25 @@
 import { createRequire as __tenjinCreateRequire } from 'node:module'; const require = __tenjinCreateRequire(import.meta.url);
+import {
+  PRIVATE_KEY_RE,
+  readWalletRecord,
+  walletFileMode,
+  writeWalletRecord
+} from "./chunk-YN5SHIXQ.js";
+import {
+  withFileLock
+} from "./chunk-YBMMV4Y4.js";
+import {
+  evaluateSpendPolicy
+} from "./chunk-UO22YNY4.js";
+import {
+  writeFileAtomic
+} from "./chunk-MUBUQVC3.js";
+import {
+  CliError,
+  external_exports,
+  passphraseBlobPath,
+  walletPath
+} from "./chunk-OYMYCW7J.js";
 import {
   hashAuthorization,
   hashMessage,
@@ -7,12 +28,12 @@ import {
   publicKeyToAddress,
   serializeSignature,
   serializeTransaction
-} from "./chunk-T4LKNY7T.js";
+} from "./chunk-NCE5NSN6.js";
 import {
   hmac,
   secp256k1,
   sha256
-} from "./chunk-Q53IYV2G.js";
+} from "./chunk-QVX5MWJZ.js";
 import {
   InvalidAddressError,
   concat3 as concat,
@@ -27,7 +48,7 @@ import {
   slice3 as slice,
   toHex,
   toHex2
-} from "./chunk-BRJHUQSY.js";
+} from "./chunk-YALGASEU.js";
 import {
   ahash,
   anumber,
@@ -39,21 +60,7 @@ import {
   rotl,
   swap32IfBE,
   u32
-} from "./chunk-CUWUHTIL.js";
-import {
-  PRIVATE_KEY_RE,
-  readWalletRecord,
-  walletFileMode,
-  writeWalletRecord
-} from "./chunk-DXPYFVKG.js";
-import {
-  writeFileAtomic
-} from "./chunk-ZPZFPVDN.js";
-import {
-  CliError,
-  passphraseBlobPath,
-  walletPath
-} from "./chunk-YG2DO46P.js";
+} from "./chunk-5CLSD5YN.js";
 
 // node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/pbkdf2.js
 function pbkdf2Init(hash, _password, _salt, _opts) {
@@ -1166,11 +1173,134 @@ function walletRecord(address, keystore) {
   };
 }
 
+// src/lib/wallet/spend.ts
+import { mkdir, readFile as readFile2 } from "fs/promises";
+import { randomUUID } from "crypto";
+import { join } from "path";
+var DEFAULT_WINDOW_MS = 864e5;
+var RESERVATION_TTL_MS = 6e5;
+var ReservationSchema = external_exports.object({
+  id: external_exports.string(),
+  amountAtomic: external_exports.string().regex(/^\d+$/),
+  atMs: external_exports.number()
+});
+var LedgerSchema = external_exports.object({
+  schemaVersion: external_exports.literal(2),
+  windowStartMs: external_exports.number(),
+  committedAtomic: external_exports.string().regex(/^\d+$/),
+  reservations: external_exports.array(ReservationSchema)
+});
+function emptyLedger(nowMs) {
+  return { schemaVersion: 2, windowStartMs: nowMs, committedAtomic: "0", reservations: [] };
+}
+function createLocalSpendAuthorizer(deps) {
+  const windowMs = deps.windowMs ?? DEFAULT_WINDOW_MS;
+  const now = deps.now ?? Date.now;
+  const path = join(deps.dir, "session.json");
+  const lockPath = `${path}.lock`;
+  const freshen = (ledger, nowMs) => {
+    if (ledger === null || nowMs - ledger.windowStartMs >= windowMs) return emptyLedger(nowMs);
+    return {
+      ...ledger,
+      reservations: ledger.reservations.filter((r) => nowMs - r.atMs < RESERVATION_TTL_MS)
+    };
+  };
+  const spentOf = (ledger) => ledger.reservations.reduce(
+    (sum, r) => sum + BigInt(r.amountAtomic),
+    BigInt(ledger.committedAtomic)
+  );
+  const persist = async (ledger) => {
+    await writeFileAtomic(path, `${JSON.stringify(ledger, null, 2)}
+`, {
+      mode: 384,
+      dirMode: 448
+    });
+  };
+  async function withLedger(fn) {
+    await mkdir(deps.dir, { recursive: true, mode: 448 });
+    return withFileLock(lockPath, async () => {
+      const nowMs = now();
+      const ledger = freshen(await readLedger(path), nowMs);
+      return fn(ledger, nowMs);
+    });
+  }
+  return {
+    policyEnforcement: "client-only",
+    async authorize(req) {
+      return withLedger(async (ledger) => {
+        const sessionSpentAtomic = spentOf(ledger);
+        const evaluation = evaluateSpendPolicy(deps.policy, {
+          amountAtomic: req.amountAtomic,
+          creator: req.creator,
+          ...req.maxPriceAtomic !== void 0 ? { maxPriceAtomic: req.maxPriceAtomic } : {},
+          sessionSpentAtomic
+        });
+        const base = {
+          ...evaluation,
+          amountAtomic: req.amountAtomic,
+          sessionSpentAtomic,
+          sessionBudgetAtomic: deps.policy.sessionBudgetAtomic,
+          policyEnforcement: "client-only"
+        };
+        if (evaluation.decision === "deny" || deps.policy.sessionBudgetAtomic === 0n) {
+          return base;
+        }
+        const reservation = {
+          id: randomUUID(),
+          amountAtomic: req.amountAtomic.toString(),
+          atMs: now()
+        };
+        await persist({ ...ledger, reservations: [...ledger.reservations, reservation] });
+        return { ...base, reservationId: reservation.id };
+      });
+    },
+    async commit(reservationId, amountAtomic) {
+      await withLedger(async (ledger) => {
+        const reservation = reservationId !== void 0 ? ledger.reservations.find((r) => r.id === reservationId) : void 0;
+        const settled = reservation !== void 0 ? BigInt(reservation.amountAtomic) : amountAtomic;
+        await persist({
+          ...ledger,
+          committedAtomic: (BigInt(ledger.committedAtomic) + settled).toString(),
+          reservations: reservationId !== void 0 ? ledger.reservations.filter((r) => r.id !== reservationId) : ledger.reservations
+        });
+      });
+    },
+    async release(reservationId) {
+      if (reservationId === void 0) return;
+      await withLedger(async (ledger) => {
+        if (!ledger.reservations.some((r) => r.id === reservationId)) return;
+        await persist({
+          ...ledger,
+          reservations: ledger.reservations.filter((r) => r.id !== reservationId)
+        });
+      });
+    }
+  };
+}
+async function readLedger(path) {
+  let raw;
+  try {
+    raw = await readFile2(path, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = LedgerSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+
 // src/lib/wallet/index.ts
 function resolveWalletProvider(ctx, opts = {}) {
   if (opts.provider !== void 0) return opts.provider;
   return createLocalProvider({ dir: ctx.dataDir, env: process.env });
 }
+function resolveSpendAuthorizer(ctx, policy, opts = {}) {
+  if (opts.authorizer !== void 0) return opts.authorizer;
+  return createLocalSpendAuthorizer({ dir: ctx.dataDir, policy });
+}
 async function describeWallet(provider) {
   try {
     return await provider.describe();
@@ -1187,7 +1317,9 @@ async function describeWallet(provider) {
 export {
   resolvePassphraseForCreate,
   createLocalWallet,
+  createLocalSpendAuthorizer,
   resolveWalletProvider,
+  resolveSpendAuthorizer,
   describeWallet
 };
 /*! Bundled license information:
@@ -1195,4 +1327,4 @@ export {
 @noble/ciphers/esm/utils.js:
   (*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-EXBMF5X7.js.map
+//# sourceMappingURL=chunk-Z6MFJV5Z.js.map