@1sat/cli 0.0.90 → 0.0.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1sat/cli",
-  "version": "0.0.90",
+  "version": "0.0.92",
   "description": "CLI for 1Sat Ordinals SDK",
   "type": "module",
   "main": "./src/cli.ts",
@@ -26,13 +26,13 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@1sat/actions": "0.0.189",
-    "@1sat/client": "0.0.45",
-    "@1sat/types": "0.0.36",
-    "@1sat/wallet-node": "0.0.62",
-    "@1sat/wallet-server": "0.0.36",
-    "@bsv/sdk": "^2.1.6",
-    "@bsv/wallet-toolbox": "2.1.24",
+    "@1sat/actions": "0.0.192",
+    "@1sat/client": "0.0.46",
+    "@1sat/types": "0.0.37",
+    "@1sat/wallet-node": "0.0.64",
+    "@1sat/wallet-server": "0.0.38",
+    "@bsv/sdk": "^2.1.9",
+    "@bsv/wallet-toolbox": "2.4.3",
     "chalk": "^5.0.0",
     "@clack/prompts": "^0.8.0",
     "bitcoin-backup": "^0.0.11",

package/src/beef.ts

@@ -0,0 +1,48 @@
+/**
+ * Parse --beef from file path, hex, or base64.
+ */
+import { readFileSync } from 'node:fs'
+import { Utils } from '@bsv/sdk'
+import { fatal } from './output'
+
+export function parseBeefFlag(value: string | undefined): number[] | undefined {
+	if (!value) return undefined
+	try {
+		if (!value.includes('\n') && !value.includes(' ') && value.length < 4096) {
+			try {
+				const buf = readFileSync(value)
+				return Array.from(buf)
+			} catch {
+				// not a readable path — treat as hex/base64
+			}
+		}
+		const hex = value.replace(/^0x/i, '')
+		if (/^[0-9a-fA-F]+$/.test(hex) && hex.length % 2 === 0) {
+			return Utils.toArray(hex, 'hex')
+		}
+		return Utils.toArray(value, 'base64')
+	} catch (e) {
+		fatal(`Invalid --beef: ${e instanceof Error ? e.message : String(e)}`)
+	}
+}
+
+/** Bare id from tags (strips id: prefix). */
+export function idFromTags(tags: string[] | undefined): string | undefined {
+	const t = tags?.find((x) => x.startsWith('id:'))
+	return t ? t.slice(3) : undefined
+}
+
+/**
+ * Parse --to as P2PKH address or identity pubkey hex.
+ * Identity keys: 66 hex chars starting with 02/03.
+ */
+export function parseToFlag(to: string): {
+	address?: string
+	counterparty?: string
+} {
+	const trimmed = to.trim()
+	if (/^0[23][0-9a-fA-F]{64}$/.test(trimmed)) {
+		return { counterparty: trimmed }
+	}
+	return { address: trimmed }
+}

package/src/commands/authfetch.ts

@@ -0,0 +1,187 @@
+/**
+ * Authenticated HTTP client using CLI wallet keys (BRC-104 AuthFetch).
+ *
+ *   1sat authfetch <method> <url> [--body <json|@file>] [--header 'K: V']...
+ *
+ * Always authenticates. On 402 Payment Required, prompts unless --yes, then
+ * AuthFetch pays and retries.
+ */
+
+import { readFileSync } from 'node:fs'
+import { AuthFetch } from '@bsv/sdk'
+import { confirm, isCancel } from '@clack/prompts'
+import type { GlobalFlags } from '../args'
+import { loadContext } from '../context'
+import { printCommandHelp } from '../help'
+import { loadKey } from '../keys'
+import { fatal, output } from '../output'
+
+const METHODS = new Set([
+	'GET',
+	'POST',
+	'PUT',
+	'PATCH',
+	'DELETE',
+	'HEAD',
+	'OPTIONS',
+])
+
+export async function handleAuthfetchCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	if (
+		!args[0] ||
+		args[0] === 'help' ||
+		args.includes('--help') ||
+		args.includes('-h')
+	) {
+		printCommandHelp('authfetch', opts.json)
+		return
+	}
+
+	let method: string | undefined
+	let url: string | undefined
+	let bodyRaw: string | undefined
+	const headerArgs: string[] = []
+
+	for (let i = 0; i < args.length; i++) {
+		const a = args[i]
+		if (a === '--body') {
+			bodyRaw = args[++i]
+			if (bodyRaw === undefined) fatal('--body requires a value')
+			continue
+		}
+		if (a === '--header') {
+			const h = args[++i]
+			if (h === undefined) fatal('--header requires a value')
+			headerArgs.push(h)
+			continue
+		}
+		if (a.startsWith('--')) {
+			fatal(`Unknown flag: ${a}`)
+		}
+		if (!method) {
+			method = a.toUpperCase()
+			continue
+		}
+		if (!url) {
+			url = a
+			continue
+		}
+		fatal(`Unexpected argument: ${a}`)
+	}
+
+	if (!method || !METHODS.has(method)) {
+		fatal(
+			`Usage: 1sat authfetch <method> <url> [--body …] [--header 'K: V']…\nUnknown or missing method: ${method ?? ''}`,
+		)
+	}
+	if (!url) fatal('Missing URL')
+	try {
+		new URL(url)
+	} catch {
+		fatal(`Invalid URL: ${url}`)
+	}
+
+	const headers: Record<string, string> = {}
+	for (const h of headerArgs) {
+		const i = h.indexOf(':')
+		if (i <= 0) fatal(`Invalid --header (want 'Name: value'): ${h}`)
+		headers[h.slice(0, i).trim()] = h.slice(i + 1).trim()
+	}
+
+	let body: string | undefined
+	if (bodyRaw !== undefined) {
+		body = bodyRaw.startsWith('@')
+			? readFileSync(bodyRaw.slice(1), 'utf8')
+			: bodyRaw
+		if (!headers['Content-Type'] && !headers['content-type']) {
+			headers['Content-Type'] = 'application/json'
+		}
+	}
+
+	const privateKey = await loadKey()
+	const { walletResult, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const auth = new AuthFetch(walletResult.wallet)
+		const init = {
+			method,
+			headers,
+			...(body !== undefined ? { body } : {}),
+		}
+
+		let res: Response
+		try {
+			// Authenticate but do not auto-pay on first try (so we can confirm).
+			res = await auth.fetch(url, {
+				...init,
+				paymentRetryAttempts: 0,
+			})
+		} catch (err) {
+			// Public routes may return 200 without BSV auth headers; AuthFetch rejects those.
+			const msg = err instanceof Error ? err.message : String(err)
+			if (/without valid BSV authentication/i.test(msg)) {
+				res = await fetch(url, init)
+			} else {
+				throw err
+			}
+		}
+
+		if (res.status === 402) {
+			const satsHeader = res.headers.get('x-bsv-payment-satoshis-required')
+			const sats = satsHeader ? Number(satsHeader) : undefined
+			const payMsg =
+				sats != null && Number.isFinite(sats)
+					? `Pay ${sats} sats for ${method} ${url}?`
+					: `Server requires payment (402) for ${method} ${url}. Continue?`
+
+			if (!opts.yes) {
+				const ok = await confirm({ message: payMsg })
+				if (isCancel(ok) || !ok) fatal('Payment cancelled.')
+			}
+
+			res = await auth.fetch(url, init)
+		}
+
+		const text = await res.text()
+		let parsed: unknown = text
+		const ct = res.headers.get('content-type') ?? ''
+		if (ct.includes('application/json') && text.length > 0) {
+			try {
+				parsed = JSON.parse(text)
+			} catch {
+				/* keep raw */
+			}
+		}
+
+		if (opts.json) {
+			output(
+				{
+					status: res.status,
+					ok: res.ok,
+					headers: Object.fromEntries(res.headers.entries()),
+					body: parsed,
+				},
+				opts,
+			)
+			if (!res.ok) process.exit(1)
+			return
+		}
+
+		if (!opts.quiet) {
+			console.log(`${res.status} ${res.statusText || ''}`.trim())
+		}
+		if (text.length > 0) {
+			console.log(
+				typeof parsed === 'string' ? parsed : JSON.stringify(parsed, null, 2),
+			)
+		}
+		if (!res.ok) process.exit(1)
+	} finally {
+		await destroy()
+	}
+}

package/src/commands/locks.ts

@@ -1,15 +1,16 @@
 /**
- * Lock commands - info, lock, unlock.
+ * Lock commands — list, bsv (lock), unlock.
  */
 
-import { getLockData, lockBsv, unlockBsv } from '@1sat/actions'
+import { listLocks, lockBsv, unlockBsv } from '@1sat/actions'
 import { confirm, isCancel } from '@clack/prompts'
 import type { GlobalFlags } from '../args'
 import { extractFlag } from '../args'
+import { idFromTags } from '../beef'
 import { loadContext } from '../context'
 import { printCommandHelp } from '../help'
 import { loadKey } from '../keys'
-import { fatal, output, printKeyValue } from '../output'
+import { fatal, formatLabel, formatValue, output } from '../output'
 
 export async function handleLocksCommand(
 	args: string[],
@@ -18,10 +19,12 @@ export async function handleLocksCommand(
 	const [subcommand, ...rest] = args
 
 	switch (subcommand) {
-		case 'info':
-			return locksInfo(rest, opts)
-		case 'lock':
-			return locksLock(rest, opts)
+		case 'list':
+		case 'info': // deprecated alias — still summary-friendly
+			return locksList(rest, opts)
+		case 'bsv':
+		case 'lock': // deprecated alias
+			return locksBsv(rest, opts)
 		case 'unlock':
 			return locksUnlock(rest, opts)
 		default:
@@ -32,89 +35,99 @@ export async function handleLocksCommand(
 	}
 }
 
-async function locksInfo(_args: string[], opts: GlobalFlags): Promise<void> {
+async function locksList(_args: string[], opts: GlobalFlags): Promise<void> {
 	const privateKey = await loadKey()
-	const { ctx, destroy } = await loadContext(privateKey, {
-		chain: opts.chain,
-	})
+	const { ctx, destroy } = await loadContext(privateKey, { chain: opts.chain })
 
 	try {
-		const data = await getLockData.execute(ctx, {})
+		const result = await listLocks.execute(ctx, {})
 
 		if (opts.json) {
-			output(data, opts)
+			output(result.outputs, opts)
 			return
 		}
 
-		printKeyValue({
-			'Total Locked (sats)': data.totalLocked,
-			'Unlockable (sats)': data.unlockable,
-			'Next Unlock Block': data.nextUnlock || 'none',
-		})
+		if (result.outputs.length === 0) {
+			output('No locks found.', opts)
+			return
+		}
+
+		let total = 0
+		for (const o of result.outputs) {
+			const id = idFromTags(o.tags) ?? ''
+			const until = o.tags?.find((t) => t.startsWith('until:'))?.slice(6) ?? '?'
+			total += o.satoshis
+			console.log(
+				`  ${formatValue(id)}  ${formatValue(String(o.satoshis))} sats  until ${formatLabel(until)}  ${formatValue(o.outpoint)}`,
+			)
+		}
+		console.log(`\n  ${result.outputs.length} lock(s), ${total} sats total.`)
 	} finally {
 		await destroy()
 	}
 }
 
-async function locksLock(args: string[], opts: GlobalFlags): Promise<void> {
+async function locksBsv(args: string[], opts: GlobalFlags): Promise<void> {
 	const satsStr = extractFlag(args, '--sats')
-	const blocksStr = extractFlag(args, '--blocks')
+	const untilStr = extractFlag(args, '--until') ?? extractFlag(args, '--blocks')
 
 	if (!satsStr) fatal('Missing --sats <amount>')
-	if (!blocksStr) fatal('Missing --blocks <n>')
+	if (!untilStr) fatal('Missing --until <block-height>')
 
 	const satoshis = Number(satsStr)
 	if (!Number.isFinite(satoshis) || satoshis <= 0) {
 		fatal('--sats must be a positive number')
 	}
 
-	const until = Number(blocksStr)
+	const until = Number(untilStr)
 	if (!Number.isFinite(until) || until <= 0) {
-		fatal('--blocks must be a positive block height')
+		fatal('--until must be a positive block height')
 	}
 
 	if (!opts.yes) {
 		const ok = await confirm({
 			message: `Lock ${satoshis} satoshis until block ${until}?`,
 		})
-		if (isCancel(ok) || !ok) {
-			fatal('Lock cancelled.')
-		}
+		if (isCancel(ok) || !ok) fatal('Lock cancelled.')
 	}
 
 	const privateKey = await loadKey()
-	const { ctx, destroy } = await loadContext(privateKey, {
-		chain: opts.chain,
-	})
+	const { ctx, destroy } = await loadContext(privateKey, { chain: opts.chain })
 
 	try {
 		const result = await lockBsv.execute(ctx, {
 			requests: [{ satoshis, until }],
 		})
-
-		if (result.error) {
-			fatal(result.error)
-		}
-
+		if (result.error) fatal(result.error)
 		output(opts.json ? result : { txid: result.txid }, opts)
 	} finally {
 		await destroy()
 	}
 }
 
-async function locksUnlock(_args: string[], opts: GlobalFlags): Promise<void> {
-	const privateKey = await loadKey()
-	const { ctx, destroy } = await loadContext(privateKey, {
-		chain: opts.chain,
-	})
+async function locksUnlock(args: string[], opts: GlobalFlags): Promise<void> {
+	const ids = extractFlag(args, '--ids')
+		?.split(',')
+		.map((s) => s.trim())
+		.filter(Boolean)
 
-	try {
-		const result = await unlockBsv.execute(ctx, {})
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: ids?.length
+				? `Unlock ${ids.length} lock(s)?`
+				: 'Unlock all matured locks?',
+		})
+		if (isCancel(ok) || !ok) fatal('Unlock cancelled.')
+	}
 
-		if (result.error) {
-			fatal(result.error)
-		}
+	const privateKey = await loadKey()
+	const { ctx, destroy } = await loadContext(privateKey, { chain: opts.chain })
 
+	try {
+		const result = await unlockBsv.execute(ctx, {
+			...(ids?.length ? { ids } : {}),
+		})
+		if (result.error) fatal(result.error)
 		output(opts.json ? result : { txid: result.txid }, opts)
 	} finally {
 		await destroy()

package/src/commands/messagebox.ts

@@ -0,0 +1,59 @@
+/**
+ * MessageBox commands — pull paymail / P2P inbox into the wallet.
+ *
+ *   1sat messagebox sync [--url <host>] [--box <name>]
+ */
+
+import { syncMessages } from '@1sat/actions'
+import type { GlobalFlags } from '../args'
+import { extractFlag } from '../args'
+import { loadContext } from '../context'
+import { printCommandHelp } from '../help'
+import { loadKey } from '../keys'
+import { output } from '../output'
+
+export async function handleMessageboxCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'sync':
+			return messageboxSync(rest, opts)
+		default:
+			printCommandHelp('messagebox', opts.json)
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+async function messageboxSync(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const url = extractFlag(args, '--url')
+	const box = extractFlag(args, '--box')
+
+	const privateKey = await loadKey()
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await syncMessages.execute(ctx, {
+			...(url ? { messageboxUrl: url } : {}),
+			...(box ? { messageBox: box } : {}),
+		})
+
+		if (opts.json) {
+			output(result, opts)
+			return
+		}
+
+		console.log(`\nprocessed: ${result.processed}  failed: ${result.failed}\n`)
+	} finally {
+		await destroy()
+	}
+}