@1sat/cli 0.0.31 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@1sat/cli",
-	"version": "0.0.31",
+	"version": "0.0.32",
 	"description": "CLI for 1Sat Ordinals SDK",
 	"type": "module",
 	"main": "./src/cli.ts",
@@ -20,12 +20,16 @@
 		"@1sat/client": "0.0.21",
 		"@1sat/types": "0.0.17",
 		"@1sat/wallet-node": "0.0.29",
+		"@1sat/wallet-server": "0.0.1",
 		"@bsv/sdk": "^2.0.13",
+		"@bsv/wallet-toolbox": "^2.1.21",
 		"chalk": "^5.0.0",
 		"@clack/prompts": "^0.8.0",
 		"bitcoin-backup": "^0.0.11",
 		"dotenv": "^17.0.0",
-		"evlog": "^2.10.0"
+		"evlog": "^2.10.0",
+		"knex": "^3.1.0",
+		"pg": "^8.11.3"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.9",

package/src/cli.ts

@@ -16,6 +16,7 @@ import { handleMcpProxyCommand } from './commands/mcp-proxy'
 import { handleOpnsCommand } from './commands/opns'
 import { handleOrdinalsCommand } from './commands/ordinals'
 import { handleRemoteCommand } from './commands/remote'
+import { handleServeCommand } from './commands/serve'
 import { handleSocialCommand } from './commands/social'
 import { handleSweepCommand } from './commands/sweep'
 import { handleTokensCommand } from './commands/tokens'
@@ -98,6 +99,10 @@ async function main(): Promise<void> {
 			await handleMcpProxyCommand()
 			break
 
+		case 'serve':
+			await handleServeCommand(rest, flags)
+			break
+
 		case 'help':
 			printHelp()
 			break

package/src/commands/config.ts

@@ -10,11 +10,12 @@
 
 import type { GlobalFlags } from '../args'
 import {
-	type OneSatCliConfig,
 	getConfigDir,
 	getConfigFile,
 	loadConfig,
-	updateConfig,
+	parseConfigValue,
+	setConfigPath,
+	unsetConfigPath,
 } from '../config'
 import { printCommandHelp } from '../help'
 import {
@@ -23,15 +24,8 @@ import {
 	formatSuccess,
 	formatValue,
 	output,
-	printKeyValue,
 } from '../output'
 
-const SETTABLE_KEYS: Array<keyof OneSatCliConfig> = [
-	'chain',
-	'dataDir',
-	'storageIdentityKey',
-]
-
 export async function handleConfigCommand(
 	args: string[],
 	opts: GlobalFlags,
@@ -69,11 +63,7 @@ function configShow(opts: GlobalFlags): void {
 	}
 
 	console.log()
-	printKeyValue({
-		chain: config.chain,
-		dataDir: config.dataDir,
-		storageIdentityKey: config.storageIdentityKey ?? '(not set)',
-	})
+	printNested(config, '')
 	console.log()
 	console.log(
 		`  ${formatLabel('config file:')}  ${formatValue(getConfigFile())}`,
@@ -81,48 +71,89 @@ function configShow(opts: GlobalFlags): void {
 	console.log()
 }
 
-function configSet(args: string[], opts: GlobalFlags): void {
-	const [key, value] = args
-
-	if (!key || !value) {
-		fatal(
-			`Usage: 1sat config set <key> <value>\n\nSettable keys: ${SETTABLE_KEYS.join(', ')}`,
+function printNested(value: unknown, prefix: string): void {
+	if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+		console.log(
+			`  ${formatLabel(`${prefix || '(value)'}:`)}  ${formatValue(String(value))}`,
 		)
+		return
 	}
-
-	if (!SETTABLE_KEYS.includes(key as keyof OneSatCliConfig)) {
-		fatal(
-			`Unknown config key: ${key}\n\nSettable keys: ${SETTABLE_KEYS.join(', ')}`,
-		)
+	const obj = value as Record<string, unknown>
+	for (const [k, v] of Object.entries(obj)) {
+		const path = prefix ? `${prefix}.${k}` : k
+		if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
+			printNested(v, path)
+		} else {
+			const display = Array.isArray(v)
+				? JSON.stringify(v)
+				: String(v ?? '(not set)')
+			console.log(`  ${formatLabel(`${path}:`)}  ${formatValue(display)}`)
+		}
 	}
+}
+
+function configSet(args: string[], opts: GlobalFlags): void {
+	const [key, ...valueArgs] = args
+	const value = valueArgs.join(' ')
 
-	// Validate specific keys
-	if (key === 'chain' && value !== 'main' && value !== 'test') {
-		fatal("chain must be 'main' or 'test'")
+	if (!key || valueArgs.length === 0) {
+		fatal('Usage: 1sat config set <dotted.path> <value>')
 	}
 
-	const updated = updateConfig({ [key]: value })
-	output(opts.json ? updated : formatSuccess(`Set ${key} = ${value}`), opts)
+	const parsed = parseConfigValue(value)
+	validateKnownPath(key, parsed)
+
+	setConfigPath(key, parsed)
+	output(
+		opts.json ? { [key]: parsed } : formatSuccess(`Set ${key} = ${value}`),
+		opts,
+	)
 }
 
 function configUnset(args: string[], opts: GlobalFlags): void {
 	const [key] = args
 
 	if (!key) {
-		fatal(
-			`Usage: 1sat config unset <key>\n\nKeys that can be unset: ${SETTABLE_KEYS.join(', ')}`,
-		)
+		fatal('Usage: 1sat config unset <dotted.path>')
 	}
 
-	if (!SETTABLE_KEYS.includes(key as keyof OneSatCliConfig)) {
-		fatal(
-			`Unknown config key: ${key}\n\nKeys that can be unset: ${SETTABLE_KEYS.join(', ')}`,
-		)
-	}
+	unsetConfigPath(key)
+	output(opts.json ? { [key]: undefined } : formatSuccess(`Unset ${key}`), opts)
+}
 
-	// For other keys, use undefined
-	const updated = updateConfig({ [key]: undefined })
-	output(opts.json ? updated : formatSuccess(`Unset ${key}`), opts)
+/**
+ * Enforce the few semantic constraints we care about. Unknown paths are
+ * allowed — callers that read them can validate at consumption time.
+ */
+function validateKnownPath(key: string, value: unknown): void {
+	switch (key) {
+		case 'chain':
+			if (value !== 'main' && value !== 'test') {
+				fatal("chain must be 'main' or 'test'")
+			}
+			break
+		case 'server.storage.provider':
+			if (
+				value !== 'bun-sqlite' &&
+				value !== 'knex-sqlite' &&
+				value !== 'knex-pg'
+			) {
+				fatal(
+					"server.storage.provider must be 'bun-sqlite' | 'knex-sqlite' | 'knex-pg'",
+				)
+			}
+			break
+		case 'server.port':
+			if (typeof value !== 'number' || value <= 0 || !Number.isInteger(value)) {
+				fatal('server.port must be a positive integer')
+			}
+			break
+		case 'server.accounts.enabled':
+			if (typeof value !== 'boolean') {
+				fatal('server.accounts.enabled must be true or false')
+			}
+			break
+	}
 }
 
 function configPath(opts: GlobalFlags): void {

package/src/commands/serve.ts

@@ -0,0 +1,297 @@
+/**
+ * `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
+ *
+ * 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
+ * `createNodeWallet` factory `1sat wallet` commands use.
+ *
+ * Server-only settings live under `server.*` in the config:
+ *   1sat config set server.port 8100
+ *   1sat config set server.host 0.0.0.0
+ *   1sat config set server.accounts.enabled true
+ */
+
+import { join } from 'node:path'
+import { OneSatServices } from '@1sat/client'
+import { type NodeWalletResult, createNodeWallet } from '@1sat/wallet-node'
+import {
+	createWalletServer,
+	runMigrations as runAccountsMigrations,
+} from '@1sat/wallet-server'
+import type { PrivateKey } from '@bsv/sdk'
+import { type Knex, knex } from 'knex'
+import type { GlobalFlags } from '../args'
+import {
+	type ServerAccountsConfig,
+	type ServerStorageConfig,
+	loadConfig,
+} from '../config'
+import { ensureDataDir } from '../config'
+import { printCommandHelp } from '../help'
+import { loadKey, resolvePassword } from '../keys'
+import { fatal } from '../output'
+
+const DEFAULT_HOST = '127.0.0.1'
+const DEFAULT_PORT = 8100
+const DEFAULT_ONESAT_URL = 'https://api.1sat.app/1sat'
+const DEFAULT_BASELINE_BYTES = 1024 * 1024 * 1024 // 1 GB
+const DEFAULT_SATS_PER_GB = 1_000_000
+const DEFAULT_DURATION_BLOCKS = 4383
+const DEFAULT_STORAGE_IDENTITY_KEY = '1sat-cli-default'
+
+type ServeMode = 'all' | 'wallet' | 'monitor'
+
+interface ResolvedServe {
+	chain: 'main' | 'test'
+	host: string
+	port: number
+	onesatURL: string
+	storage: ServerStorageConfig
+	dataDir: string
+	sqliteFilename: string
+	storageIdentityKey: string
+	activeRemote?: string
+	backups?: string[]
+	accounts: ResolvedAccounts
+	privateKey: PrivateKey
+}
+
+interface ResolvedAccounts {
+	enabled: boolean
+	baselineBytes: number
+	satsPerGb: number
+	durationBlocks: number
+	freeIdentityKeys: string[]
+}
+
+export async function handleServeCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand] = args
+	const mode = resolveMode(subcommand)
+
+	if (mode === null) {
+		printCommandHelp('serve', {
+			'(no subcommand)': 'Wallet server plus monitor daemon',
+			wallet: 'Wallet server only',
+			monitor: 'Monitor daemon only',
+		})
+		if (subcommand && subcommand !== 'help') process.exit(1)
+		return
+	}
+
+	const resolved = await resolveServe(opts)
+	const handles: Stoppable[] = []
+
+	try {
+		if (resolved.storage.provider === 'bun-sqlite') {
+			handles.push(await runBunSqlite(resolved, mode))
+		} else {
+			fatal(
+				`server.storage.provider '${resolved.storage.provider}' is not yet wired through the shared wallet factory. Only bun-sqlite is supported at the moment.`,
+			)
+		}
+
+		await waitForShutdown()
+	} finally {
+		for (const h of handles.reverse()) {
+			try {
+				await h.stop()
+			} catch (err) {
+				console.error(`Error during shutdown: ${(err as Error).message}`)
+			}
+		}
+	}
+}
+
+function resolveMode(subcommand: string | undefined): ServeMode | null {
+	if (!subcommand) return 'all'
+	switch (subcommand) {
+		case 'wallet':
+		case 'monitor':
+			return subcommand
+		default:
+			return null
+	}
+}
+
+/**
+ * Load the CLI config, apply serve defaults, and resolve the server identity
+ * key via the existing keyring mechanism.
+ */
+async function resolveServe(opts: GlobalFlags): Promise<ResolvedServe> {
+	const config = loadConfig()
+	const server = config.server ?? {}
+
+	const storage: ServerStorageConfig = server.storage ?? {
+		provider: 'bun-sqlite',
+	}
+	if (storage.provider === 'knex-pg' && !storage.dbUrl) {
+		fatal(
+			'server.storage.provider is knex-pg but server.storage.dbUrl is not set. ' +
+				'Set it with: 1sat config set server.storage.dbUrl postgres://…',
+		)
+	}
+
+	const dataDir = ensureDataDir()
+	const chain = opts.chain ?? config.chain ?? 'main'
+
+	let privateKey: PrivateKey
+	try {
+		privateKey = await loadKey(resolvePassword())
+	} catch (err) {
+		fatal((err as Error).message)
+	}
+
+	return {
+		chain,
+		host: server.host ?? DEFAULT_HOST,
+		port: server.port ?? DEFAULT_PORT,
+		onesatURL: DEFAULT_ONESAT_URL,
+		storage,
+		dataDir,
+		sqliteFilename: deriveSqliteFilename(dataDir, chain),
+		storageIdentityKey:
+			config.storageIdentityKey ?? DEFAULT_STORAGE_IDENTITY_KEY,
+		activeRemote: config.activeRemote,
+		backups: config.backups,
+		accounts: resolveAccounts(server.accounts),
+		privateKey,
+	}
+}
+
+function deriveSqliteFilename(dataDir: string, chain: string): string {
+	return join(dataDir, `wallet-${chain}.db`)
+}
+
+function resolveAccounts(accounts?: ServerAccountsConfig): ResolvedAccounts {
+	return {
+		enabled: accounts?.enabled ?? false,
+		baselineBytes: accounts?.baselineBytes ?? DEFAULT_BASELINE_BYTES,
+		satsPerGb: accounts?.satsPerGb ?? DEFAULT_SATS_PER_GB,
+		durationBlocks: accounts?.durationBlocks ?? DEFAULT_DURATION_BLOCKS,
+		freeIdentityKeys: accounts?.freeIdentityKeys ?? [],
+	}
+}
+
+interface Stoppable {
+	stop(): Promise<void>
+}
+
+/**
+ * bun-sqlite path: construct the wallet via the same `createNodeWallet`
+ * factory the CLI uses. Server + monitor operate on that single wallet
+ * instance, so `activeRemote`, `backups`, and `storageIdentityKey` behave
+ * identically to `1sat wallet <command>`.
+ */
+async function runBunSqlite(
+	resolved: ResolvedServe,
+	mode: ServeMode,
+): Promise<Stoppable> {
+	const walletResult = await createNodeWallet({
+		privateKey: resolved.privateKey,
+		chain: resolved.chain,
+		storageIdentityKey: resolved.storageIdentityKey,
+		filename: resolved.sqliteFilename,
+		activeRemote: resolved.activeRemote,
+		backups: resolved.backups,
+	})
+
+	const accounts = await buildAccountsForServer(resolved)
+
+	const serverHandle =
+		mode === 'monitor'
+			? undefined
+			: await startWalletServer(resolved, walletResult, accounts)
+
+	if (mode !== 'wallet') {
+		await walletResult.monitor.startTasks()
+		console.log('[monitor] started')
+	}
+
+	return {
+		async stop() {
+			if (mode !== 'wallet') {
+				walletResult.monitor.stopTasks()
+			}
+			if (serverHandle) await serverHandle.stop()
+			if (accounts) await accounts.knex.destroy()
+			await walletResult.destroy()
+		},
+	}
+}
+
+async function startWalletServer(
+	resolved: ResolvedServe,
+	walletResult: NodeWalletResult,
+	accounts: AccountsRuntime | undefined,
+): Promise<{ stop(): Promise<void> }> {
+	const handle = createWalletServer({
+		storage: walletResult.storage,
+		serverPrivateKey: resolved.privateKey.toHex(),
+		listen: { port: resolved.port, host: resolved.host },
+		publicPath: '/',
+		internalPath: null,
+		accounts: accounts?.walletServerAccounts,
+	})
+	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() }
+}
+
+interface AccountsRuntime {
+	walletServerAccounts: NonNullable<
+		Parameters<typeof createWalletServer>[0]['accounts']
+	>
+	knex: Knex
+}
+
+async function buildAccountsForServer(
+	resolved: ResolvedServe,
+): Promise<AccountsRuntime | undefined> {
+	if (!resolved.accounts.enabled) return undefined
+
+	// Accounts uses its own knex pool. For bun-sqlite wallets that means
+	// opening the same file via better-sqlite3; for future pg wallets it
+	// shares the pg connection. Always a file path for now.
+	const accountsKnex = knex({
+		client: 'better-sqlite3',
+		connection: { filename: resolved.sqliteFilename },
+		useNullAsDefault: true,
+	})
+	await runAccountsMigrations(accountsKnex)
+
+	const services = new OneSatServices(resolved.chain, resolved.onesatURL)
+
+	return {
+		knex: accountsKnex,
+		walletServerAccounts: {
+			config: {
+				enabled: true,
+				baselineBytes: resolved.accounts.baselineBytes,
+				satsPerGb: resolved.accounts.satsPerGb,
+				durationBlocks: resolved.accounts.durationBlocks,
+				freeIdentityKeys: resolved.accounts.freeIdentityKeys,
+			},
+			knex: accountsKnex,
+			currentBlock: () => services.chaintracks.currentHeight(),
+		},
+	}
+}
+
+function waitForShutdown(): Promise<void> {
+	return new Promise((resolve) => {
+		const handler = (sig: string) => {
+			console.log(`Received ${sig}, shutting down...`)
+			resolve()
+		}
+		process.once('SIGINT', () => handler('SIGINT'))
+		process.once('SIGTERM', () => handler('SIGTERM'))
+	})
+}

package/src/config.ts

@@ -11,6 +11,49 @@ import { join } from 'node:path'
 const CONFIG_DIR = join(homedir(), '.1sat', 'cli')
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json')
 
+export interface ServerStorageBunSqliteConfig {
+	provider: 'bun-sqlite'
+}
+
+export interface ServerStorageKnexSqliteConfig {
+	provider: 'knex-sqlite'
+}
+
+export interface ServerStorageKnexPgConfig {
+	provider: 'knex-pg'
+	/** Postgres connection URL (required for knex-pg). */
+	dbUrl: string
+}
+
+export type ServerStorageConfig =
+	| ServerStorageBunSqliteConfig
+	| ServerStorageKnexSqliteConfig
+	| ServerStorageKnexPgConfig
+
+export interface ServerAccountsConfig {
+	/** Master toggle. Defaults to false when omitted. */
+	enabled?: boolean
+	/** Free baseline per identity key, in bytes. */
+	baselineBytes?: number
+	/** Sats charged per GB of paid capacity per `durationBlocks`. */
+	satsPerGb?: number
+	/** Block window a payment remains valid for. */
+	durationBlocks?: number
+	/** Identity keys that bypass metering (server's own key is auto-added). */
+	freeIdentityKeys?: string[]
+}
+
+export interface ServerConfig {
+	/** Hostname to bind. Defaults to `127.0.0.1`. */
+	host?: string
+	/** Port to bind. Defaults to `8100`. */
+	port?: number
+	/** Storage backend. Defaults to `{ provider: 'bun-sqlite' }`. */
+	storage?: ServerStorageConfig
+	/** Optional account/metering layer (opt-in per-deployment). */
+	accounts?: ServerAccountsConfig
+}
+
 export interface OneSatCliConfig {
 	/** Network: mainnet or testnet */
 	chain: 'main' | 'test'
@@ -22,6 +65,8 @@ export interface OneSatCliConfig {
 	backups?: string[]
 	/** Storage identity key for wallet persistence */
 	storageIdentityKey?: string
+	/** Settings read by `1sat serve` subcommands. Absent for client-only installs. */
+	server?: ServerConfig
 }
 
 const DEFAULT_CONFIG: OneSatCliConfig = {
@@ -72,6 +117,66 @@ export function updateConfig(patch: Partial<OneSatCliConfig>): OneSatCliConfig {
 	return next
 }
 
+/**
+ * Set a value at a dotted path inside the config, creating intermediate
+ * objects as needed. `value` is stored as-is; callers are responsible for
+ * type coercion (typically via `parseConfigValue`).
+ */
+export function setConfigPath(path: string, value: unknown): OneSatCliConfig {
+	if (!path) throw new Error('setConfigPath requires a non-empty path')
+	const config = loadConfig() as Record<string, unknown>
+	const segments = path.split('.')
+	let cursor: Record<string, unknown> = config
+	for (let i = 0; i < segments.length - 1; i++) {
+		const key = segments[i]
+		const existing = cursor[key]
+		if (
+			existing == null ||
+			typeof existing !== 'object' ||
+			Array.isArray(existing)
+		) {
+			cursor[key] = {}
+		}
+		cursor = cursor[key] as Record<string, unknown>
+	}
+	cursor[segments[segments.length - 1]] = value
+	saveConfig(config as OneSatCliConfig)
+	return config as OneSatCliConfig
+}
+
+/**
+ * Remove a value at a dotted path. Leaves empty parent objects in place to
+ * keep the file shape explicit.
+ */
+export function unsetConfigPath(path: string): OneSatCliConfig {
+	if (!path) throw new Error('unsetConfigPath requires a non-empty path')
+	const config = loadConfig() as Record<string, unknown>
+	const segments = path.split('.')
+	let cursor: Record<string, unknown> | undefined = config
+	for (let i = 0; i < segments.length - 1; i++) {
+		const next = cursor?.[segments[i]]
+		if (next == null || typeof next !== 'object')
+			return config as OneSatCliConfig
+		cursor = next as Record<string, unknown>
+	}
+	if (cursor) delete cursor[segments[segments.length - 1]]
+	saveConfig(config as OneSatCliConfig)
+	return config as OneSatCliConfig
+}
+
+/**
+ * Parse a raw CLI argument into a typed JSON value. Tries `JSON.parse`
+ * first so numbers, booleans, objects and arrays round-trip naturally;
+ * falls back to the raw string for bare words that aren't valid JSON.
+ */
+export function parseConfigValue(raw: string): unknown {
+	try {
+		return JSON.parse(raw)
+	} catch {
+		return raw
+	}
+}
+
 /**
  * Get the config directory path.
  */