@thetanuts-finance/odette-cli 0.0.0-stage → 0.1.0

package/dist/commands/config.js

@@ -0,0 +1,299 @@
+import fs from 'node:fs';
+import { ethers } from 'ethers';
+import { ODETTE_REFERRER } from '@thetanuts-finance/odette-sdk';
+import { defaultConfigPath, loadConfig, saveConfig, stopForDryRun, } from '../config.js';
+import { DEFAULT_CHAIN_ID, DEFAULT_RPC_URL } from '../defaults.js';
+import { getGlobalOpts } from '../options.js';
+import { render, renderError, redactSecrets } from '../output.js';
+/**
+ * Read all bytes from stdin and return as a UTF-8 string. Used by
+ * `config set privateKey -` to accept the key over a pipe instead of as an
+ * argv positional (which would leak into shell history, ps aux, and terminal
+ * scrollback). Mirrors the OpenClaw `import-wallet.js --stdin` pattern.
+ */
+async function readStdin() {
+    if (process.stdin.isTTY) {
+        throw new Error('Expected input on stdin but stdin is a TTY. Example:\n' +
+            '  printf "%s" "$KEY" | odette config set privateKey -\n' +
+            'Or use `odette wallet import` for an interactive prompt.');
+    }
+    return new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', reject);
+    });
+}
+const ALLOWED_KEYS = [
+    'chainId',
+    'rpcUrl',
+    'privateKey',
+];
+/** Refusal for `config set|unset referrer`. The referrer is a constant. */
+function referrerIsFixed() {
+    process.stderr.write(`The Odette referrer is fixed (${ODETTE_REFERRER}). It cannot be set, changed or removed.\n`);
+    process.exit(2);
+}
+const PRIVATE_KEY_REGEX = /^0x[0-9a-fA-F]{64}$/;
+function isAllowedKey(key) {
+    return ALLOWED_KEYS.includes(key);
+}
+function maskPrivateKey(pk) {
+    if (!pk)
+        return '<not set>';
+    if (pk.length < 6)
+        return '0x…';
+    return `0x…${pk.slice(-4)}`;
+}
+/**
+ * Show an RPC URL without its path or query: hosted RPC URLs carry the API key
+ * there (for example /v2/<key>). `https://mainnet.base.org` prints unchanged.
+ */
+function maskRpcUrl(url) {
+    try {
+        const u = new URL(url);
+        const hidden = (u.pathname !== '/' && u.pathname !== '') || u.search !== '' || u.username !== '';
+        return hidden ? `${u.protocol}//${u.host}/… (path and query hidden)` : `${u.protocol}//${u.host}`;
+    }
+    catch {
+        return '<invalid URL>';
+    }
+}
+function emptyConfig() {
+    return {
+        version: 1,
+        chainId: DEFAULT_CHAIN_ID,
+        rpcUrl: DEFAULT_RPC_URL,
+    };
+}
+function parseValue(key, value) {
+    if (key === 'chainId') {
+        const n = Number.parseInt(value, 10);
+        if (n !== DEFAULT_CHAIN_ID) {
+            throw Object.assign(new Error(`chainId must be ${DEFAULT_CHAIN_ID} (Base). Odette trades on Base only. Got "${value}".`), { exitCode: 2 });
+        }
+        return n;
+    }
+    if (key === 'privateKey') {
+        if (!PRIVATE_KEY_REGEX.test(value)) {
+            throw Object.assign(new Error('privateKey must be a 0x-prefixed 64-char hex string'), { exitCode: 2 });
+        }
+        return value;
+    }
+    if (key === 'rpcUrl') {
+        // Same rule as at use time (client.ts): https, or localhost for dev.
+        let parsed;
+        try {
+            parsed = new URL(value);
+        }
+        catch {
+            throw Object.assign(new Error('rpcUrl is not a valid URL.'), { exitCode: 2 });
+        }
+        const local = parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1';
+        if (!(parsed.protocol === 'https:' || (parsed.protocol === 'http:' && local))) {
+            throw Object.assign(new Error(`rpcUrl must use https:// (got ${parsed.protocol}//${parsed.host}).`), { exitCode: 2 });
+        }
+        return value;
+    }
+    return value;
+}
+export function register(program) {
+    const grp = program
+        .command('config')
+        .description('Inspect, get, set, or unset persisted CLI configuration');
+    grp
+        .command('show')
+        .description('Print the current configuration (private key masked)')
+        .action(async (_localOpts, cmd) => {
+        const opts = getGlobalOpts(cmd);
+        try {
+            const path = opts.config ?? defaultConfigPath();
+            const cfg = loadConfig(path);
+            if (!cfg) {
+                render({ path, exists: false }, { output: opts.output, noColor: !opts.color });
+                return;
+            }
+            const masked = {
+                version: cfg.version,
+                chainId: cfg.chainId,
+                rpcUrl: maskRpcUrl(cfg.rpcUrl),
+                privateKey: maskPrivateKey(cfg.privateKey),
+                referrer: `${ODETTE_REFERRER} (fixed)`,
+                path,
+            };
+            render(masked, { output: opts.output, noColor: !opts.color });
+        }
+        catch (err) {
+            renderError(err, { jsonErrors: Boolean(opts.jsonErrors), noColor: !opts.color });
+            process.exit(err.exitCode ?? 1);
+        }
+    });
+    grp
+        .command('path')
+        .description('Print the config file path')
+        .action(async (_localOpts, cmd) => {
+        const opts = getGlobalOpts(cmd);
+        try {
+            const path = opts.config ?? defaultConfigPath();
+            render(path, { output: opts.output, noColor: !opts.color });
+        }
+        catch (err) {
+            renderError(err, { jsonErrors: Boolean(opts.jsonErrors), noColor: !opts.color });
+            process.exit(err.exitCode ?? 1);
+        }
+    });
+    grp
+        .command('set <key> <value>')
+        .description('Set one config field (chainId, rpcUrl, privateKey). The referrer is fixed and cannot be set. ' +
+        'For privateKey, only `-` (read from stdin) is accepted — argv would leak the key via shell history.')
+        .action(async (key, value, _localOpts, cmd) => {
+        const opts = getGlobalOpts(cmd);
+        try {
+            if (key === 'referrer')
+                referrerIsFixed();
+            if (!isAllowedKey(key)) {
+                process.stderr.write(`Unknown config key "${key}". Allowed: ${ALLOWED_KEYS.join(', ')}\n`);
+                process.exit(2);
+            }
+            if (stopForDryRun(opts.dryRun, `config set ${key}`, opts.config ?? defaultConfigPath()))
+                return;
+            // SECURITY: reject argv for privateKey. The shell records argv in
+            // history (~/.zsh_history, ~/.bash_history), and the running process
+            // is visible in `ps aux` for its lifetime. Either route is a key-leak
+            // vector that the safer commands (`wallet import`, `setup`) avoid by
+            // reading via masked prompt. Mirror that here by accepting only:
+            //   - `-`        → read the key from stdin (pipe / heredoc / here-string)
+            //   - anything else → hard refusal
+            // The plain-argv path was the same footgun TODO §8 cited when it
+            // chose to ship import-only over BIP-39 wallet generation in v0.1.0.
+            let effectiveValue = value;
+            if (key === 'privateKey') {
+                if (value !== '-') {
+                    throw new Error('Refusing to read a private key from argv — it would land in shell\n' +
+                        'history, ps aux, and terminal scrollback. Use one of:\n' +
+                        '  1. `odette wallet import`                       (recommended; interactive, masked)\n' +
+                        '  2. `odette config set privateKey - <<< "$KEY"`  (read from stdin, no argv exposure)\n' +
+                        '  3. `ODETTE_PRIVATE_KEY=$KEY odette ...`         (env var, per-invocation)');
+                }
+                effectiveValue = (await readStdin()).trim();
+            }
+            const path = opts.config ?? defaultConfigPath();
+            const cfg = loadConfig(path) ?? emptyConfig();
+            const parsed = parseValue(key, effectiveValue);
+            // Assign with a typed cast — Config field types vary per key.
+            cfg[key] = parsed;
+            saveConfig(cfg, path);
+            render({
+                key,
+                value: key === 'privateKey' ? maskPrivateKey(String(parsed)) : key === 'rpcUrl' ? maskRpcUrl(String(parsed)) : parsed,
+                path,
+            }, { output: opts.output, noColor: !opts.color });
+        }
+        catch (err) {
+            renderError(err, { jsonErrors: Boolean(opts.jsonErrors), noColor: !opts.color });
+            process.exit(err.exitCode ?? 1);
+        }
+    });
+    grp
+        .command('unset <key>')
+        .description('Remove one config field')
+        .action(async (key, _localOpts, cmd) => {
+        const opts = getGlobalOpts(cmd);
+        try {
+            if (key === 'referrer')
+                referrerIsFixed();
+            if (!isAllowedKey(key)) {
+                process.stderr.write(`Unknown config key "${key}". Allowed: ${ALLOWED_KEYS.join(', ')}\n`);
+                process.exit(2);
+            }
+            const path = opts.config ?? defaultConfigPath();
+            if (stopForDryRun(opts.dryRun, `config unset ${key}`, path))
+                return;
+            const cfg = loadConfig(path);
+            if (!cfg) {
+                process.stderr.write(`No config file at ${path}\n`);
+                process.exit(4);
+            }
+            // chainId and rpcUrl are required fields; rather than `delete` them, reset to defaults.
+            if (key === 'chainId') {
+                cfg.chainId = DEFAULT_CHAIN_ID;
+            }
+            else if (key === 'rpcUrl') {
+                cfg.rpcUrl = DEFAULT_RPC_URL;
+            }
+            else {
+                delete cfg[key];
+            }
+            saveConfig(cfg, path);
+            render({ key, unset: true, path }, { output: opts.output, noColor: !opts.color });
+        }
+        catch (err) {
+            renderError(err, { jsonErrors: Boolean(opts.jsonErrors), noColor: !opts.color });
+            process.exit(err.exitCode ?? 1);
+        }
+    });
+    grp
+        .command('validate')
+        .description('Ensure RPC is reachable and the private key (if any) is valid')
+        .action(async (_localOpts, cmd) => {
+        const opts = getGlobalOpts(cmd);
+        try {
+            const path = opts.config ?? defaultConfigPath();
+            if (!fs.existsSync(path)) {
+                process.stderr.write(`No config file at ${path}\n`);
+                process.exit(4);
+            }
+            const cfg = loadConfig(path);
+            if (!cfg) {
+                process.stderr.write(`Could not parse config at ${path}\n`);
+                process.exit(4);
+            }
+            const rpcUrl = cfg.rpcUrl;
+            let chainId;
+            try {
+                const provider = new ethers.JsonRpcProvider(rpcUrl);
+                const network = await provider.getNetwork();
+                chainId = Number(network.chainId);
+                if (chainId !== cfg.chainId) {
+                    process.stderr.write(`Chain id mismatch: RPC reports ${chainId}, config says ${cfg.chainId}\n`);
+                    process.exit(4);
+                }
+            }
+            catch (err) {
+                const msg = err.message ?? String(err);
+                process.stderr.write(`RPC unreachable: ${redactSecrets(msg)}\n`);
+                process.exit(4);
+            }
+            let address;
+            if (cfg.privateKey !== undefined) {
+                // Check the shape ourselves and print a fixed message. ethers' error
+                // for an odd-length value echoes the whole value, i.e. the key.
+                if (typeof cfg.privateKey !== 'string' || !PRIVATE_KEY_REGEX.test(cfg.privateKey)) {
+                    process.stderr.write('Private key invalid: expected a 0x-prefixed 64-character hex string.\n');
+                    process.exit(4);
+                }
+                try {
+                    address = new ethers.Wallet(cfg.privateKey).address;
+                }
+                catch {
+                    process.stderr.write('Private key invalid: not a usable secp256k1 key.\n');
+                    process.exit(4);
+                }
+            }
+            render({
+                path,
+                chainId,
+                rpcUrl,
+                address: address ?? '<no signer>',
+                valid: true,
+            }, { output: opts.output, noColor: !opts.color });
+        }
+        catch (err) {
+            renderError(err, { jsonErrors: Boolean(opts.jsonErrors), noColor: !opts.color });
+            process.exit(err.exitCode ?? 1);
+        }
+    });
+}

package/dist/commands/registry.js

@@ -0,0 +1,14 @@
+import * as setup from './setup.js';
+import * as config from './config.js';
+import * as wallet from './wallet.js';
+import * as book from './book.js';
+/**
+ * Centralized command registration. Each module under `commands/` exports a
+ * `register(program)` function that attaches its subcommand tree to the root.
+ */
+export function registerCommands(program) {
+    setup.register(program);
+    config.register(program);
+    wallet.register(program);
+    book.register(program);
+}

package/dist/commands/setup.js

@@ -0,0 +1,221 @@
+// Adapted from thetanuts-sdk cli/src/commands/setup.ts at 9e72aef1ab5c008ccc92352fa5048bd08c452ede.
+// MIT License, Copyright (c) 2026 Thetanuts Finance.
+// Changes: no referrer prompt (the Odette referrer is fixed and is shown in the
+// summary); names; config errors exit 4; `--dry-run` writes nothing.
+// RPC error text is redacted before it is printed.
+import fs from 'node:fs';
+import prompts from 'prompts';
+import { ethers } from 'ethers';
+import { ODETTE_REFERRER } from '@thetanuts-finance/odette-sdk';
+import { defaultConfigPath, loadConfig, saveConfig, stopForDryRun } from '../config.js';
+import { DEFAULT_CHAIN_ID, DEFAULT_RPC_URL } from '../defaults.js';
+import { getGlobalOpts } from '../options.js';
+import { getClient } from '../client.js';
+import { render, renderError, redactSecrets } from '../output.js';
+const PRIVATE_KEY_REGEX = /^0x[0-9a-fA-F]{64}$/;
+function checkNodeVersion() {
+    const v = process.versions.node;
+    const major = Number.parseInt(v.split('.')[0] ?? '0', 10);
+    if (Number.isNaN(major) || major < 18) {
+        throw new Error(`Node.js >= 18 is required, but found ${v}`);
+    }
+}
+async function promptPrivateKey() {
+    // Re-prompt until valid or aborted.
+    while (true) {
+        const response = await prompts({
+            type: 'password',
+            name: 'pk',
+            message: 'Paste your private key (input hidden)',
+        });
+        const pk = response.pk;
+        if (!pk) {
+            throw new Error('Setup aborted (no private key provided)');
+        }
+        if (!PRIVATE_KEY_REGEX.test(pk)) {
+            process.stderr.write('Invalid private key. Expect a 0x-prefixed 64-char hex string.\n');
+            continue;
+        }
+        return pk;
+    }
+}
+async function promptAndValidateRpc(defaultUrl = DEFAULT_RPC_URL, expectedChainId = DEFAULT_CHAIN_ID) {
+    while (true) {
+        const response = await prompts({
+            type: 'text',
+            name: 'url',
+            message: 'RPC URL',
+            initial: defaultUrl,
+        });
+        const url = response.url?.trim();
+        if (!url) {
+            throw new Error('Setup aborted (no RPC URL provided)');
+        }
+        try {
+            const provider = new ethers.JsonRpcProvider(url);
+            const network = await provider.getNetwork();
+            const actual = Number(network.chainId);
+            if (actual !== expectedChainId) {
+                process.stderr.write(`RPC chain id mismatch: got ${actual}, expected ${expectedChainId}. Try a different URL.\n`);
+                continue;
+            }
+            return url;
+        }
+        catch (err) {
+            const msg = err.message ?? String(err);
+            process.stderr.write(`RPC connection failed: ${redactSecrets(msg)}\nTry a different URL.\n`);
+            continue;
+        }
+    }
+}
+export function register(program) {
+    program
+        .command('setup')
+        .description('Interactive first-run setup: wallet and Base RPC URL')
+        .action(async (_localOpts, cmd) => {
+        const opts = getGlobalOpts(cmd);
+        try {
+            if (stopForDryRun(opts.dryRun, 'setup', opts.config ?? defaultConfigPath()))
+                return;
+            process.stdout.write('Odette CLI setup\n');
+            process.stdout.write('----------------\n');
+            process.stdout.write(`Referrer for every fill (fixed): ${ODETTE_REFERRER}\n`);
+            checkNodeVersion();
+            const cfgPath = opts.config ?? defaultConfigPath();
+            if (fs.existsSync(cfgPath)) {
+                const ow = await prompts({
+                    type: 'confirm',
+                    name: 'ok',
+                    message: `Config exists at ${cfgPath}. Overwrite?`,
+                    initial: false,
+                });
+                if (!ow.ok) {
+                    process.stderr.write('Aborted.\n');
+                    process.exit(3);
+                }
+            }
+            // Existing config (if any) gives sensible defaults.
+            const existing = loadConfig(cfgPath) ?? null;
+            const mode = await prompts({
+                type: 'select',
+                name: 'value',
+                message: 'How would you like to configure a wallet?',
+                choices: [
+                    { title: 'Create a new wallet (random key, saved locally)', value: 'create' },
+                    { title: 'Import an existing private key', value: 'import' },
+                    { title: 'Skip — read-only mode', value: 'skip' },
+                ],
+                initial: 0,
+            });
+            if (mode.value === undefined) {
+                throw new Error('Setup aborted');
+            }
+            let privateKey;
+            if (mode.value === 'create') {
+                // Generate in memory → give user a single chance
+                // to back up the mnemonic → save raw key to disk. Once the user
+                // acknowledges (or declines backup), the mnemonic is unrecoverable.
+                const wallet = ethers.Wallet.createRandom();
+                privateKey = wallet.privateKey;
+                const mnemonic = wallet.mnemonic?.phrase;
+                process.stdout.write(`\nGenerated new wallet\n`);
+                process.stdout.write(`  Address: ${wallet.address}\n\n`);
+                process.stdout.write('You have ONE chance to back up the mnemonic before it is discarded.\n' +
+                    'Anyone with this mnemonic (or the saved private key) controls the wallet.\n\n');
+                const showBackup = await prompts({
+                    type: 'confirm',
+                    name: 'show',
+                    message: 'Display mnemonic phrase now for backup?',
+                    initial: false,
+                });
+                if (showBackup.show && mnemonic) {
+                    process.stdout.write(`\n  ${mnemonic}\n\n`);
+                    const ack = await prompts({
+                        type: 'confirm',
+                        name: 'ok',
+                        message: 'I have written down the mnemonic somewhere safe',
+                        initial: false,
+                    });
+                    if (!ack.ok) {
+                        process.stderr.write('Aborting setup. Wallet was NOT saved. Re-run `odette setup` to try again.\n');
+                        process.exit(3);
+                    }
+                }
+                process.stdout.write('Saving wallet to config...\n');
+            }
+            else if (mode.value === 'import') {
+                privateKey = await promptPrivateKey();
+            }
+            // hardcode Base chain for current setup of CLI (since v4 mostly on Base)
+            const chainId = 8453;
+            const defaultRpc = existing?.rpcUrl ?? DEFAULT_RPC_URL;
+            const rpcUrl = await promptAndValidateRpc(defaultRpc, chainId);
+            // Persist. Preserve unrelated fields from any prior config.
+            const keep = privateKey ?? existing?.privateKey;
+            const newCfg = {
+                version: 1,
+                chainId,
+                rpcUrl,
+                ...(keep ? { privateKey: keep } : {}),
+            };
+            saveConfig(newCfg, cfgPath);
+            process.stdout.write(`Saved to ${cfgPath}\n`);
+            // If a key was imported, show wallet summary.
+            if (privateKey) {
+                try {
+                    const { client } = getClient({ ...opts, config: cfgPath });
+                    const address = await client.getSignerAddress();
+                    const tokens = client.chainConfig.tokens;
+                    const optionBookAddr = client.chainConfig.contracts.optionBook;
+                    const usdc = tokens.USDC;
+                    const provider = new ethers.JsonRpcProvider(rpcUrl);
+                    const ethBal = await provider.getBalance(address);
+                    let usdcBalanceStr = '<n/a>';
+                    let approvalStr = '<n/a>';
+                    if (usdc) {
+                        const balance = await client.erc20.getBalance(usdc.address, address);
+                        usdcBalanceStr = client.utils.fromBigInt(balance, Number(usdc.decimals));
+                        if (optionBookAddr) {
+                            const allowance = await client.erc20.getAllowance(usdc.address, address, optionBookAddr);
+                            approvalStr =
+                                allowance === 0n
+                                    ? 'not approved'
+                                    : `approved (${client.utils.fromBigInt(allowance, Number(usdc.decimals))})`;
+                        }
+                        else {
+                            approvalStr = 'optionBook not deployed on this chain';
+                        }
+                    }
+                    const summary = {
+                        address,
+                        referrer: ODETTE_REFERRER,
+                        eth: client.utils.fromBigInt(ethBal, 18),
+                        usdc: usdcBalanceStr,
+                        optionBookApproval: approvalStr,
+                    };
+                    render(summary, { output: opts.output, noColor: !opts.color });
+                }
+                catch (err) {
+                    // Don't fail setup if the post-save wallet check fails — config is already written.
+                    const msg = err.message ?? String(err);
+                    process.stderr.write(`Warning: could not fetch wallet summary: ${redactSecrets(msg)}\n`);
+                }
+            }
+            else {
+                if (existing?.privateKey) {
+                    // Skip keeps the saved wallet (deleting it could destroy the only
+                    // copy of a key). Say so; upstream printed "Read-only mode" here.
+                    process.stdout.write('No new wallet. The existing wallet in this config is kept and can still sign. ' +
+                        'To remove it, run `odette wallet reset`.\n');
+                }
+                else {
+                    process.stdout.write('Read-only mode. Run `odette wallet import` later to add a key.\n');
+                }
+            }
+        }
+        catch (err) {
+            renderError(err, { jsonErrors: Boolean(opts.jsonErrors), noColor: !opts.color });
+            process.exit(err.exitCode ?? 1);
+        }
+    });
+}