@1sat/cli 0.0.1

package/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "@1sat/cli",
+	"version": "0.0.1",
+	"description": "CLI for 1Sat Ordinals SDK",
+	"type": "module",
+	"main": "./src/cli.ts",
+	"bin": {
+		"1sat": "./src/cli.ts"
+	},
+	"files": ["src", "bin"],
+	"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.52",
+		"@1sat/client": "0.0.15",
+		"@1sat/types": "0.0.13",
+		"@1sat/wallet-node": "0.0.11",
+		"@bsv/sdk": "^2.0.4",
+		"chalk": "^5.0.0",
+		"@clack/prompts": "^0.8.0",
+		"bitcoin-backup": "^0.0.8"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.3.9",
+		"typescript": "^5.9.3"
+	}
+}

package/src/args.ts

@@ -0,0 +1,100 @@
+/**
+ * Argument parsing utilities for the 1sat CLI.
+ *
+ * Pure manual parsing - no frameworks. Follows clawnet pattern.
+ */
+
+export interface GlobalFlags {
+	json: boolean
+	quiet: boolean
+	yes: boolean
+	chain: 'main' | 'test'
+	help: boolean
+	version: boolean
+	rest: string[]
+}
+
+/**
+ * Parse global flags from raw argv, returning structured flags and remaining args.
+ */
+export function parseGlobalFlags(args: string[]): GlobalFlags {
+	let json = false
+	let quiet = false
+	let yes = false
+	let chain: 'main' | 'test' = 'main'
+	let help = false
+	let version = false
+	const rest: string[] = []
+	const skip = new Set<number>()
+
+	for (let i = 0; i < args.length; i++) {
+		if (skip.has(i)) continue
+
+		const arg = args[i]
+
+		switch (arg) {
+			case '--json':
+				json = true
+				break
+			case '--quiet':
+			case '-q':
+				quiet = true
+				break
+			case '--yes':
+			case '-y':
+				yes = true
+				break
+			case '--chain': {
+				const value = args[i + 1]
+				if (value === 'main' || value === 'test') {
+					chain = value
+					skip.add(i + 1)
+				} else {
+					throw new Error(
+						`Invalid chain value: ${value}. Must be 'main' or 'test'.`,
+					)
+				}
+				break
+			}
+			case '--help':
+			case '-h':
+				help = true
+				break
+			case '--version':
+			case '-v':
+				version = true
+				break
+			default:
+				rest.push(arg)
+		}
+	}
+
+	return { json, quiet, yes, chain, help, version, rest }
+}
+
+/**
+ * Extract a named flag value from args.
+ * Returns the value following the flag, or undefined if not found.
+ */
+export function extractFlag(args: string[], flag: string): string | undefined {
+	const idx = args.indexOf(flag)
+	if (idx === -1 || idx + 1 >= args.length) return undefined
+	return args[idx + 1]
+}
+
+/**
+ * Check if a boolean flag is present.
+ */
+export function hasFlag(args: string[], flag: string): boolean {
+	return args.includes(flag)
+}
+
+/**
+ * Extract positional arguments, skipping flag indices.
+ */
+export function extractPositional(
+	args: string[],
+	skipIndices: Set<number>,
+): string[] {
+	return args.filter((arg, i) => !arg.startsWith('--') && !skipIndices.has(i))
+}

package/src/cli.ts

@@ -0,0 +1,105 @@
+#!/usr/bin/env bun
+
+/**
+ * 1sat CLI - Command-line interface for 1Sat Ordinals SDK.
+ *
+ * Pure Bun CLI with manual arg parsing. No frameworks.
+ */
+
+import { parseGlobalFlags } from './args'
+import { handleActionCommand } from './commands/action'
+import { handleConfigCommand } from './commands/config'
+import { handleIdentityCommand } from './commands/identity'
+import { handleInitCommand } from './commands/init'
+import { handleLocksCommand } from './commands/locks'
+import { handleOpnsCommand } from './commands/opns'
+import { handleOrdinalsCommand } from './commands/ordinals'
+import { handleSocialCommand } from './commands/social'
+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 { formatError } from './output'
+
+const rawArgs = process.argv.slice(2)
+
+async function main(): Promise<void> {
+	const flags = parseGlobalFlags(rawArgs)
+
+	if (flags.version) {
+		printVersion()
+		process.exit(0)
+	}
+
+	const [command, ...rest] = flags.rest
+
+	if (!command || flags.help) {
+		printHelp()
+		process.exit(0)
+	}
+
+	switch (command) {
+		case 'init':
+			await handleInitCommand(rest, flags)
+			break
+
+		case 'config':
+			await handleConfigCommand(rest, flags)
+			break
+
+		case 'wallet':
+			await handleWalletCommand(rest, flags)
+			break
+
+		case 'ordinals':
+			await handleOrdinalsCommand(rest, flags)
+			break
+
+		case 'tokens':
+			await handleTokensCommand(rest, flags)
+			break
+
+		case 'locks':
+			await handleLocksCommand(rest, flags)
+			break
+
+		case 'identity':
+			await handleIdentityCommand(rest, flags)
+			break
+
+		case 'social':
+			await handleSocialCommand(rest, flags)
+			break
+
+		case 'opns':
+			await handleOpnsCommand(rest, flags)
+			break
+
+		case 'sweep':
+			await handleSweepCommand(rest, flags)
+			break
+
+		case 'action':
+			await handleActionCommand(rest, flags)
+			break
+
+		case 'tx':
+			await handleTxCommand(rest, flags)
+			break
+
+		case 'help':
+			printHelp()
+			break
+
+		default:
+			console.error(formatError(`Unknown command: ${command}`))
+			printHelp()
+			process.exit(1)
+	}
+}
+
+main().catch((err) => {
+	console.error(formatError(`Error: ${err.message}`))
+	process.exit(1)
+})

package/src/commands/action.ts

@@ -0,0 +1,79 @@
+/**
+ * Generic action executor.
+ *
+ * Run any registered action by name with JSON input.
+ * Useful for scripting and testing.
+ */
+
+import { actionRegistry } from '@1sat/actions'
+import type { GlobalFlags } from '../args'
+import { loadContext } from '../context'
+import { loadKey, resolvePassword } from '../keys'
+import { fatal, output } from '../output'
+
+export async function handleActionCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [actionName, jsonInput] = args
+
+	if (!actionName) {
+		// List available actions
+		const actions = actionRegistry.list()
+		if (opts.json) {
+			output(
+				actions.map((a) => ({
+					name: a.meta.name,
+					description: a.meta.description,
+					category: a.meta.category,
+				})),
+				opts,
+			)
+			return
+		}
+
+		console.log('\nRegistered actions:\n')
+		const grouped = new Map<string, typeof actions>()
+		for (const action of actions) {
+			const cat = action.meta.category
+			if (!grouped.has(cat)) grouped.set(cat, [])
+			grouped.get(cat)!.push(action)
+		}
+		for (const [category, categoryActions] of grouped) {
+			console.log(`  ${category}:`)
+			for (const a of categoryActions) {
+				console.log(`    ${a.meta.name.padEnd(30)} ${a.meta.description}`)
+			}
+			console.log()
+		}
+		return
+	}
+
+	const action = actionRegistry.get(actionName)
+	if (!action) {
+		fatal(
+			`Unknown action: ${actionName}\n\nRun '1sat action' to list available actions.`,
+		)
+	}
+
+	let input: unknown = {}
+	if (jsonInput) {
+		try {
+			input = JSON.parse(jsonInput)
+		} catch {
+			fatal(`Invalid JSON input: ${jsonInput}`)
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await action.execute(ctx, input)
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}

package/src/commands/config.ts

@@ -0,0 +1,109 @@
+/**
+ * Config command - show, set, and locate configuration.
+ *
+ * Subcommands:
+ *   show   - Display current configuration
+ *   set    - Set a configuration value
+ *   path   - Print config directory path
+ */
+
+import type { GlobalFlags } from '../args'
+import {
+	type OneSatCliConfig,
+	getConfigDir,
+	getConfigFile,
+	loadConfig,
+	updateConfig,
+} from '../config'
+import { printCommandHelp } from '../help'
+import {
+	fatal,
+	formatLabel,
+	formatSuccess,
+	formatValue,
+	output,
+	printKeyValue,
+} from '../output'
+
+const SETTABLE_KEYS: Array<keyof OneSatCliConfig> = [
+	'chain',
+	'dataDir',
+	'remoteStorageUrl',
+	'storageIdentityKey',
+]
+
+export async function handleConfigCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'show':
+			return configShow(opts)
+		case 'set':
+			return configSet(rest, opts)
+		case 'path':
+			return configPath(opts)
+		default:
+			printCommandHelp('config', {
+				show: 'Display current configuration',
+				set: 'Set a config value (e.g. 1sat config set chain test)',
+				path: 'Print config directory path',
+			})
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+function configShow(opts: GlobalFlags): void {
+	const config = loadConfig()
+
+	if (opts.json) {
+		output(config, opts)
+		return
+	}
+
+	console.log()
+	printKeyValue({
+		chain: config.chain,
+		dataDir: config.dataDir,
+		remoteStorageUrl: config.remoteStorageUrl ?? '(not set)',
+		storageIdentityKey: config.storageIdentityKey ?? '(not set)',
+	})
+	console.log()
+	console.log(
+		`  ${formatLabel('config file:')}  ${formatValue(getConfigFile())}`,
+	)
+	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(', ')}`,
+		)
+	}
+
+	if (!SETTABLE_KEYS.includes(key as keyof OneSatCliConfig)) {
+		fatal(
+			`Unknown config key: ${key}\n\nSettable keys: ${SETTABLE_KEYS.join(', ')}`,
+		)
+	}
+
+	// Validate specific keys
+	if (key === 'chain' && value !== 'main' && value !== 'test') {
+		fatal("chain must be 'main' or 'test'")
+	}
+
+	const updated = updateConfig({ [key]: value })
+	output(opts.json ? updated : formatSuccess(`Set ${key} = ${value}`), opts)
+}
+
+function configPath(opts: GlobalFlags): void {
+	const dir = getConfigDir()
+	output(opts.json ? { path: dir } : dir, opts)
+}

package/src/commands/identity.ts

@@ -0,0 +1,133 @@
+/**
+ * Identity commands - create, info, sign, verify.
+ *
+ * BAP (Bitcoin Attestation Protocol) identity management.
+ */
+
+import { publishIdentity, signBsm } from '@1sat/actions'
+import type { GlobalFlags } from '../args'
+import { extractFlag } from '../args'
+import { loadContext } from '../context'
+import { printCommandHelp } from '../help'
+import { loadKey, resolvePassword } from '../keys'
+import { fatal, output, printKeyValue } from '../output'
+
+export async function handleIdentityCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'create':
+			return identityCreate(rest, opts)
+		case 'info':
+			return identityInfo(rest, opts)
+		case 'sign':
+			return identitySign(rest, opts)
+		case 'verify':
+			return identityVerify(rest, opts)
+		default:
+			printCommandHelp('identity', {
+				create: 'Create/publish a BAP identity',
+				info: 'Show BAP identity information',
+				sign: 'Sign a message with identity key (--message <text>)',
+				verify:
+					'Verify a signed message (--message <text> --sig <sig> --address <addr>)',
+			})
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+async function identityCreate(
+	_args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await publishIdentity.execute(ctx, {})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function identityInfo(
+	_args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const { publicKey } = await ctx.wallet.getPublicKey({
+			protocolID: [1, 'bap'],
+			keyID: '1',
+			counterparty: 'self',
+			forSelf: true,
+		})
+
+		if (opts.json) {
+			output({ identityKey: publicKey }, opts)
+		} else {
+			printKeyValue('Identity Key', publicKey)
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function identitySign(args: string[], opts: GlobalFlags): Promise<void> {
+	const message = extractFlag(args, '--message')
+
+	if (!message) fatal('Missing --message <text>')
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await signBsm.execute(ctx, { message })
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function identityVerify(
+	args: string[],
+	_opts: GlobalFlags,
+): Promise<void> {
+	const message = extractFlag(args, '--message')
+	const sig = extractFlag(args, '--sig')
+	const address = extractFlag(args, '--address')
+
+	if (!message) fatal('Missing --message <text>')
+	if (!sig) fatal('Missing --sig <signature>')
+	if (!address) fatal('Missing --address <addr>')
+
+	// BSM verification doesn't need a wallet context — it's pure crypto
+	// Use @bsv/sdk BSM.verify directly
+	fatal(
+		'identity verify is not yet implemented (needs direct BSM.verify integration)',
+	)
+}