@1sat/cli 0.0.32 → 0.0.34

package/package.json

@@ -1,38 +1,45 @@
 {
-	"name": "@1sat/cli",
-	"version": "0.0.32",
-	"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.99",
-		"@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",
-		"knex": "^3.1.0",
-		"pg": "^8.11.3"
-	},
-	"devDependencies": {
-		"@types/bun": "^1.3.9",
-		"typescript": "^5.9.3"
-	}
+  "name": "@1sat/cli",
+  "version": "0.0.34",
+  "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.100",
+    "@1sat/client": "0.0.21",
+    "@1sat/types": "0.0.17",
+    "@1sat/wallet-node": "0.0.31",
+    "@1sat/wallet-server": "0.0.3",
+    "@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",
+    "knex": "^3.1.0",
+    "pg": "^8.11.3"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.9",
+    "typescript": "^5.9.3"
+  }
 }

package/src/cli.ts

@@ -116,5 +116,6 @@ async function main(): Promise<void> {
 
 main().catch((err) => {
 	console.error(formatError(`Error: ${err.message}`))
+	if (process.env.DEBUG) console.error(err.stack)
 	process.exit(1)
 })

package/src/commands/config.ts

@@ -133,14 +133,8 @@ function validateKnownPath(key: string, value: unknown): void {
 			}
 			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'",
-				)
+			if (value !== 'bun-sqlite' && value !== 'knex-pg') {
+				fatal("server.storage.provider must be 'bun-sqlite' | 'knex-pg'")
 			}
 			break
 		case 'server.port':

package/src/commands/remote.ts

@@ -8,6 +8,8 @@
  *   set-active - Switch active storage to a remote or back to local
  */
 
+import { StorageClient } from '@1sat/wallet-node'
+import { WalletServerClient, topUpStorage } from '@1sat/wallet-server'
 import { confirm, isCancel, text } from '@clack/prompts'
 import type { GlobalFlags } from '../args'
 import { loadConfig, saveConfig } from '../config'
@@ -31,6 +33,10 @@ export async function handleRemoteCommand(
 			return remoteDelete(rest, opts)
 		case 'set-active':
 			return remoteSetActive(rest, opts)
+		case 'status':
+			return remoteStatus(rest, opts)
+		case 'topup':
+			return remoteTopup(rest, opts)
 		default:
 			printCommandHelp('remote', {
 				add: 'Add a remote storage as backup (1sat remote add <url>)',
@@ -39,6 +45,10 @@ export async function handleRemoteCommand(
 					'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])',
 			})
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
@@ -85,11 +95,7 @@ async function remoteAdd(args: string[], opts: GlobalFlags): Promise<void> {
 	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
-		const { StorageClient } = await import('@1sat/wallet-node')
-		const wallet = walletResult.wallet as any
-		const client = new (StorageClient as any)(wallet, url)
+		const client = new StorageClient(walletResult.wallet, url)
 		await walletResult.storage.addWalletStorageProvider(client)
 
 		// When adding a backup, the remote may report itself as "active" which
@@ -128,7 +134,7 @@ async function remoteAdd(args: string[], opts: GlobalFlags): Promise<void> {
 
 async function remoteList(_args: string[], opts: GlobalFlags): Promise<void> {
 	const privateKey = await loadKey(resolvePassword())
-	const { walletResult, destroy } = await loadContext(privateKey, {
+	const { destroy } = await loadContext(privateKey, {
 		chain: opts.chain,
 	})
 
@@ -321,6 +327,152 @@ async function remoteSetActive(
 	}
 }
 
+// ============================================================================
+// remote status
+// ============================================================================
+
+async function remoteStatus(args: string[], opts: GlobalFlags): Promise<void> {
+	const config = loadConfig()
+	const url = args[0] ?? config.activeRemote ?? config.backups?.[0]
+	if (!url) {
+		fatal(
+			'No remote URL supplied. Pass one as an argument or configure activeRemote/backups first.',
+		)
+	}
+	try {
+		new URL(url)
+	} catch {
+		fatal(`Invalid URL: ${url}`)
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { walletResult, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const client = new WalletServerClient(url, walletResult.wallet)
+		const status = await client.accountStatus()
+
+		if (opts.json) {
+			output(status, opts)
+			return
+		}
+
+		console.log()
+		console.log(`  ${bold('Remote:')} ${url}`)
+		console.log(`  ${bold('Identity:')} ${status.identityKey}`)
+		console.log(
+			`  ${bold('Accounts:')} ${status.accountsEnabled ? 'on' : 'off'}`,
+		)
+		if (status.currentBlock != null) {
+			console.log(`  ${bold('Chain tip:')} block ${status.currentBlock}`)
+		}
+		if (status.usedBytes != null) {
+			console.log(`  ${bold('Used:')} ${formatBytes(status.usedBytes)}`)
+		}
+		if (status.accountsEnabled) {
+			console.log(`  ${bold('Baseline:')} ${formatBytes(status.baselineBytes)}`)
+			console.log(`  ${bold('Paid:')} ${formatBytes(status.paidBytes)}`)
+			console.log(`  ${bold('Capacity:')} ${formatBytes(status.capacityBytes)}`)
+			if (status.deficitBytes > 0) {
+				console.log(
+					`  ${bold('Deficit:')} ${formatBytes(status.deficitBytes)} (next write will trigger 402)`,
+				)
+			}
+			if (status.paidThroughBlock != null) {
+				const remaining = status.paidThroughBlock - status.currentBlock
+				console.log(
+					`  ${bold('Paid through:')} block ${status.paidThroughBlock} (${remaining} blocks left)`,
+				)
+			}
+			console.log(
+				`  ${bold('Pricing:')} ${status.pricing.satsPerUnit} sats per ${formatBytes(status.pricing.purchaseUnitBytes)} over ${status.pricing.durationBlocks} blocks`,
+			)
+		}
+		console.log()
+	} finally {
+		await destroy()
+	}
+}
+
+// ============================================================================
+// remote topup
+// ============================================================================
+
+async function remoteTopup(args: string[], opts: GlobalFlags): Promise<void> {
+	let url: string | undefined
+	let units: number | undefined
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i]
+		if (arg === '--units') {
+			const val = args[++i]
+			const parsed = Number(val)
+			if (!Number.isInteger(parsed) || parsed <= 0) {
+				fatal(`--units requires a positive integer, got "${val}"`)
+			}
+			units = parsed
+		} else if (!url) {
+			url = arg
+		}
+	}
+
+	const config = loadConfig()
+	url = url ?? config.activeRemote ?? config.backups?.[0]
+	if (!url) {
+		fatal(
+			'No remote URL supplied. Pass one as an argument or configure activeRemote/backups first.',
+		)
+	}
+	try {
+		new URL(url)
+	} catch {
+		fatal(`Invalid URL: ${url}`)
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { walletResult, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await topUpStorage(walletResult.wallet, url, { units })
+
+		if (opts.json) {
+			output(result, opts)
+			return
+		}
+
+		console.log()
+		console.log(`  ${bold('Remote:')} ${url}`)
+		console.log(`  ${bold('Units bought:')} ${result.unitsBought}`)
+		console.log(`  ${bold('Sats paid:')} ${result.satsPaid}`)
+		console.log(`  ${bold('Payment txid:')} ${result.txid}`)
+		if (result.status.accountsEnabled) {
+			console.log()
+			console.log(
+				`  ${bold('New capacity:')} ${formatBytes(result.status.capacityBytes)} (${formatBytes(result.status.usedBytes)} used, ${formatBytes(result.status.deficitBytes)} deficit)`,
+			)
+			if (result.status.paidThroughBlock != null) {
+				const remaining = result.status.paidThroughBlock - result.status.currentBlock
+				console.log(
+					`  ${bold('Paid through:')} block ${result.status.paidThroughBlock} (${remaining} blocks left)`,
+				)
+			}
+		}
+		console.log()
+	} finally {
+		await destroy()
+	}
+}
+
+function formatBytes(n: number): string {
+	if (n < 1024) return `${n} B`
+	if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`
+	if (n < 1024 * 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(1)} MB`
+	return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`
+}
+
 // ============================================================================
 // Helpers
 // ============================================================================

package/src/commands/serve.ts

@@ -16,14 +16,13 @@
  */
 
 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'
+	type NodeWalletResult,
+	type NodeWalletStorageConfig,
+	createNodeWallet,
+} from '@1sat/wallet-node'
+import { createWalletServer } from '@1sat/wallet-server'
 import type { PrivateKey } from '@bsv/sdk'
-import { type Knex, knex } from 'knex'
 import type { GlobalFlags } from '../args'
 import {
 	type ServerAccountsConfig,
@@ -33,13 +32,15 @@ import {
 import { ensureDataDir } from '../config'
 import { printCommandHelp } from '../help'
 import { loadKey, resolvePassword } from '../keys'
+import { clearMonitorPid, writeMonitorPid } from '../monitor-lock'
 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_PURCHASE_UNIT_BYTES = 1_073_741_824 // 1 GB chunks for production
+const DEFAULT_SATS_PER_UNIT = 1_000_000
 const DEFAULT_DURATION_BLOCKS = 4383
 const DEFAULT_STORAGE_IDENTITY_KEY = '1sat-cli-default'
 
@@ -63,7 +64,8 @@ interface ResolvedServe {
 interface ResolvedAccounts {
 	enabled: boolean
 	baselineBytes: number
-	satsPerGb: number
+	purchaseUnitBytes: number
+	satsPerUnit: number
 	durationBlocks: number
 	freeIdentityKeys: string[]
 }
@@ -89,14 +91,7 @@ export async function handleServeCommand(
 	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.`,
-			)
-		}
-
+		handles.push(await runWithStorage(resolved, mode))
 		await waitForShutdown()
 	} finally {
 		for (const h of handles.reverse()) {
@@ -169,11 +164,28 @@ function deriveSqliteFilename(dataDir: string, chain: string): string {
 	return join(dataDir, `wallet-${chain}.db`)
 }
 
+function resolveWalletStorageConfig(
+	resolved: ResolvedServe,
+): NodeWalletStorageConfig {
+	const storage = resolved.storage
+	if (storage.provider === 'bun-sqlite') {
+		return { provider: 'bun-sqlite', filename: resolved.sqliteFilename }
+	}
+	if (storage.provider === 'knex-pg') {
+		return { provider: 'knex-pg', dbUrl: storage.dbUrl }
+	}
+	fatal(
+		`server.storage.provider '${storage.provider}' is not supported. Use 'bun-sqlite' or 'knex-pg'.`,
+	)
+}
+
 function resolveAccounts(accounts?: ServerAccountsConfig): ResolvedAccounts {
 	return {
 		enabled: accounts?.enabled ?? false,
 		baselineBytes: accounts?.baselineBytes ?? DEFAULT_BASELINE_BYTES,
-		satsPerGb: accounts?.satsPerGb ?? DEFAULT_SATS_PER_GB,
+		purchaseUnitBytes:
+			accounts?.purchaseUnitBytes ?? DEFAULT_PURCHASE_UNIT_BYTES,
+		satsPerUnit: accounts?.satsPerUnit ?? DEFAULT_SATS_PER_UNIT,
 		durationBlocks: accounts?.durationBlocks ?? DEFAULT_DURATION_BLOCKS,
 		freeIdentityKeys: accounts?.freeIdentityKeys ?? [],
 	}
@@ -184,25 +196,33 @@ interface Stoppable {
 }
 
 /**
- * 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>`.
+ * Construct the wallet via the same `createNodeWallet` factory the CLI
+ * uses, with storage provider (bun-sqlite / knex-pg) chosen from config.
+ * Server + monitor operate on that single wallet instance, so
+ * `activeRemote`, `backups`, and `storageIdentityKey` behave identically
+ * to `1sat wallet <command>`.
  */
-async function runBunSqlite(
+async function runWithStorage(
 	resolved: ResolvedServe,
 	mode: ServeMode,
 ): Promise<Stoppable> {
+	const storage = resolveWalletStorageConfig(resolved)
 	const walletResult = await createNodeWallet({
 		privateKey: resolved.privateKey,
 		chain: resolved.chain,
 		storageIdentityKey: resolved.storageIdentityKey,
-		filename: resolved.sqliteFilename,
+		storage,
 		activeRemote: resolved.activeRemote,
 		backups: resolved.backups,
+		// Server owns the monitor loop; suppress the factory's initial
+		// runOnce so CLI invocations in the same data dir don't race with it.
+		skipInitialMonitor: mode !== 'wallet',
 	})
 
-	const accounts = await buildAccountsForServer(resolved)
+	const accounts =
+		mode === 'monitor'
+			? undefined
+			: await buildAccountsForServer(resolved, walletResult)
 
 	const serverHandle =
 		mode === 'monitor'
@@ -210,7 +230,13 @@ async function runBunSqlite(
 			: await startWalletServer(resolved, walletResult, accounts)
 
 	if (mode !== 'wallet') {
-		await walletResult.monitor.startTasks()
+		// startTasks loops until stopTasks flips its flag. Fire without
+		// awaiting so the caller can install shutdown handlers and write
+		// the monitor pid file.
+		walletResult.monitor.startTasks().catch((err: unknown) => {
+			console.error('[monitor] task loop exited:', err)
+		})
+		writeMonitorPid(resolved.dataDir)
 		console.log('[monitor] started')
 	}
 
@@ -218,9 +244,11 @@ async function runBunSqlite(
 		async stop() {
 			if (mode !== 'wallet') {
 				walletResult.monitor.stopTasks()
+				clearMonitorPid(resolved.dataDir)
 			}
 			if (serverHandle) await serverHandle.stop()
-			if (accounts) await accounts.knex.destroy()
+			// Accounts shares the wallet's connection — walletResult.destroy
+			// below closes it. No separate teardown needed.
 			await walletResult.destroy()
 		},
 	}
@@ -232,8 +260,9 @@ async function startWalletServer(
 	accounts: AccountsRuntime | undefined,
 ): Promise<{ stop(): Promise<void> }> {
 	const handle = createWalletServer({
-		storage: walletResult.storage,
-		serverPrivateKey: resolved.privateKey.toHex(),
+		wallet: walletResult.wallet,
+		storage: walletResult.getActiveStorage(),
+		serverIdentityKey: walletResult.wallet.identityKey,
 		listen: { port: resolved.port, host: resolved.host },
 		publicPath: '/',
 		internalPath: null,
@@ -249,38 +278,27 @@ interface AccountsRuntime {
 	walletServerAccounts: NonNullable<
 		Parameters<typeof createWalletServer>[0]['accounts']
 	>
-	knex: Knex
 }
 
 async function buildAccountsForServer(
 	resolved: ResolvedServe,
+	walletResult: NodeWalletResult,
 ): 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)
+	// When the wallet is remote-primary the server is fronting someone else's
+	// storage; accounts semantics don't apply.
+	if (resolved.activeRemote) return undefined
 
 	return {
-		knex: accountsKnex,
 		walletServerAccounts: {
 			config: {
-				enabled: true,
+				enabled: resolved.accounts.enabled,
 				baselineBytes: resolved.accounts.baselineBytes,
-				satsPerGb: resolved.accounts.satsPerGb,
+				purchaseUnitBytes: resolved.accounts.purchaseUnitBytes,
+				satsPerUnit: resolved.accounts.satsPerUnit,
 				durationBlocks: resolved.accounts.durationBlocks,
 				freeIdentityKeys: resolved.accounts.freeIdentityKeys,
 			},
-			knex: accountsKnex,
-			currentBlock: () => services.chaintracks.currentHeight(),
+			currentBlock: () => walletResult.services.chaintracks.currentHeight(),
 		},
 	}
 }

package/src/config.ts

@@ -15,10 +15,6 @@ 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). */
@@ -27,7 +23,6 @@ export interface ServerStorageKnexPgConfig {
 
 export type ServerStorageConfig =
 	| ServerStorageBunSqliteConfig
-	| ServerStorageKnexSqliteConfig
 	| ServerStorageKnexPgConfig
 
 export interface ServerAccountsConfig {
@@ -35,8 +30,10 @@ export interface ServerAccountsConfig {
 	enabled?: boolean
 	/** Free baseline per identity key, in bytes. */
 	baselineBytes?: number
-	/** Sats charged per GB of paid capacity per `durationBlocks`. */
-	satsPerGb?: number
+	/** Purchase chunk size in bytes. Deficits round up to whole chunks. Defaults to 1 GB. */
+	purchaseUnitBytes?: number
+	/** Sats charged per purchase unit. */
+	satsPerUnit?: number
 	/** Block window a payment remains valid for. */
 	durationBlocks?: number
 	/** Identity keys that bypass metering (server's own key is auto-added). */

package/src/context.ts

@@ -8,6 +8,7 @@ import { type OneSatContext, createContext } from '@1sat/actions'
 import { type NodeWalletResult, createNodeWallet } from '@1sat/wallet-node'
 import type { PrivateKey } from '@bsv/sdk'
 import { ensureDataDir, loadConfig } from './config'
+import { readLiveMonitorPid } from './monitor-lock'
 
 /** Extended context that includes cleanup */
 export interface CliContext {
@@ -36,13 +37,19 @@ export async function loadContext(
 
 	const storageIdentityKey = config.storageIdentityKey ?? '1sat-cli-default'
 
+	const skipInitialMonitor = readLiveMonitorPid(dataDir) !== undefined
+
 	const walletResult = await createNodeWallet({
 		privateKey,
 		chain: opts.chain,
 		storageIdentityKey,
-		filename: `${dataDir}/wallet-${opts.chain}.db`,
+		storage: {
+			provider: 'bun-sqlite',
+			filename: `${dataDir}/wallet-${opts.chain}.db`,
+		},
 		activeRemote: config.activeRemote,
 		backups: config.backups,
+		skipInitialMonitor,
 	})
 
 	const ctx = createContext(walletResult.wallet, {

package/src/monitor-lock.ts

@@ -0,0 +1,50 @@
+/**
+ * PID lock file coordinating a single monitor owner across CLI invocations
+ * and a long-running `1sat serve` process.
+ *
+ * - `1sat serve` (modes that run the monitor) writes the pid on startup and
+ *   removes it on clean shutdown.
+ * - CLI invocations read the file and, if the pid is alive, skip firing
+ *   their own `monitor.runOnce()` to avoid duplicate work against the same
+ *   SQLite file.
+ */
+
+import { readFileSync, unlinkSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export const MONITOR_PID_FILENAME = 'monitor.pid'
+
+export function monitorPidPath(dataDir: string): string {
+	return join(dataDir, MONITOR_PID_FILENAME)
+}
+
+export function writeMonitorPid(
+	dataDir: string,
+	pid: number = process.pid,
+): void {
+	writeFileSync(monitorPidPath(dataDir), `${pid}\n`, 'utf8')
+}
+
+export function clearMonitorPid(dataDir: string): void {
+	try {
+		unlinkSync(monitorPidPath(dataDir))
+	} catch {}
+}
+
+/** Returns the pid of a live monitor owner, or undefined if none. */
+export function readLiveMonitorPid(dataDir: string): number | undefined {
+	let raw: string
+	try {
+		raw = readFileSync(monitorPidPath(dataDir), 'utf8')
+	} catch {
+		return undefined
+	}
+	const pid = Number.parseInt(raw.trim(), 10)
+	if (!Number.isInteger(pid) || pid <= 0) return undefined
+	try {
+		process.kill(pid, 0)
+		return pid
+	} catch {
+		return undefined
+	}
+}