@1sat/cli 0.0.51 → 0.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1sat/cli",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "description": "CLI for 1Sat Ordinals SDK",
   "type": "module",
   "main": "./src/cli.ts",
@@ -25,11 +25,12 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@1sat/actions": "0.0.115",
-    "@1sat/client": "0.0.26",
-    "@1sat/types": "0.0.18",
-    "@1sat/wallet-node": "0.0.42",
-    "@1sat/wallet-server": "0.0.12",
+    "@1sat/actions": "0.0.117",
+    "@1sat/client": "0.0.27",
+    "@1sat/knex-bun-sqlite": "0.0.1",
+    "@1sat/types": "0.0.19",
+    "@1sat/wallet-node": "0.0.43",
+    "@1sat/wallet-server": "0.0.13",
     "@bsv/sdk": "^2.0.13",
     "@bsv/wallet-toolbox": "npm:@bopen-io/wallet-toolbox@2.1.21-parity-fix.2",
     "chalk": "^5.0.0",
@@ -38,6 +39,7 @@
     "dotenv": "^17.0.0",
     "evlog": "^2.10.0",
     "knex": "^3.1.0",
+    "@bopen-io/messagebox-server": "^1.1.5",
     "pg": "^8.11.3"
   },
   "devDependencies": {

package/scripts/resubmit-bsv21-discovery.ts

@@ -0,0 +1,33 @@
+/**
+ * One-off recovery script: re-submit a BSV21 deploy tx to the discovery
+ * overlay topic (tm_bsv21).
+ *
+ * Use when a deploy was broadcast on-chain but didn't reach the overlay
+ * (e.g. previous URL bug, network blip, server downtime).
+ *
+ * Usage: bun run scripts/resubmit-bsv21-discovery.ts <txid>
+ */
+
+import { OneSatServices } from '@1sat/client'
+
+const txid = process.argv[2]
+if (!txid || !/^[0-9a-f]{64}$/i.test(txid)) {
+	console.error(
+		'Usage: bun run scripts/resubmit-bsv21-discovery.ts <txid>\n' +
+			'  txid must be a 64-char hex string',
+	)
+	process.exit(1)
+}
+
+const services = new OneSatServices('main')
+
+console.log(`Fetching BEEF for ${txid}...`)
+const beef = await services.getBeefForTxid(txid)
+console.log(`  beef has ${beef.txs.length} txs and ${beef.bumps.length} bumps`)
+
+const atomicBeef = beef.toBinaryAtomic(txid)
+console.log(`  atomic BEEF size: ${atomicBeef.length} bytes`)
+
+console.log('Submitting to tm_bsv21 discovery topic...')
+const result = await services.overlay.submitBsv21Discovery(atomicBeef)
+console.log('Result:', result)

package/src/cli.ts

@@ -22,7 +22,7 @@ import { handleSweepCommand } from './commands/sweep'
 import { handleTokensCommand } from './commands/tokens'
 import { handleTxCommand } from './commands/tx'
 import { handleWalletCommand } from './commands/wallet'
-import { printHelp, printVersion } from './help'
+import { getCommand, printCommandHelp, printHelp, printVersion } from './help'
 import { formatError } from './output'
 
 const rawArgs = process.argv.slice(2)
@@ -37,8 +37,17 @@ async function main(): Promise<void> {
 
 	const [command, ...rest] = flags.rest
 
-	if (!command || flags.help) {
-		printHelp()
+	if (!command) {
+		printHelp(flags.json)
+		process.exit(0)
+	}
+
+	if (flags.help) {
+		if (getCommand(command)) {
+			printCommandHelp(command, flags.json)
+		} else {
+			printHelp(flags.json)
+		}
 		process.exit(0)
 	}
 
@@ -104,12 +113,12 @@ async function main(): Promise<void> {
 			break
 
 		case 'help':
-			printHelp()
+			printHelp(flags.json)
 			break
 
 		default:
 			console.error(formatError(`Unknown command: ${command}`))
-			printHelp()
+			printHelp(flags.json)
 			process.exit(1)
 	}
 }

package/src/commands/config.ts

@@ -42,12 +42,7 @@ export async function handleConfigCommand(
 		case 'path':
 			return configPath(opts)
 		default:
-			printCommandHelp('config', {
-				show: 'Display current configuration',
-				set: 'Set a config value (e.g. 1sat config set chain test)',
-				unset: 'Remove a configuration key (e.g. 1sat config unset chain)',
-				path: 'Print config directory path',
-			})
+			printCommandHelp('config', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}

package/src/commands/identity.ts

@@ -30,14 +30,7 @@ export async function handleIdentityCommand(
 		case 'verify':
 			return identityVerify(rest, opts)
 		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> [--encoding <utf8|hex|base64>])',
-				verify:
-					'Verify a signed message (--message <text> --sig <sig> --address <addr>)',
-			})
+			printCommandHelp('identity', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}

package/src/commands/locks.ts

@@ -25,11 +25,7 @@ export async function handleLocksCommand(
 		case 'unlock':
 			return locksUnlock(rest, opts)
 		default:
-			printCommandHelp('locks', {
-				info: 'Show lock information and maturity status',
-				lock: 'Time-lock BSV (--sats <amount> --blocks <n>)',
-				unlock: 'Unlock matured BSV locks',
-			})
+			printCommandHelp('locks', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}

package/src/commands/opns.ts

@@ -32,11 +32,7 @@ export async function handleOpnsCommand(
 		case 'lookup':
 			return opnsLookup(rest, opts)
 		default:
-			printCommandHelp('opns', {
-				register: 'Register identity on an OpNS name (--outpoint <op>)',
-				deregister: 'Deregister identity from an OpNS name (--outpoint <op>)',
-				lookup: 'List OpNS names from wallet',
-			})
+			printCommandHelp('opns', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}

package/src/commands/ordinals.ts

@@ -46,15 +46,7 @@ export async function handleOrdinalsCommand(
 		case 'burn':
 			return ordinalsBurn(rest, opts)
 		default:
-			printCommandHelp('ordinals', {
-				list: 'List owned ordinals/inscriptions',
-				mint: 'Mint a new ordinal inscription (--file <path> [--type <mime>] [--map <json>] [--sign-with-bap])',
-				transfer: 'Transfer an ordinal (--outpoint <op> --to <addr>)',
-				sell: 'List an ordinal for sale (--outpoint <op> --price <sats>)',
-				cancel: 'Cancel an ordinal listing (--outpoint <op>)',
-				buy: 'Purchase a listed ordinal (--outpoint <op>)',
-				burn: 'Burn ordinals permanently (--outpoints <op1,op2,...>)',
-			})
+			printCommandHelp('ordinals', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}

package/src/commands/remote.ts

@@ -38,17 +38,7 @@ export async function handleRemoteCommand(
 		case 'topup':
 			return remoteTopup(rest, opts)
 		default:
-			printCommandHelp('remote', {
-				add: 'Add a remote storage as backup (1sat remote add <url>)',
-				list: 'List all configured remotes and their status',
-				delete:
-					'Remove a remote from the backup list (1sat remote delete <url>)',
-				'set-active':
-					'Switch active storage (1sat remote set-active <url | local>)',
-				status:
-					'Fetch GET /account/status from a remote (1sat remote status [url])',
-				topup: 'Buy capacity on a remote (1sat remote topup [url] [--units N])',
-			})
+			printCommandHelp('remote', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}

package/src/commands/serve-messagebox.ts

@@ -0,0 +1,233 @@
+/**
+ * `1sat serve messagebox` — launch the BSV message-box server using the
+ * CLI's wallet identity.
+ *
+ * Storage mirrors the wallet's choice: SQLite via `@1sat/knex-bun-sqlite`
+ * when wallet storage is `bun-sqlite`, Postgres when wallet storage is `pg`.
+ *
+ * messagebox-server boots itself as a side effect of `import` once env vars
+ * are populated, so this handler:
+ *   1. Reads CLI config + private key
+ *   2. Composes env (SERVER_PRIVATE_KEY, PORT, KNEX_DB_*, WALLET_STORAGE_URL, …)
+ *   3. Dynamically imports `messagebox-server`
+ *   4. Awaits SIGINT/SIGTERM, then closes the HTTP and WebSocket servers
+ */
+
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { PrivateKey } from '@bsv/sdk'
+import type { GlobalFlags } from '../args'
+import {
+	type ServerMessageboxConfig,
+	type ServerStorageConfig,
+	ensureDataDir,
+	loadConfig,
+} from '../config'
+import { loadKey } from '../keys'
+import { fatal } from '../output'
+
+const DEFAULT_MESSAGEBOX_PORT = 8771
+const DEFAULT_WALLET_HOST = '127.0.0.1'
+const DEFAULT_WALLET_PORT = 8100
+const DEFAULT_PG_SCHEMA = 'messagebox'
+
+interface ResolvedMessagebox {
+	chain: 'main' | 'test'
+	port: number
+	websockets: boolean
+	walletStorageUrl: string
+	knexClient: string
+	knexConnection: Record<string, unknown>
+	identityHex: string
+	identityPub: string
+}
+
+interface MessageboxModule {
+	http: { close(cb?: (err?: Error) => void): void }
+	io: { close(cb?: () => void): void } | null
+}
+
+export interface MessageboxStoppable {
+	stop(): Promise<void>
+}
+
+export async function startMessagebox(
+	opts: GlobalFlags,
+): Promise<MessageboxStoppable> {
+	const resolved = await resolveMessagebox(opts)
+	applyEnv(resolved)
+
+	console.log(`[messagebox] starting on 0.0.0.0:${resolved.port}`)
+	console.log(`[messagebox] identity: ${resolved.identityPub.slice(0, 16)}…`)
+	console.log(`[messagebox] storage: ${resolved.knexClient}`)
+	console.log(`[messagebox] wallet:  ${resolved.walletStorageUrl}`)
+	console.log(
+		`[messagebox] websockets: ${resolved.websockets ? 'enabled' : 'disabled'}`,
+	)
+
+	// When the env-driven knexfile resolves to 'sqlite3', swap in our
+	// bun:sqlite-backed Knex dialect class and rewrite the migrations
+	// directory to an absolute path. ESM singleton semantics mean
+	// messagebox-server's app.ts gets the same (mutated) module instance
+	// when it imports the knexfile next.
+	if (resolved.knexClient === 'sqlite3') {
+		const knexfileUrl = import.meta.resolve(
+			'@bopen-io/messagebox-server/out/knexfile.js',
+		)
+		const migrationsDir = fileURLToPath(new URL('src/migrations/', knexfileUrl))
+		const [knexfile, dialect] = await Promise.all([
+			import('@bopen-io/messagebox-server/out/knexfile.js') as Promise<{
+				default: Record<
+					string,
+					{ client: unknown; migrations?: { directory: string } }
+				>
+			}>,
+			import('@1sat/knex-bun-sqlite'),
+		])
+		const Client = dialect.default
+		for (const env of ['development', 'staging', 'production']) {
+			const cfg = knexfile.default[env]
+			if (!cfg) continue
+			cfg.client = Client
+			if (cfg.migrations) cfg.migrations.directory = migrationsDir
+		}
+	}
+
+	// messagebox-server boots itself when its index module is loaded.
+	const mbox = (await import(
+		'@bopen-io/messagebox-server'
+	)) as unknown as MessageboxModule
+
+	return {
+		async stop() {
+			await new Promise<void>((resolve) => {
+				try {
+					mbox.http.close(() => resolve())
+				} catch {
+					resolve()
+				}
+			})
+			if (mbox.io) {
+				await new Promise<void>((resolve) => {
+					try {
+						mbox.io?.close(() => resolve())
+					} catch {
+						resolve()
+					}
+				})
+			}
+		},
+	}
+}
+
+async function resolveMessagebox(
+	opts: GlobalFlags,
+): Promise<ResolvedMessagebox> {
+	const config = loadConfig()
+	const server = config.server ?? {}
+	const messagebox: ServerMessageboxConfig = server.messagebox ?? {}
+
+	const chain = opts.chain ?? config.chain ?? 'main'
+	const port = resolvePort(messagebox.port)
+	const websockets = messagebox.websockets !== false
+
+	let privateKey: PrivateKey
+	try {
+		privateKey = await loadKey()
+	} catch (err) {
+		fatal((err as Error).message)
+	}
+
+	const identityHex = privateKey.toString()
+	const identityPub = privateKey.toPublicKey().toString()
+
+	const walletHost = server.host ?? DEFAULT_WALLET_HOST
+	const walletPort = server.port ?? DEFAULT_WALLET_PORT
+	const walletStorageUrl =
+		messagebox.walletStorageUrl ?? `http://${walletHost}:${walletPort}/`
+
+	const { knexClient, knexConnection } = resolveStorage(
+		server.storage ?? { provider: 'bun-sqlite' },
+		messagebox,
+		chain,
+	)
+
+	return {
+		chain,
+		port,
+		websockets,
+		walletStorageUrl,
+		knexClient,
+		knexConnection,
+		identityHex,
+		identityPub,
+	}
+}
+
+function resolvePort(configured: number | undefined): number {
+	const fromEnv = process.env.ONESAT_MESSAGEBOX_PORT
+	if (fromEnv && fromEnv.trim() !== '') {
+		const parsed = Number(fromEnv)
+		if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 65535) {
+			fatal(
+				`ONESAT_MESSAGEBOX_PORT must be a valid port number, got: ${fromEnv}`,
+			)
+		}
+		return parsed
+	}
+	return configured ?? DEFAULT_MESSAGEBOX_PORT
+}
+
+function resolveStorage(
+	storage: ServerStorageConfig,
+	messagebox: ServerMessageboxConfig,
+	chain: 'main' | 'test',
+): { knexClient: string; knexConnection: Record<string, unknown> } {
+	if (storage.provider === 'bun-sqlite') {
+		const dataDir = ensureDataDir()
+		const filename =
+			messagebox.dbPath ?? join(dataDir, `messagebox-${chain}.db`)
+		// We pass `sqlite3` to satisfy the env-driven knexfile's alias check;
+		// the actual Client class is swapped in via ESM module mutation
+		// just before messagebox-server is imported.
+		return {
+			knexClient: 'sqlite3',
+			knexConnection: { filename },
+		}
+	}
+
+	if (storage.provider === 'pg') {
+		const schema = messagebox.pgSchema ?? DEFAULT_PG_SCHEMA
+		return {
+			knexClient: 'pg',
+			knexConnection: {
+				connectionString: storage.dbUrl,
+				searchPath: [schema, 'public'],
+			},
+		}
+	}
+
+	fatal(
+		`server.storage.provider '${(storage as { provider: string }).provider}' is not supported by 'serve messagebox'.`,
+	)
+}
+
+function applyEnv(resolved: ResolvedMessagebox): void {
+	// messagebox-server reads env at module-load time, so we set everything
+	// before the dynamic import. dotenv.config() inside messagebox-server
+	// does not overwrite values already set on process.env.
+	process.env.SERVER_PRIVATE_KEY = resolved.identityHex
+	process.env.BSV_NETWORK = resolved.chain === 'main' ? 'mainnet' : 'testnet'
+	process.env.PORT = String(resolved.port)
+	// messagebox-server's index.ts forces HTTP_PORT=3000 when NODE_ENV
+	// is anything other than 'development', ignoring our PORT entirely.
+	// Use 'development' so PORT is honored.
+	process.env.NODE_ENV = 'development'
+	process.env.ENABLE_WEBSOCKETS = resolved.websockets ? 'true' : 'false'
+	process.env.WALLET_STORAGE_URL = resolved.walletStorageUrl
+	process.env.KNEX_DB_CLIENT = resolved.knexClient
+	process.env.KNEX_DB_CONNECTION = JSON.stringify(resolved.knexConnection)
+	if (process.env.ENABLE_FIREBASE === undefined) {
+		process.env.ENABLE_FIREBASE = 'false'
+	}
+}

package/src/commands/serve.ts

@@ -1,9 +1,10 @@
 /**
  * `1sat serve` command — launch wallet server and/or monitor.
  *
- *   1sat serve             Wallet server + monitor daemon
- *   1sat serve wallet      Wallet server only
- *   1sat serve monitor     Monitor daemon only
+ *   1sat serve              Wallet server + monitor daemon
+ *   1sat serve wallet       Wallet server only
+ *   1sat serve monitor      Monitor daemon only
+ *   1sat serve messagebox   BSV message-box server
  *
  * The server wraps the same wallet instance the CLI uses. Storage, active
  * remote, and backups all come from `~/.1sat/cli/config.json` via the same
@@ -13,6 +14,7 @@
  *   1sat config set server.port 8100
  *   1sat config set server.host 0.0.0.0
  *   1sat config set server.accounts.enabled true
+ *   1sat config set server.messagebox.port 8771
  */
 
 import { join } from 'node:path'
@@ -23,6 +25,7 @@ import {
 } from '@1sat/wallet-node'
 import { createWalletServer } from '@1sat/wallet-server'
 import type { PrivateKey } from '@bsv/sdk'
+import { initLogger } from 'evlog'
 import type { GlobalFlags } from '../args'
 import {
 	type ServerAccountsConfig,
@@ -34,6 +37,7 @@ import { printCommandHelp } from '../help'
 import { loadKey } from '../keys'
 import { clearMonitorPid, writeMonitorPid } from '../monitor-lock'
 import { fatal } from '../output'
+import { startMessagebox } from './serve-messagebox'
 
 const DEFAULT_HOST = '127.0.0.1'
 const DEFAULT_PORT = 8100
@@ -44,7 +48,7 @@ const DEFAULT_SATS_PER_UNIT = 1_000_000
 const DEFAULT_DURATION_BLOCKS = 4383
 const DEFAULT_STORAGE_IDENTITY_KEY = '1sat-cli-default'
 
-type ServeMode = 'all' | 'wallet' | 'monitor'
+type ServeMode = 'all' | 'wallet' | 'monitor' | 'messagebox'
 
 interface ResolvedServe {
 	chain: 'main' | 'test'
@@ -78,15 +82,27 @@ export async function handleServeCommand(
 	const mode = resolveMode(subcommand)
 
 	if (mode === null) {
-		printCommandHelp('serve', {
-			'(no subcommand)': 'Wallet server plus monitor daemon',
-			wallet: 'Wallet server only',
-			monitor: 'Monitor daemon only',
-		})
+		printCommandHelp('serve', opts.json)
 		if (subcommand && subcommand !== 'help') process.exit(1)
 		return
 	}
 
+	initLogger({ env: { service: `1sat-cli-serve-${mode}` } })
+
+	if (mode === 'messagebox') {
+		const handle = await startMessagebox(opts)
+		try {
+			await waitForShutdown()
+		} finally {
+			try {
+				await handle.stop()
+			} catch (err) {
+				console.error(`Error during shutdown: ${(err as Error).message}`)
+			}
+		}
+		return
+	}
+
 	const resolved = await resolveServe(opts)
 	const handles: Stoppable[] = []
 
@@ -109,6 +125,7 @@ function resolveMode(subcommand: string | undefined): ServeMode | null {
 	switch (subcommand) {
 		case 'wallet':
 		case 'monitor':
+		case 'messagebox':
 			return subcommand
 		default:
 			return null

package/src/commands/social.ts

@@ -22,9 +22,7 @@ export async function handleSocialCommand(
 		case 'post':
 			return socialPost(rest, opts)
 		default:
-			printCommandHelp('social', {
-				post: 'Create an on-chain social post (--content <text> [--app <name>] [--content-type <text/plain|text/markdown>] [--tags <t1,t2>])',
-			})
+			printCommandHelp('social', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}

package/src/commands/sweep.ts

@@ -32,10 +32,7 @@ export async function handleSweepCommand(
 		case 'import':
 			return sweepImport(rest, opts)
 		default:
-			printCommandHelp('sweep', {
-				scan: 'Scan an address for UTXOs (--wif <key>)',
-				import: 'Import UTXOs into wallet (--wif <key>)',
-			})
+			printCommandHelp('sweep', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}