@1sat/cli 0.0.83 → 0.0.86

package/package.json

@@ -1,49 +1,50 @@
 {
-	"name": "@1sat/cli",
-	"version": "0.0.83",
-	"description": "CLI for 1Sat Ordinals SDK",
-	"type": "module",
-	"main": "./src/cli.ts",
-	"bin": {
-		"1sat": "./src/cli.ts"
-	},
-	"files": [
-		"src",
-		"scripts"
-	],
-	"scripts": {
-		"preinstall": "node scripts/check-bun.cjs",
-		"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 --external mariadb --external 'mariadb/*'",
-		"dev": "bun run src/cli.ts",
-		"lint": "biome check src",
-		"test": "bun test"
-	},
-	"keywords": [
-		"1sat",
-		"bsv",
-		"ordinals",
-		"cli"
-	],
-	"license": "MIT",
-	"dependencies": {
-		"@1sat/actions": "0.0.187",
-		"@1sat/client": "0.0.43",
-		"@1sat/types": "0.0.34",
-		"@1sat/wallet-node": "0.0.60",
-		"@1sat/wallet-server": "0.0.29",
-		"@bsv/sdk": "^2.1.6",
-		"@bsv/wallet-toolbox": "2.1.24",
-		"chalk": "^5.0.0",
-		"@clack/prompts": "^0.8.0",
-		"bitcoin-backup": "^0.0.11",
-		"dotenv": "^17.0.0",
-		"evlog": "^2.10.0",
-		"knex": "^3.1.0",
-		"@bopen-io/messagebox-server": "^1.1.5",
-		"pg": "^8.11.3"
-	},
-	"devDependencies": {
-		"@types/bun": "^1.3.9",
-		"typescript": "^5.9.3"
-	}
+  "name": "@1sat/cli",
+  "version": "0.0.86",
+  "description": "CLI for 1Sat Ordinals SDK",
+  "type": "module",
+  "main": "./src/cli.ts",
+  "bin": {
+    "1sat": "./src/cli.ts"
+  },
+  "files": [
+    "src",
+    "scripts"
+  ],
+  "scripts": {
+    "preinstall": "node scripts/check-bun.cjs",
+    "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 --external mariadb --external 'mariadb/*'",
+    "dev": "bun run src/cli.ts",
+    "lint": "biome check src",
+    "test": "bun test"
+  },
+  "keywords": [
+    "1sat",
+    "bsv",
+    "ordinals",
+    "cli"
+  ],
+  "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.32",
+    "@bsv/sdk": "^2.1.6",
+    "@bsv/wallet-toolbox": "2.1.24",
+    "chalk": "^5.0.0",
+    "@clack/prompts": "^0.8.0",
+    "bitcoin-backup": "^0.0.11",
+    "dotenv": "^17.0.0",
+    "evlog": "^2.10.0",
+    "knex": "^3.1.0",
+    "@bopen-io/messagebox-server": "^1.3.2",
+    "pg": "^8.11.3",
+    "sqlite3": "^6.0.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.9",
+    "typescript": "^5.9.3"
+  }
 }

package/src/commands/serve.ts

@@ -1,10 +1,9 @@
 /**
- * `1sat serve` command — launch wallet server and/or monitor.
+ * `1sat serve` command — launch the unified host server and/or monitor.
  *
- *   1sat serve              Wallet server + monitor daemon
- *   1sat serve wallet       Wallet server only
+ *   1sat serve              Host server (storage + hosting + paymail + messagebox) + monitor
+ *   1sat serve wallet       Wallet storage 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
@@ -14,7 +13,9 @@
  *   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
+ *   1sat config set server.hosting.enabled true
+ *   1sat config set server.paymail.baseUrl https://1sat.app
+ *   1sat config set server.monitor.enabled false
  */
 
 import { join } from 'node:path'
@@ -23,12 +24,19 @@ import {
 	type NodeWalletStorageConfig,
 	createNodeWallet,
 } from '@1sat/wallet-node'
-import { createWalletServer } from '@1sat/wallet-server'
+import {
+	KnexPendingStore,
+	createHostServer,
+	createWalletServer,
+} from '@1sat/wallet-server'
 import type { PrivateKey } from '@bsv/sdk'
 import { initLogger } from 'evlog'
+import knexLib from 'knex'
 import type { GlobalFlags } from '../args'
 import {
+	type RepricerConfig,
 	type ServerAccountsConfig,
+	type ServerMessageboxConfig,
 	type ServerStorageConfig,
 	loadConfig,
 	setConfigPath,
@@ -39,11 +47,11 @@ import { loadKey } from '../keys'
 import { clearMonitorPid, writeMonitorPid } from '../monitor-lock'
 import { fatal } from '../output'
 import {
+	type RepriceTarget,
 	buildPriceUpdateTask,
 	createAccountsConfigLoader,
 	resolveRateProvider,
 } from '../repricer'
-import { startMessagebox } from './serve-messagebox'
 
 const DEFAULT_HOST = '127.0.0.1'
 const DEFAULT_PORT = 8100
@@ -51,10 +59,11 @@ const DEFAULT_ONESAT_URL = 'https://api.1sat.app/1sat'
 const DEFAULT_BASELINE_BYTES = 1024 * 1024 * 1024 // 1 GB
 const DEFAULT_PURCHASE_UNIT_BYTES = 1_073_741_824 // 1 GB chunks for production
 const DEFAULT_SATS_PER_UNIT = 1_000_000
+const DEFAULT_HOSTING_PRICE_SATS = 10_000
 const DEFAULT_DURATION_BLOCKS = 4383
 const DEFAULT_STORAGE_IDENTITY_KEY = '1sat-cli-default'
 
-type ServeMode = 'all' | 'wallet' | 'monitor' | 'messagebox'
+type ServeMode = 'all' | 'wallet' | 'monitor'
 
 interface ResolvedServe {
 	chain: 'main' | 'test'
@@ -68,6 +77,8 @@ interface ResolvedServe {
 	activeRemote?: string
 	backups?: string[]
 	accounts: ResolvedAccounts
+	repricer?: RepricerConfig
+	monitorEnabled: boolean
 	privateKey: PrivateKey
 }
 
@@ -78,14 +89,7 @@ interface ResolvedAccounts {
 	satsPerUnit: number
 	durationBlocks: number
 	freeIdentityKeys: string[]
-	repricer?: {
-		enabled?: boolean
-		targetUsd?: number
-		intervalMs?: number
-		provider?: string
-		maxMovePct?: number
-		minSats?: number
-	}
+	targetUsd?: number
 }
 
 export async function handleServeCommand(
@@ -103,20 +107,6 @@ export async function handleServeCommand(
 
 	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[] = []
 
@@ -139,7 +129,6 @@ function resolveMode(subcommand: string | undefined): ServeMode | null {
 	switch (subcommand) {
 		case 'wallet':
 		case 'monitor':
-		case 'messagebox':
 			return subcommand
 		default:
 			return null
@@ -187,6 +176,8 @@ async function resolveServe(opts: GlobalFlags): Promise<ResolvedServe> {
 		activeRemote: config.activeRemote,
 		backups: config.backups,
 		accounts: resolveAccounts(server.accounts),
+		repricer: server.repricer,
+		monitorEnabled: resolveMonitorEnabled(server.monitor?.enabled),
 		privateKey,
 	}
 }
@@ -195,6 +186,19 @@ function deriveSqliteFilename(dataDir: string, chain: string): string {
 	return join(dataDir, `wallet-${chain}.db`)
 }
 
+/**
+ * Env beats config, default on. ONESAT_MONITOR=false is set per-process by
+ * clustered deployments (PM2 ecosystem) that run a dedicated `serve monitor`;
+ * a plain `1sat serve` runs all-in-one.
+ */
+function resolveMonitorEnabled(configured: boolean | undefined): boolean {
+	const fromEnv = process.env.ONESAT_MONITOR
+	if (fromEnv && fromEnv.trim() !== '') {
+		return !['false', '0', 'off'].includes(fromEnv.trim().toLowerCase())
+	}
+	return configured !== false
+}
+
 function resolvePort(configured: number | undefined): number {
 	const fromEnv = process.env.ONESAT_PORT
 	if (fromEnv && fromEnv.trim() !== '') {
@@ -231,7 +235,7 @@ function resolveAccounts(accounts?: ServerAccountsConfig): ResolvedAccounts {
 		satsPerUnit: accounts?.satsPerUnit ?? DEFAULT_SATS_PER_UNIT,
 		durationBlocks: accounts?.durationBlocks ?? DEFAULT_DURATION_BLOCKS,
 		freeIdentityKeys: accounts?.freeIdentityKeys ?? [],
-		repricer: accounts?.repricer,
+		targetUsd: accounts?.targetUsd,
 	}
 }
 
@@ -258,12 +262,17 @@ async function runWithStorage(
 		storage,
 		activeRemote: resolved.activeRemote,
 		backups: resolved.backups,
-		// Every serve mode manages monitor work explicitly: wallet mode
-		// does none, monitor/all modes run startTasks. The factory's
-		// initial runOnce is redundant in all three cases.
+		// Each serve mode manages monitor work explicitly (see runMonitor
+		// below); the factory's initial runOnce is redundant in every case.
 		skipInitialMonitor: true,
 	})
 
+	// One active monitor per deployment: wallet mode never runs it, monitor
+	// mode always does, all mode runs it unless server.monitor.enabled=false
+	// (set on redundant host instances that share a dedicated serve monitor).
+	const runMonitor =
+		mode === 'monitor' || (mode === 'all' && resolved.monitorEnabled)
+
 	const accounts =
 		mode === 'monitor'
 			? undefined
@@ -272,17 +281,35 @@ async function runWithStorage(
 	const serverHandle =
 		mode === 'monitor'
 			? undefined
-			: await startWalletServer(resolved, walletResult, accounts)
-
-	if (mode !== 'wallet') {
-		const accountsCfg = resolved.accounts
-		const r = accountsCfg.repricer
-		if (
-			accountsCfg.enabled &&
-			r?.enabled &&
-			typeof r.targetUsd === 'number' &&
-			r.targetUsd > 0
-		) {
+			: await startWalletServer(resolved, walletResult, accounts, mode)
+
+	if (runMonitor) {
+		const r = resolved.repricer
+		const targets: RepriceTarget[] = []
+		if (resolved.accounts.enabled && (resolved.accounts.targetUsd ?? 0) > 0) {
+			targets.push({
+				name: 'accounts',
+				targetUsd: resolved.accounts.targetUsd!,
+				readCurrentSats: () =>
+					loadConfig().server?.accounts?.satsPerUnit ?? DEFAULT_SATS_PER_UNIT,
+				onPersist: async (sats) => {
+					setConfigPath('server.accounts.satsPerUnit', sats)
+				},
+			})
+		}
+		const hostingCfg = loadConfig().server?.hosting
+		if (hostingCfg?.enabled === true && (hostingCfg.targetUsd ?? 0) > 0) {
+			targets.push({
+				name: 'hosting',
+				targetUsd: hostingCfg.targetUsd!,
+				readCurrentSats: () =>
+					loadConfig().server?.hosting?.priceSats ?? DEFAULT_HOSTING_PRICE_SATS,
+				onPersist: async (sats) => {
+					setConfigPath('server.hosting.priceSats', sats)
+				},
+			})
+		}
+		if (r?.enabled && targets.length > 0) {
 			walletResult.monitor.addTask(
 				buildPriceUpdateTask({
 					monitor: walletResult.monitor,
@@ -290,27 +317,24 @@ async function runWithStorage(
 						chain: resolved.chain,
 					}),
 					intervalMs: r.intervalMs ?? 15 * 60 * 1000,
-					targetUsd: r.targetUsd,
 					bounds: {
 						maxMovePct: r.maxMovePct ?? 25,
 						minSats: r.minSats ?? 1,
 					},
-					readCurrentSats: () =>
-						loadConfig().server?.accounts?.satsPerUnit ?? DEFAULT_SATS_PER_UNIT,
-					onPersist: async (sats) => {
-						setConfigPath('server.accounts.satsPerUnit', sats)
-					},
+					targets,
 				}),
 			)
 			console.log(
-				`[repricer] enabled — $${r.targetUsd}/unit every ${Math.round(
+				`[repricer] enabled — ${targets
+					.map((t) => `${t.name} $${t.targetUsd}`)
+					.join(', ')} every ${Math.round(
 					(r.intervalMs ?? 900_000) / 1000,
 				)}s via ${r.provider ?? 'whatsonchain'}`,
 			)
 		}
 	}
 
-	if (mode !== 'wallet') {
+	if (runMonitor) {
 		// startTasks loops until stopTasks flips its flag. Fire without
 		// awaiting so the caller can install shutdown handlers and write
 		// the monitor pid file.
@@ -323,7 +347,7 @@ async function runWithStorage(
 
 	return {
 		async stop() {
-			if (mode !== 'wallet') {
+			if (runMonitor) {
 				walletResult.monitor.stopTasks()
 				clearMonitorPid(resolved.dataDir, process.pid)
 			}
@@ -339,20 +363,136 @@ async function startWalletServer(
 	resolved: ResolvedServe,
 	walletResult: NodeWalletResult,
 	accounts: AccountsRuntime | undefined,
+	mode: ServeMode,
 ): Promise<{ stop(): Promise<void> }> {
-	const handle = createWalletServer({
+	const config = loadConfig()
+	const hostingCfg = config.server?.hosting
+	const hostingEnabled = hostingCfg?.enabled === true
+	const hosting = hostingEnabled
+		? {
+				getConfig: () => {
+					const h = loadConfig().server?.hosting
+					return {
+						enabled: h?.enabled === true,
+						priceSats: h?.priceSats ?? DEFAULT_HOSTING_PRICE_SATS,
+						priceUsd: h?.targetUsd,
+						periodSeconds: h?.periodSeconds ?? 2_592_000,
+					}
+				},
+			}
+		: undefined
+
+	if (mode === 'wallet') {
+		const handle = createWalletServer({
+			wallet: walletResult.wallet,
+			storage: walletResult.getActiveStorage(),
+			serverIdentityKey: walletResult.wallet.identityKey,
+			listen: { port: resolved.port, host: resolved.host },
+			publicPath: '/',
+			internalPath: null,
+			accounts: accounts?.walletServerAccounts,
+			hosting,
+		})
+		const port = await handle.start()
+		const notes = [
+			resolved.accounts.enabled ? 'accounts: on' : '',
+			hostingEnabled ? 'hosting: on' : '',
+		]
+			.filter(Boolean)
+			.join(', ')
+		console.log(
+			`[wallet] listening on ${resolved.host}:${port}${notes ? ` (${notes})` : ''}`,
+		)
+		return { stop: () => handle.stop() }
+	}
+
+	// Unified host: storage + messagebox + paymail + hosting
+	const serverCfg = config.server ?? {}
+	const paymailCfg = serverCfg.paymail
+	const messageboxCfg = serverCfg.messagebox
+
+	const knex = createMessageboxKnex(
+		serverCfg.storage ?? { provider: 'bun-sqlite' },
+		messageboxCfg,
+		resolved,
+	)
+	const pendingStore = new KnexPendingStore(knex)
+	await pendingStore.init()
+
+	const handle = await createHostServer({
 		wallet: walletResult.wallet,
 		storage: walletResult.getActiveStorage(),
 		serverIdentityKey: walletResult.wallet.identityKey,
 		listen: { port: resolved.port, host: resolved.host },
-		publicPath: '/',
-		internalPath: null,
 		accounts: accounts?.walletServerAccounts,
+		hosting,
+		paymail: {
+			baseUrl:
+				paymailCfg?.baseUrl ?? `http://${resolved.host}:${resolved.port}`,
+			stackUrl: paymailCfg?.stackUrl ?? 'https://api.1sat.app',
+			pendingStore,
+			hostWallet: hostingEnabled ? walletResult.wallet : undefined,
+			requireEntitlement: hostingEnabled,
+			messageboxUrl: `http://127.0.0.1:${resolved.port}/messagebox`,
+			hostPrivateKey: resolved.privateKey,
+		},
+		messagebox: {
+			knex,
+			websockets: messageboxCfg?.websockets !== false,
+		},
 	})
 	const port = await handle.start()
-	const accountsNote = resolved.accounts.enabled ? ' (accounts: on)' : ''
-	console.log(`[wallet] listening on ${resolved.host}:${port}${accountsNote}`)
-	return { stop: () => handle.stop() }
+	const notes = [
+		resolved.accounts.enabled ? 'accounts: on' : '',
+		hostingEnabled ? 'hosting: on' : '',
+	]
+		.filter(Boolean)
+		.join(', ')
+	console.log(
+		`[host] listening on ${resolved.host}:${port}${notes ? ` (${notes})` : ''}`,
+	)
+	return {
+		stop: async () => {
+			await handle.stop()
+			if (knex) await knex.destroy()
+		},
+	}
+}
+
+const DEFAULT_PG_SCHEMA = 'messagebox'
+
+function createMessageboxKnex(
+	storage: ServerStorageConfig,
+	messagebox: ServerMessageboxConfig | undefined,
+	resolved: ResolvedServe,
+) {
+	if (storage.provider === 'bun-sqlite') {
+		const filename =
+			messagebox?.dbPath ??
+			join(resolved.dataDir, `messagebox-${resolved.chain}.db`)
+		return (knexLib as any)({
+			client: 'sqlite3',
+			connection: { filename },
+			useNullAsDefault: true,
+		})
+	}
+	if (storage.provider === 'pg') {
+		if (messagebox?.dbUrl) {
+			return (knexLib as any)({
+				client: 'pg',
+				connection: { connectionString: messagebox.dbUrl },
+			})
+		}
+		const schema = messagebox?.pgSchema ?? DEFAULT_PG_SCHEMA
+		return (knexLib as any)({
+			client: 'pg',
+			connection: { connectionString: storage.dbUrl },
+			searchPath: [schema],
+		})
+	}
+	fatal(
+		`server.storage.provider '${(storage as { provider: string }).provider}' is not supported for messagebox storage.`,
+	)
 }
 
 interface AccountsRuntime {

package/src/config.ts

@@ -25,18 +25,23 @@ export type ServerStorageConfig =
 	| ServerStorageBunSqliteConfig
 	| ServerStoragePgConfig
 
+/**
+ * Shared repricer engine (`server.repricer`). When enabled, a monitor task
+ * fetches the BSV/USD rate on the interval and rewrites each service's sats
+ * price toward its own `targetUsd` (`server.accounts.targetUsd` →
+ * `satsPerUnit`, `server.hosting.targetUsd` → `priceSats`). Services with no
+ * `targetUsd` set are left alone.
+ */
 export interface RepricerConfig {
 	/** Master toggle. Defaults to false. */
 	enabled?: boolean
-	/** Target price per `purchaseUnitBytes` chunk, in USD. */
-	targetUsd?: number
 	/** Interval between rate checks in ms. Defaults to 900000 (15 min). */
 	intervalMs?: number
 	/** Rate provider name. Defaults to "whatsonchain". */
 	provider?: string
 	/** Max percent change allowed per update. Larger moves are skipped. Defaults to 25. */
 	maxMovePct?: number
-	/** Lower bound for `satsPerUnit`. Defaults to 1. */
+	/** Lower bound for repriced sats values. Defaults to 1. */
 	minSats?: number
 }
 
@@ -49,12 +54,12 @@ export interface ServerAccountsConfig {
 	purchaseUnitBytes?: number
 	/** Sats charged per purchase unit. */
 	satsPerUnit?: number
+	/** USD target per purchase unit, maintained by `server.repricer`. */
+	targetUsd?: number
 	/** Block window a payment remains valid for. */
 	durationBlocks?: number
 	/** Identity keys that bypass metering (server's own key is auto-added). */
 	freeIdentityKeys?: string[]
-	/** Optional auto-repricer. When enabled, updates `satsPerUnit` from a live BSV/USD rate. */
-	repricer?: RepricerConfig
 }
 
 export interface ServerMessageboxConfig {
@@ -85,6 +90,65 @@ export interface ServerMessageboxConfig {
 	walletStorageUrl?: string
 }
 
+export interface ServerPaymailConfig {
+	/** Port to bind. Defaults to `8466` or ONESAT_PAYMAIL_PORT. */
+	port?: number
+	/**
+	 * Public base URL used in /.well-known/bsvalias capability links
+	 * (e.g. https://1sat.app). Required for serve paymail.
+	 */
+	baseUrl?: string
+	/** Stack API root (OpNS, beef, tx). Defaults to https://api.1sat.app */
+	stackUrl?: string
+	/**
+	 * SQLite path for in-flight P2P payment references (Go paymail port).
+	 * Defaults to `<dataDir>/paymail-pending-{chain}.db`.
+	 */
+	pendingDbPath?: string
+	/**
+	 * Messagebox URL for payment_inbox delivery after receive.
+	 * Defaults to https://messagebox.1sat.app when unset is OK to skip —
+	 * set explicitly to enable (same as Go messagebox_url).
+	 */
+	messageboxUrl?: string
+	/**
+	 * When true, open host wallet storage and require active HOSTING_BASKET
+	 * receipt for the bound identity. Default false until subscribe path ships.
+	 */
+	requireEntitlement?: boolean
+	/**
+	 * Wallet storage URL for entitlement listOutputs (and optional later
+	 * subscribe). Defaults to local wallet serve URL like messagebox.
+	 */
+	walletStorageUrl?: string
+}
+
+export interface ServerHostingConfig {
+	/** Master toggle. Defaults to false. */
+	enabled?: boolean
+	/** Sats per subscription period. */
+	priceSats?: number
+	/**
+	 * USD price per subscription period. Returned as `priceUsd` on the
+	 * pricing API for display, and maintained as the repricing target for
+	 * `priceSats` when `server.repricer` is enabled.
+	 */
+	targetUsd?: number
+	/** Period length in seconds (e.g. 2592000 ≈ 30 days). */
+	periodSeconds?: number
+}
+
+export interface ServerMonitorConfig {
+	/**
+	 * Run the background monitor task loop (post waiting txs, check for
+	 * proofs, account repricing). Defaults to true. Set false on redundant
+	 * host instances that run alongside a dedicated `serve monitor`, so a
+	 * single active monitor runs per deployment. `serve monitor` always runs
+	 * the loop regardless of this flag.
+	 */
+	enabled?: boolean
+}
+
 export interface ServerConfig {
 	/** Hostname to bind. Defaults to `127.0.0.1`. */
 	host?: string
@@ -96,6 +160,14 @@ export interface ServerConfig {
 	accounts?: ServerAccountsConfig
 	/** Messagebox subcommand settings. */
 	messagebox?: ServerMessageboxConfig
+	/** Paymail subcommand settings. */
+	paymail?: ServerPaymailConfig
+	/** Hosted paymail subscription (wallet serve /hosting/*). */
+	hosting?: ServerHostingConfig
+	/** Shared BSV/USD repricer engine for accounts + hosting prices. */
+	repricer?: RepricerConfig
+	/** Background monitor task loop. Defaults to enabled. */
+	monitor?: ServerMonitorConfig
 }
 
 export interface OneSatCliConfig {

package/src/help.ts

@@ -560,19 +560,14 @@ export const COMMANDS: CommandSpec[] = [
 		group: 'Server',
 		name: 'serve',
 		description:
-			'Run wallet HTTP server and/or monitor daemon (config under server.* in config.json)',
+			'Run unified host server (storage + hosting + paymail + messagebox) and/or monitor (config under server.* in config.json)',
 		subcommands: [
 			{
 				name: '(no subcommand)',
-				description: 'Wallet server + monitor daemon',
+				description: 'Host server + monitor daemon',
 			},
-			{ name: 'wallet', description: 'Wallet server only (BRC-100 HTTP)' },
+			{ name: 'wallet', description: 'Wallet storage server only (BRC-100 HTTP)' },
 			{ name: 'monitor', description: 'Monitor daemon only' },
-			{
-				name: 'messagebox',
-				description:
-					'BSV message-box server (port 8771 default; uses wallet identity)',
-			},
 		],
 	},
 	{

package/src/repricer/buildPriceUpdateTask.ts

@@ -1,18 +1,25 @@
 import { computeReprice } from './computeReprice'
 import type { RateProvider, RepricerBounds } from './types'
 
+/** One price the repricer maintains from the shared BSV/USD quote. */
+export interface RepriceTarget {
+	/** Label for task result logs, e.g. 'accounts' or 'hosting'. */
+	name: string
+	/** USD target for this price. Targets with 0 or negative are ignored. */
+	targetUsd: number
+	/** Read the current sats value (typically from disk via the same loader the servers use). */
+	readCurrentSats: () => number
+	/** Persist the new sats value (wraps `setConfigPath`). */
+	onPersist: (newSats: number) => Promise<void>
+}
+
 export interface PriceUpdateTaskOptions {
 	monitor: unknown
 	rateProvider: RateProvider
 	/** Interval between successful tick attempts. */
 	intervalMs: number
-	/** USD target per purchase unit. Task no-ops when this is 0. */
-	targetUsd: number
 	bounds: RepricerBounds
-	/** Read current `satsPerUnit` (typically from disk via the same loader the servers use). */
-	readCurrentSats: () => number
-	/** Persist the new `satsPerUnit` value. Wraps `setConfigPath('server.accounts.satsPerUnit', sats)`. */
-	onPersist: (newSats: number) => Promise<void>
+	targets: RepriceTarget[]
 }
 
 export interface PriceUpdateTask {
@@ -28,15 +35,8 @@ export interface PriceUpdateTask {
 export function buildPriceUpdateTask(
 	options: PriceUpdateTaskOptions,
 ): PriceUpdateTask {
-	const {
-		monitor,
-		rateProvider,
-		intervalMs,
-		targetUsd,
-		bounds,
-		readCurrentSats,
-		onPersist,
-	} = options
+	const { monitor, rateProvider, intervalMs, bounds } = options
+	const targets = options.targets.filter((t) => t.targetUsd > 0)
 
 	const storage = (monitor as { storage?: unknown } | null | undefined)?.storage
 
@@ -47,7 +47,7 @@ export function buildPriceUpdateTask(
 		lastRunMsecsSinceEpoch: 0,
 		async asyncSetup() {},
 		trigger(now: number): { run: boolean } {
-			if (!(targetUsd > 0)) return { run: false }
+			if (targets.length === 0) return { run: false }
 			if (now - this.lastRunMsecsSinceEpoch < intervalMs) return { run: false }
 			return { run: true }
 		},
@@ -59,22 +59,32 @@ export function buildPriceUpdateTask(
 				return `rate fetch failed: ${(err as Error).message}`
 			}
 
-			const currentSats = readCurrentSats()
-			const result = computeReprice({
-				targetUsd,
-				bsvUsd: quote.bsvUsd,
-				currentSats,
-				bounds,
-			})
+			const parts: string[] = []
+			for (const target of targets) {
+				const currentSats = target.readCurrentSats()
+				const result = computeReprice({
+					targetUsd: target.targetUsd,
+					bsvUsd: quote.bsvUsd,
+					currentSats,
+					bounds,
+				})
 
-			if (result.status === 'skipped') return `skipped: ${result.reason}`
+				if (result.status === 'skipped') {
+					parts.push(`${target.name}: skipped: ${result.reason}`)
+					continue
+				}
 
-			try {
-				await onPersist(result.newSats)
-			} catch (err) {
-				return `persist failed: ${(err as Error).message}`
+				try {
+					await target.onPersist(result.newSats)
+				} catch (err) {
+					parts.push(
+						`${target.name}: persist failed: ${(err as Error).message}`,
+					)
+					continue
+				}
+				parts.push(`${target.name}: ${currentSats} → ${result.newSats} sats`)
 			}
-			return `${currentSats} → ${result.newSats} sats/unit @ $${quote.bsvUsd}/BSV`
+			return `${parts.join('; ')} @ $${quote.bsvUsd}/BSV`
 		},
 	}
 }

package/src/repricer/index.ts

@@ -1,5 +1,8 @@
 export { buildPriceUpdateTask } from './buildPriceUpdateTask'
-export type { PriceUpdateTaskOptions } from './buildPriceUpdateTask'
+export type {
+	PriceUpdateTaskOptions,
+	RepriceTarget,
+} from './buildPriceUpdateTask'
 export { computeReprice } from './computeReprice'
 export { createAccountsConfigLoader } from './configLoader'
 export type { AccountsConfigLoaderOptions } from './configLoader'

package/src/commands/serve-messagebox.ts

@@ -1,221 +0,0 @@
-/**
- * `1sat serve messagebox` — launch the BSV message-box server using the
- * CLI's wallet identity.
- *
- * 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. Switches cwd to the messagebox-server install dir so its knexfile's
- *      relative `./out/src/migrations` path resolves correctly
- *   4. Dynamically imports `@bopen-io/messagebox-server`
- *   5. Awaits SIGINT/SIGTERM, then closes the HTTP and WebSocket servers
- */
-
-import { dirname, 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'}`,
-	)
-
-	// messagebox-server's knexfile uses `./out/src/migrations` relative to
-	// cwd. Switch cwd to its install dir so that path resolves correctly
-	// regardless of where the CLI was invoked from.
-	const packageJsonUrl = import.meta.resolve(
-		'@bopen-io/messagebox-server/package.json',
-	)
-	const messageboxDir = dirname(fileURLToPath(packageJsonUrl))
-	process.chdir(messageboxDir)
-
-	// 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`)
-		return {
-			knexClient: 'sqlite3',
-			knexConnection: { filename },
-		}
-	}
-
-	if (storage.provider === 'pg') {
-		// Prefer a dedicated messagebox database when configured (recommended:
-		// avoids `knex_migrations` table collisions with wallet-toolbox).
-		// Fall back to schema isolation against the wallet's database — note
-		// the `messagebox` schema must exist in that database for table
-		// creation to land there instead of `public`.
-		if (messagebox.dbUrl) {
-			return {
-				knexClient: 'pg',
-				knexConnection: { connectionString: messagebox.dbUrl },
-			}
-		}
-		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'
-	}
-}