@1sat/cli 0.0.21 → 0.0.23

package/package.json

@@ -1,34 +1,41 @@
 {
-	"name": "@1sat/cli",
-	"version": "0.0.21",
-	"description": "CLI for 1Sat Ordinals SDK",
-	"type": "module",
-	"main": "./src/cli.ts",
-	"bin": {
-		"1sat": "./src/cli.ts"
-	},
-	"files": ["src"],
-	"scripts": {
-		"build": "bun build ./src/cli.ts --compile --outfile=bin/1sat --external pg --external pg-native --external pg-query-stream --external tedious --external oracledb --external mysql",
-		"dev": "bun run src/cli.ts",
-		"lint": "biome check src"
-	},
-	"keywords": ["1sat", "bsv", "ordinals", "cli"],
-	"license": "MIT",
-	"dependencies": {
-		"@1sat/actions": "0.0.82",
-		"@1sat/client": "0.0.20",
-		"@1sat/types": "0.0.14",
-		"@1sat/wallet-node": ">=0.0.13",
-		"@bsv/sdk": "^2.0.6",
-		"chalk": "^5.0.0",
-		"@clack/prompts": "^0.8.0",
-		"bitcoin-backup": "^0.0.11",
-		"dotenv": "^17.0.0",
-		"evlog": "^2.10.0"
-	},
-	"devDependencies": {
-		"@types/bun": "^1.3.9",
-		"typescript": "^5.9.3"
-	}
-}
+  "name": "@1sat/cli",
+  "version": "0.0.23",
+  "description": "CLI for 1Sat Ordinals SDK",
+  "type": "module",
+  "main": "./src/cli.ts",
+  "bin": {
+    "1sat": "./src/cli.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "build": "bun build ./src/cli.ts --compile --outfile=bin/1sat --external pg --external pg-native --external pg-query-stream --external tedious --external oracledb --external mysql",
+    "dev": "bun run src/cli.ts",
+    "lint": "biome check src"
+  },
+  "keywords": [
+    "1sat",
+    "bsv",
+    "ordinals",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@1sat/actions": "0.0.83",
+    "@1sat/client": "0.0.20",
+    "@1sat/types": "0.0.15",
+    "@1sat/wallet-node": "0.0.23",
+    "@bsv/sdk": "^2.0.6",
+    "chalk": "^5.0.0",
+    "@clack/prompts": "^0.8.0",
+    "bitcoin-backup": "^0.0.11",
+    "dotenv": "^17.0.0",
+    "evlog": "^2.10.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.9",
+    "typescript": "^5.9.3"
+  }
+}

package/src/args.ts

@@ -82,6 +82,24 @@ export function extractFlag(args: string[], flag: string): string | undefined {
 	return args[idx + 1]
 }
 
+/**
+ * Extract multiple values for a flag, supporting comma-delimited and multiple flag occurrences.
+ * Example: --tags a,b,c OR --tags a --tags b --tags c
+ */
+export function extractFlags(args: string[], flag: string): string[] {
+	const values: string[] = []
+	for (let i = 0; i < args.length - 1; i++) {
+		if (args[i] === flag) {
+			const value = args[i + 1]
+			if (value && !value.startsWith('--')) {
+				// Split comma-delimited values
+				values.push(...value.split(',').filter((v) => v.length > 0))
+			}
+		}
+	}
+	return values
+}
+
 /**
  * Check if a boolean flag is present.
  */

package/src/commands/config.ts

@@ -105,7 +105,9 @@ function configSet(args: string[], opts: GlobalFlags): void {
 	if (key === 'monitorIntervalMinutes') {
 		const n = Number(value)
 		if (!Number.isFinite(n) || n < 0) {
-			fatal('monitorIntervalMinutes must be a non-negative number (0 to disable)')
+			fatal(
+				'monitorIntervalMinutes must be a non-negative number (0 to disable)',
+			)
 		}
 	}
 

package/src/commands/identity.ts

@@ -4,7 +4,7 @@
  * BAP (Bitcoin Attestation Protocol) identity management.
  */
 
-import { publishIdentity, signBsm } from '@1sat/actions'
+import { publishIdentity, signBsm, updateProfile } from '@1sat/actions'
 import type { GlobalFlags } from '../args'
 import { extractFlag } from '../args'
 import { loadContext } from '../context'
@@ -21,6 +21,8 @@ export async function handleIdentityCommand(
 	switch (subcommand) {
 		case 'create':
 			return identityCreate(rest, opts)
+		case 'update-profile':
+			return identityUpdateProfile(rest, opts)
 		case 'info':
 			return identityInfo(rest, opts)
 		case 'sign':
@@ -30,6 +32,7 @@ export async function handleIdentityCommand(
 		default:
 			printCommandHelp('identity', {
 				create: 'Create/publish a BAP identity',
+				'update-profile': 'Update BAP identity profile (--profile <json>)',
 				info: 'Show BAP identity information',
 				sign: 'Sign a message with identity key (--message <text>)',
 				verify:
@@ -128,3 +131,36 @@ async function identityVerify(
 		'identity verify is not yet implemented (needs direct BSM.verify integration)',
 	)
 }
+
+async function identityUpdateProfile(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const profileStr = extractFlag(args, '--profile')
+
+	if (!profileStr) fatal('Missing --profile <json>')
+
+	let profile: Record<string, unknown>
+	try {
+		profile = JSON.parse(profileStr)
+	} catch {
+		fatal(`Invalid JSON in --profile: ${profileStr}`)
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await updateProfile.execute(ctx, { profile })
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}

package/src/commands/init.ts

@@ -8,6 +8,7 @@
  * 4. Config file creation
  */
 
+import { randomBytes } from 'node:crypto'
 import { PrivateKey } from '@bsv/sdk'
 import {
 	cancel,
@@ -162,16 +163,8 @@ export async function handleInitCommand(
 		// bitcoin-backup Touch ID not available — skip silently
 	}
 
-	// 4. Optional: storage identity key
-	const storageId = await text({
-		message: 'Storage identity key (for wallet persistence):',
-		defaultValue: '1sat-cli-default',
-		placeholder: '1sat-cli-default',
-	})
-	if (isCancel(storageId)) {
-		cancel('Setup cancelled.')
-		process.exit(0)
-	}
+	// 4. Generate random storage identity key
+	const storageId = `1sat-cli-${randomBytes(8).toString('hex')}`
 
 	// 5. Optional: remote storage configuration
 	const useRemote = await confirm({
@@ -220,7 +213,7 @@ export async function handleInitCommand(
 	saveConfig({
 		...loadConfig(),
 		chain: chain as 'main' | 'test',
-		storageIdentityKey: storageId as string,
+		storageIdentityKey: storageId,
 		activeRemote,
 	})
 

package/src/commands/mcp-proxy.ts

@@ -61,33 +61,54 @@ async function handshake(key: PrivateKey): Promise<Session> {
 	if (!res.ok) throw new Error(`Handshake failed: HTTP ${res.status}`)
 
 	const data = await res.json()
-	if (data.messageType !== 'initialResponse') throw new Error(`Unexpected: ${data.messageType}`)
+	if (data.messageType !== 'initialResponse')
+		throw new Error(`Unexpected: ${data.messageType}`)
 
 	const serverNonce = data.nonce as string
 	const deriver = new KeyDeriver(key)
 	const serverPub = deriver.derivePublicKey(
-		AUTH_PROTOCOL_ID, `${serverNonce} ${clientNonce}`, data.identityKey as string, false,
+		AUTH_PROTOCOL_ID,
+		`${serverNonce} ${clientNonce}`,
+		data.identityKey as string,
+		false,
 	)
 
 	const clientNonceBytes = toArray(clientNonce, 'base64')
 	const serverNonceBytes = toArray(serverNonce, 'base64')
-	const msgHash = Hash.sha256(Array.from(new Uint8Array([...clientNonceBytes, ...serverNonceBytes])))
+	const msgHash = Hash.sha256(
+		Array.from(new Uint8Array([...clientNonceBytes, ...serverNonceBytes])),
+	)
 
 	const sig = Signature.fromDER(data.signature as string, 'hex')
-	if (!serverPub.verify(Array.from(msgHash), sig)) throw new Error('Server signature verification failed')
+	if (!serverPub.verify(Array.from(msgHash), sig))
+		throw new Error('Server signature verification failed')
 
 	const log = createLogger({ context: 'auth' })
-	log.set({ event: 'handshake_complete', serverIdentityKey: (data.identityKey as string).slice(0, 16) })
+	log.set({
+		event: 'handshake_complete',
+		serverIdentityKey: (data.identityKey as string).slice(0, 16),
+	})
 	log.emit()
 
-	return { serverIdentityKey: data.identityKey as string, serverNonce, clientKey: key }
+	return {
+		serverIdentityKey: data.identityKey as string,
+		serverNonce,
+		clientKey: key,
+	}
 }
 
-function signHeaders(session: Session, pathname: string): Record<string, string> {
+function signHeaders(
+	session: Session,
+	pathname: string,
+): Record<string, string> {
 	const { serverIdentityKey, serverNonce, clientKey: key } = session
 	const nonce = generateNonce()
 	const deriver = new KeyDeriver(key)
-	const derivedKey = deriver.derivePrivateKey(AUTH_PROTOCOL_ID, `${nonce} ${serverNonce}`, serverIdentityKey)
+	const derivedKey = deriver.derivePrivateKey(
+		AUTH_PROTOCOL_ID,
+		`${nonce} ${serverNonce}`,
+		serverIdentityKey,
+	)
 	const payload = new TextEncoder().encode(pathname)
 	const msgHash = Hash.sha256(Array.from(payload))
 	const sig = derivedKey.sign(Array.from(msgHash))
@@ -109,7 +130,9 @@ export async function handleMcpProxyCommand(): Promise<void> {
 	} catch {
 		startLog.set({ event: 'server_unreachable', url: MCP_URL })
 		startLog.emit()
-		process.stderr.write(`[1sat mcp-proxy] Server not reachable at ${MCP_URL} — is 1Sat wallet running?\n`)
+		process.stderr.write(
+			`[1sat mcp-proxy] Server not reachable at ${MCP_URL} — is 1Sat wallet running?\n`,
+		)
 		process.exit(1)
 	}
 
@@ -156,7 +179,11 @@ export async function handleMcpProxyCommand(): Promise<void> {
 					method = JSON.parse(line).method
 				} catch {}
 
-				const res = await fetch(`${MCP_URL}/mcp`, { method: 'POST', headers, body: line })
+				const res = await fetch(`${MCP_URL}/mcp`, {
+					method: 'POST',
+					headers,
+					body: line,
+				})
 
 				const sessionHeader = res.headers.get('mcp-session-id')
 				if (sessionHeader) mcpSessionId = sessionHeader
@@ -202,13 +229,19 @@ export async function handleMcpProxyCommand(): Promise<void> {
 				}
 			} catch (err) {
 				const msg = err instanceof Error ? err.message : String(err)
-				reqLog.set({ event: 'request_failed', requestNum: requestCount, error: msg })
+				reqLog.set({
+					event: 'request_failed',
+					requestNum: requestCount,
+					error: msg,
+				})
 				reqLog.emit()
-				process.stdout.write(`${JSON.stringify({
-					jsonrpc: '2.0',
-					error: { code: -32000, message: `MCP proxy error: ${msg}` },
-					id: null,
-				})}\n`)
+				process.stdout.write(
+					`${JSON.stringify({
+						jsonrpc: '2.0',
+						error: { code: -32000, message: `MCP proxy error: ${msg}` },
+						id: null,
+					})}\n`,
+				)
 			}
 		}
 	}

package/src/commands/remote.ts

@@ -81,6 +81,9 @@ async function remoteAdd(args: string[], opts: GlobalFlags): Promise<void> {
 		chain: opts.chain,
 	})
 
+	// Load config early — needed for storage identity key lookups
+	const config = loadConfig()
+
 	try {
 		// For backup-only, we use StorageClient via wallet-node
 		// biome-ignore lint/suspicious/noExplicitAny: StorageClient constructor not typed in wallet-toolbox
@@ -99,7 +102,6 @@ async function remoteAdd(args: string[], opts: GlobalFlags): Promise<void> {
 		await walletResult.storage.updateBackups()
 
 		// Persist to config — connectivity will be validated on next monitor run
-		const config = loadConfig()
 		const existing = config.backups ?? []
 		if (!existing.includes(url)) {
 			saveConfig({ ...config, backups: [...existing, url] })
@@ -131,9 +133,11 @@ async function remoteList(_args: string[], opts: GlobalFlags): Promise<void> {
 	})
 
 	try {
-		const backups = walletResult.storage.getBackupStores?.() ?? []
 		const config = loadConfig()
 
+		// Use config.backups for display (remoteClients only populated for active connections)
+		const backupUrls = config.backups ?? []
+
 		// Use config for active determination — WalletStorageManager internal state
 		// can be misleading (a backup may appear as active after addWalletStorageProvider)
 		const isRemoteActive = Boolean(config.activeRemote)
@@ -142,7 +146,7 @@ async function remoteList(_args: string[], opts: GlobalFlags): Promise<void> {
 			output(
 				{
 					activeStorage: isRemoteActive ? 'remote' : 'local',
-					backups: walletResult.storage.getAllStores?.() ?? [],
+					backups: backupUrls,
 					config: {
 						activeRemote: config.activeRemote ?? null,
 						backups: config.backups ?? [],
@@ -154,27 +158,19 @@ async function remoteList(_args: string[], opts: GlobalFlags): Promise<void> {
 		}
 
 		console.log()
-		console.log(`  ${bold('Active Storage:')} ${isRemoteActive ? 'remote' : 'local'}`)
+		console.log(
+			`  ${bold('Active Storage:')} ${isRemoteActive ? 'remote' : 'local'}`,
+		)
 		if (isRemoteActive) {
-			console.log(
-				`  ${bold('Active Remote:')} ${config.activeRemote}`,
-			)
+			console.log(`  ${bold('Active Remote:')} ${config.activeRemote}`)
 		}
 		console.log()
-		if (backups.length === 0 && !config.backups?.length) {
+		if (backupUrls.length === 0 && !config.backups?.length) {
 			console.log('  No remote storages configured')
 		} else {
 			console.log(`  ${bold('Backups:')}`)
-			const known = new Set(config.backups ?? [])
-			for (const b of backups) {
-				const isKnown = known.has(b)
-				console.log(`    ${isKnown ? '●' : '○'} ${b}`)
-			}
-			// Show configured but not yet connected
-			for (const url of config.backups ?? []) {
-				if (!backups.includes(url)) {
-					console.log(`    ? ${url} (not connected)`)
-				}
+			for (const url of backupUrls) {
+				console.log(`    ● ${url}`)
 			}
 		}
 		console.log()

package/src/commands/sweep.ts

@@ -106,9 +106,7 @@ async function sweepScan(args: string[], opts: GlobalFlags): Promise<void> {
 			}
 		}
 
-		console.log(
-			`\n  ${formatLabel('RUN Tokens:')} ${result.run.length}`,
-		)
+		console.log(`\n  ${formatLabel('RUN Tokens:')} ${result.run.length}`)
 		if (result.run.length > 0) {
 			const runSats = result.run.reduce((sum, r) => sum + (r.satoshis ?? 0), 0)
 			console.log(
@@ -161,11 +159,15 @@ async function sweepImport(args: string[], opts: GlobalFlags): Promise<void> {
 
 		const hasFunding = scan.funding.length > 0
 		const hasOrdinals = scan.ordinals.length > 0
-		const hasTokens = scan.bsv21Tokens.some((t) => t.isActive && t.outputs.length > 0)
+		const hasTokens = scan.bsv21Tokens.some(
+			(t) => t.isActive && t.outputs.length > 0,
+		)
 
 		if (!hasFunding && !hasOrdinals && !hasTokens) {
 			if (scan.run.length > 0) {
-				fatal(`No sweepable UTXOs found at ${address} (${scan.run.length} RUN token output(s) excluded)`)
+				fatal(
+					`No sweepable UTXOs found at ${address} (${scan.run.length} RUN token output(s) excluded)`,
+				)
 			}
 			fatal(`No UTXOs found at ${address}`)
 		}

package/src/commands/wallet.ts

@@ -1,11 +1,12 @@
 /**
  * Wallet commands - balance, address, send, send-all, info.
+ * BRC-100 interface commands - list-outputs, relinquish-output, list-actions, etc.
  */
 
 import { deriveDepositAddresses, sendAllBsv, sendBsv } from '@1sat/actions'
 import { confirm, isCancel } from '@clack/prompts'
 import type { GlobalFlags } from '../args'
-import { extractFlag } from '../args'
+import { extractFlag, extractFlags } from '../args'
 import { loadContext } from '../context'
 import { printCommandHelp } from '../help'
 import { loadKey, resolvePassword } from '../keys'
@@ -28,6 +29,22 @@ export async function handleWalletCommand(
 			return walletSendAll(rest, opts)
 		case 'info':
 			return walletInfo(rest, opts)
+		case 'list-outputs':
+			return walletListOutputs(rest, opts)
+		case 'relinquish-output':
+			return walletRelinquishOutput(rest, opts)
+		case 'list-actions':
+			return walletListActions(rest, opts)
+		case 'create-action':
+			return walletCreateAction(rest, opts)
+		case 'sign-action':
+			return walletSignAction(rest, opts)
+		case 'abort-action':
+			return walletAbortAction(rest, opts)
+		case 'list-certificates':
+			return walletListCertificates(rest, opts)
+		case 'relinquish-certificate':
+			return walletRelinquishCertificate(rest, opts)
 		default:
 			printCommandHelp('wallet', {
 				balance: 'Show wallet balance in satoshis',
@@ -35,6 +52,17 @@ export async function handleWalletCommand(
 				send: 'Send BSV to an address (--to <addr> --sats <amount>)',
 				'send-all': 'Send all BSV to an address (--to <addr>)',
 				info: 'Show wallet info (address, balance, network)',
+				'list-outputs':
+					'List wallet outputs (--basket <name> [--tags <t1,t2>] [--limit N] [--include-tags] [--include <val>])',
+				'relinquish-output':
+					'Remove output from basket (--basket <name> --output <txid.vout>)',
+				'list-actions': 'List wallet actions [--labels <l1,l2>] [--limit N]',
+				'create-action': 'Create action (JSON args)',
+				'sign-action': 'Sign action (JSON args)',
+				'abort-action': 'Abort action (--reference <ref>)',
+				'list-certificates': 'List certificates',
+				'relinquish-certificate':
+					'Relinquish certificate (--type <t> --serialNumber <s> --certifier <c>)',
 			})
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
@@ -216,3 +244,285 @@ async function walletInfo(_args: string[], opts: GlobalFlags): Promise<void> {
 		await destroy()
 	}
 }
+
+// BRC-100 Interface Commands
+
+async function walletListOutputs(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const basket = extractFlag(args, '--basket')
+	if (!basket) fatal('Missing required --basket <name>')
+
+	const tags = extractFlags(args, '--tags')
+	const limitStr = extractFlag(args, '--limit')
+	const limit = limitStr ? Number.parseInt(limitStr, 10) : 10
+	if (!Number.isFinite(limit) || limit < 1 || limit > 10000) {
+		fatal('--limit must be between 1 and 10000')
+	}
+
+	const includeTags = args.includes('--include-tags')
+	const include = extractFlag(args, '--include')
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const listArgs: Parameters<typeof ctx.wallet.listOutputs>[0] = {
+			basket,
+			limit,
+			includeTags,
+			include,
+		}
+		if (tags.length > 0) {
+			listArgs.tags = tags
+		}
+
+		const result = await ctx.wallet.listOutputs(listArgs)
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			console.log(
+				`\n${result.totalOutputs} total outputs in basket '${basket}':\n`,
+			)
+			for (const out of result.outputs) {
+				const tags = out.tags?.join(', ') || 'none'
+				console.log(`  ${out.outpoint} | ${out.satoshis} sats | tags: ${tags}`)
+			}
+			console.log()
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletRelinquishOutput(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const basket = extractFlag(args, '--basket')
+	const outpoint = extractFlag(args, '--output')
+
+	if (!basket) fatal('Missing required --basket <name>')
+	if (!outpoint) fatal('Missing required --output <txid.vout>')
+
+	// Validate output format (txid.vout)
+	if (!outpoint.includes('.') || outpoint.split('.').length !== 2) {
+		fatal('Invalid --output format. Expected: txid.vout (e.g., abc123...0)')
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.relinquishOutput({
+			basket,
+			output: outpoint,
+		})
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			output({ relinquished: true, basket, output: outpoint }, opts)
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletListActions(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const labels = extractFlags(args, '--labels')
+	const limitStr = extractFlag(args, '--limit')
+	const limit = limitStr ? Number.parseInt(limitStr, 10) : 10
+	if (!Number.isFinite(limit) || limit < 1 || limit > 10000) {
+		fatal('--limit must be between 1 and 10000')
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const listArgs: Parameters<typeof ctx.wallet.listActions>[0] = {
+			labels: labels.length > 0 ? labels : ['*'], // Default to all labels if none specified
+			limit,
+		}
+
+		const result = await ctx.wallet.listActions(listArgs)
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			console.log(`\n${result.totalActions} total actions:\n`)
+			for (const action of result.actions) {
+				console.log(`  ${action.txid || 'pending'} | status: ${action.status}`)
+			}
+			console.log()
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletCreateAction(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const jsonInput = args[0]
+
+	if (!jsonInput)
+		fatal("Missing JSON arguments. Usage: wallet create-action '{...}'")
+
+	let actionArgs: Parameters<typeof ctx.wallet.createAction>[0]
+	try {
+		actionArgs = JSON.parse(jsonInput)
+	} catch {
+		fatal(`Invalid JSON: ${jsonInput}`)
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.createAction(actionArgs)
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletSignAction(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const jsonInput = args[0]
+
+	if (!jsonInput)
+		fatal("Missing JSON arguments. Usage: wallet sign-action '{...}'")
+
+	let signArgs: Parameters<typeof ctx.wallet.signAction>[0]
+	try {
+		signArgs = JSON.parse(jsonInput)
+	} catch {
+		fatal(`Invalid JSON: ${jsonInput}`)
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.signAction(signArgs)
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletAbortAction(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const reference = extractFlag(args, '--reference')
+
+	if (!reference) fatal('Missing required --reference <ref>')
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.abortAction({ reference })
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletListCertificates(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const certifiers = extractFlags(args, '--certifiers')
+	const types = extractFlags(args, '--types')
+	const limitStr = extractFlag(args, '--limit')
+	const limit = limitStr ? Number.parseInt(limitStr, 10) : 10
+
+	if (!Number.isFinite(limit) || limit < 1 || limit > 10000) {
+		fatal('--limit must be between 1 and 10000')
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const listArgs: Parameters<typeof ctx.wallet.listCertificates>[0] = {
+			certifiers: certifiers.length > 0 ? certifiers : [],
+			types: types.length > 0 ? types : [],
+			limit,
+		}
+
+		const result = await ctx.wallet.listCertificates(listArgs)
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			console.log(`\n${result.totalCertificates} total certificates:\n`)
+			for (const cert of result.certificates) {
+				console.log(`  ${cert.type} | ${cert.serialNumber} | ${cert.certifier}`)
+			}
+			console.log()
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletRelinquishCertificate(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const type = extractFlag(args, '--type')
+	const serialNumber = extractFlag(args, '--serialNumber')
+	const certifier = extractFlag(args, '--certifier')
+
+	if (!type) fatal('Missing required --type <type>')
+	if (!serialNumber) fatal('Missing required --serialNumber <serial>')
+	if (!certifier) fatal('Missing required --certifier <certifier>')
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.relinquishCertificate({
+			type,
+			serialNumber,
+			certifier,
+		})
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			output({ relinquished: true, type, serialNumber, certifier }, opts)
+		}
+	} finally {
+		await destroy()
+	}
+}

package/src/context.ts

@@ -38,7 +38,20 @@ async function runMonitorIfStale(
 	const intervalMs = intervalMinutes * 60 * 1000
 
 	if (elapsed >= intervalMs) {
-		await walletResult.monitor.runOnce()
+		const originalLog = console.log
+		const originalInfo = console.info
+		const originalWarn = console.warn
+		console.log = () => {}
+		console.info = () => {}
+		console.warn = () => {}
+
+		try {
+			await walletResult.monitor.runOnce()
+		} finally {
+			console.log = originalLog
+			console.info = originalInfo
+			console.warn = originalWarn
+		}
 		saveMonitorState({ lastMonitorRun: Date.now() })
 	}
 }

package/src/help.ts

@@ -47,6 +47,22 @@ ${bold('Wallet:')}
   ${cyan('wallet send-all')}          Send all BSV to an address
   ${cyan('wallet info')}              Show wallet info
 
+${bold('Wallet (BRC-100 Interface):')}
+  ${cyan('wallet list-outputs')}      List outputs in basket
+                               ${dim('--basket <name> [--tags <t1,t2>] [--limit N]')}
+  ${cyan('wallet relinquish-output')} Remove output from basket
+                               ${dim('--basket <name> --output <txid.vout>')}
+  ${cyan('wallet list-actions')}      List wallet actions
+                               ${dim('[--labels <l1,l2>] [--limit N]')}
+  ${cyan('wallet create-action')}     Create raw action (JSON args)
+  ${cyan('wallet sign-action')}       Sign raw action (JSON args)
+  ${cyan('wallet abort-action')}      Abort pending action
+                               ${dim('--reference <ref>')}
+  ${cyan('wallet list-certificates')} List certificates
+                               ${dim('[--certifiers <c1,c2>] [--types <t1,t2>] [--limit N]')}
+  ${cyan('wallet relinquish-certificate')} Relinquish certificate
+                               ${dim('--type <t> --serialNumber <s> --certifier <c>')}
+
 ${bold('Ordinals:')}
   ${cyan('ordinals list')}            List owned ordinals
   ${cyan('ordinals mint')}            Mint a new ordinal inscription
@@ -69,6 +85,7 @@ ${bold('Locks:')}
 
 ${bold('Identity (BAP):')}
   ${cyan('identity create')}          Create a new BAP identity
+  ${cyan('identity update-profile')}  Update BAP identity profile (--profile <json>)
   ${cyan('identity info')}            Show identity information
   ${cyan('identity sign')}            Sign a message with identity key
   ${cyan('identity verify')}          Verify a signed message