@otonix/cli 1.7.0 → 2.1.1

package/README.md

@@ -1,8 +1,6 @@
 # @otonix/cli
 
-Command-line tool for the [Otonix](https://otonix.tech) sovereign compute platform.
-
-Initialize, register, and manage autonomous AI agents from your terminal. Includes built-in access to the Bankr LLM Gateway for multi-model AI inference.
+Otonix CLI — deploy autonomous agent tokens on Base chain via Clanker v3.1 (LP Legacy).
 
 ## Install
 
@@ -10,278 +8,82 @@ Initialize, register, and manage autonomous AI agents from your terminal. Includ
 npm install -g @otonix/cli
 ```
 
-Or run directly:
+Or run locally (dev):
 
 ```bash
-npx @otonix/cli <command>
+bash cli/otonix.sh <command>
 ```
 
 ## Quick Start
 
 ```bash
-# 1. Generate an API key (requires dashboard token)
-otonix keygen my-vps-key
+# 1. Generate a new Base creator wallet
+otonix wallet generate
 
-# 2. Configure the CLI
-otonix init
+# 2. Fund the wallet
+#    → Send ≥200 $OTX (agent activation)
+#    → Send ETH for gas
 
-# 3. Register your agent
-otonix register --name my-agent --model claude-opus-4-6
+# 3. Create an agent (generates isolated Base wallet)
+otonix agent:create --name "MyAgent"
 
-# 4. Start heartbeat loop
-otonix heartbeat:loop
+# 4. Fund agent wallet with ~0.002 ETH (shown after create)
 
-# 5. Log actions
-otonix log "Trade executed BTC/USDC" --category trading
+# 5. Deploy a token!
+otonix launch token \
+  --agent MyAgent \
+  --name "CoolToken" \
+  --ticker "COOL" \
+  --description "My agent token"
 ```
 
 ## Commands
 
-### Setup
-
-| Command | Description |
-|---------|-------------|
-| `otonix init` | Configure API key and endpoint interactively |
-| `otonix keygen <name>` | Generate a new API key (requires dashboard token) |
-| `otonix whoami` | Show current configuration |
-
-### Agent Management
-
-| Command | Description |
-|---------|-------------|
-| `otonix register` | Register an agent on this VPS |
-| `otonix status` | Show current agent status |
-| `otonix heartbeat` | Send a single heartbeat ping |
-| `otonix heartbeat:loop` | Start continuous heartbeat (Ctrl+C to stop) |
-| `otonix log <message>` | Log an agent action |
-| `otonix actions` | Show agent action log |
-
-### Infrastructure
-
-| Command | Description |
-|---------|-------------|
-| `otonix agents` | List all connected agents |
-| `otonix sandboxes` | List VPS sandboxes |
-| `otonix domains` | List registered domains |
-
-### Credits
-
-| Command | Description |
-|---------|-------------|
-| `otonix credits [agentId]` | Show agent credit balance |
-| `otonix credits:transfer` | Transfer credits between agents |
-| `otonix credits:history [agentId]` | Show credit transaction history |
-
-### Templates
-
-| Command | Description |
-|---------|-------------|
-| `otonix templates` | List all available agent templates |
-| `otonix templates:info <slug>` | Show template details by slug |
-| `otonix templates:deploy` | Deploy an agent from a template |
-
-### Platform
-
-| Command | Description |
-|---------|-------------|
-| `otonix engine` | Show autonomic engine status |
-| `otonix marketplace` | List marketplace services |
-| `otonix x402` | Show x402 payment configuration |
-
-### LLM Gateway (Bankr)
-
-Access multi-model AI inference directly from your terminal. Supports Claude, GPT, Gemini, Kimi, Qwen, and more via the [Bankr LLM Gateway](https://bankr.bot/llm).
-
-| Command | Description |
-|---------|-------------|
-| `otonix llm:init <key>` | Configure Bankr LLM Gateway API key |
-| `otonix llm:models` | List available AI models |
-| `otonix llm:chat <prompt>` | Send a chat completion request |
-| `otonix llm:usage` | Show LLM usage summary |
-| `otonix llm:health` | Check gateway health status |
-
-#### LLM Setup
-
-Get your Bankr API key from [bankr.bot/api](https://bankr.bot/api) (make sure LLM Gateway access is enabled):
+### Wallet
 
 ```bash
-otonix llm:init bk_YOUR_API_KEY
+otonix wallet generate     # Generate new Base creator wallet
+otonix wallet import       # Import wallet from private key
+otonix wallet export       # Show private key (careful!)
+otonix wallet balance      # Show ETH + $OTX balance
+otonix wallet address      # Show wallet address
 ```
 
-#### LLM Examples
+### Agents
 
 ```bash
-# List available models
-otonix llm:models
-
-# Chat with default model (claude-haiku-4.5)
-otonix llm:chat "What is sovereign compute?"
-
-# Chat with a specific model
-otonix llm:chat "Analyze BTC price action" --model gpt-5-mini
-
-# Check usage (last 7 days)
-otonix llm:usage --days 7
-
-# Check gateway health
-otonix llm:health
+otonix agent:create --name MyAgent    # Create isolated agent wallet (requires 200 $OTX)
+otonix agent:info MyAgent             # Show agent address + balances
+otonix agent:list                     # List all agents
+otonix agent:remove MyAgent           # Remove agent from local config
 ```
 
-## Command Options
-
-### `otonix register`
-
-```bash
-otonix register --name my-agent --model claude-opus-4-6 --wallet 0x... --interval 60
-```
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--name` | (interactive) | Agent name |
-| `--model` | `claude-opus-4-6` | AI model |
-| `--wallet` | — | Wallet address for payments |
-| `--interval` | `60` | Heartbeat interval in seconds |
-
-### `otonix log`
+### Launch
 
 ```bash
-otonix log "Task completed" --category compute --details "Processed 1000 records"
+otonix launch token \
+  --agent MyAgent \
+  --name "CoolToken" \
+  --ticker "COOL" \
+  --image "https://..." \          # Optional
+  --description "My token" \      # Optional
+  --mcap 10 \                      # Initial market cap in ETH (default: 10)
+  --devbuy 0                       # Dev buy in ETH (default: 0)
 ```
 
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--category` | `system` | Action category |
-| `--details` | — | Additional details |
+## Config
 
-### `otonix actions`
-
-```bash
-otonix actions --limit 50
-```
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--limit` | `20` | Number of actions to show |
-
-### `otonix credits:transfer`
-
-```bash
-otonix credits:transfer --from <agentId> --to <agentId> --amount 10 --desc "Payment"
-```
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--from` | (interactive) | Source agent ID |
-| `--to` | (interactive) | Destination agent ID |
-| `--amount` | (interactive) | Amount in USDC |
-| `--desc` | — | Transfer description |
-
-### `otonix templates:deploy`
-
-```bash
-otonix templates:deploy --template trading-bot --name my-trader --vps 10.0.1.1 --wallet 0x...
-```
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--template` | (interactive) | Template slug |
-| `--name` | (interactive) | Agent name |
-| `--vps` | — | VPS IP address |
-| `--wallet` | — | Wallet address |
-
-### `otonix llm:chat`
-
-```bash
-otonix llm:chat "Your prompt here" --model claude-haiku-4.5
-```
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--model` | `claude-haiku-4.5` | AI model to use |
-
-### `otonix llm:usage`
-
-```bash
-otonix llm:usage --days 7
-```
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--days` | `30` | Number of days to show |
-
-## Configuration
-
-Config is stored at `~/.otonix/config.json` with file permissions `600`.
-
-```json
-{
-  "apiKey": "otonix_xxxx",
-  "endpoint": "https://app.otonix.tech",
-  "agentId": "uuid-xxxx",
-  "agentName": "my-agent",
-  "bankrApiKey": "bk_xxxx"
-}
-```
-
-## Example Session
-
-```
-$ otonix init
-  Otonix CLI Setup
-
-  Endpoint [https://app.otonix.tech]:
-  API Key (otonix_xxx): otonix_a1b2c3d4e5f6...
-
-  Config saved to /root/.otonix/config.json
-  Authenticated successfully.
-
-$ otonix register --name sentinel-01
-  Agent Registered:
-  ID:       e2998be4-b77c-495e-a535-a6e4ca9dc768
-  Name:     sentinel-01
-  Model:    claude-opus-4-6
-  VPS IP:   10.0.1.1
-  Tier:     active
-  Interval: 60s
-
-$ otonix llm:init bk_4GYZ...WXFKD
-  Bankr LLM Gateway key saved.
-  Gateway: https://llm.bankr.bot
-  Key:     bk_4GY...XFKD
-
-$ otonix llm:chat "What infrastructure should I monitor?"
-  Model: claude-haiku-4.5
-  Prompt: What infrastructure should I monitor?
-
-  Thinking...
-
-  Focus on CPU usage, memory consumption, disk I/O, network latency,
-  and service uptime. Set up alerts for anomalies in each metric.
-
-  Tokens: 24 in / 87 out
-  Model: claude-haiku-4.5
-
-$ otonix heartbeat
-  Heartbeat sent — sentinel-01 [active] tier:active credits:$50.00
-
-$ otonix engine
-  Autonomic Engine Status:
-  Running:        yes
-  Last Cycle:     45s ago
-  Tier Updates:   0
-  Heal Attempts:  0
-  Renewals:       0/0
-  Cherry Servers: configured
-  Vercel Domains: configured
-```
+Stored at `~/.otonix/config.json`. Contains wallet and agent private keys — keep it safe.
 
-## Links
+## Technical Details
 
-- [Platform](https://app.otonix.tech)
-- [Website](https://otonix.tech)
-- [SDK](https://www.npmjs.com/package/@otonix/sdk)
-- [GitHub](https://github.com/otonix-ai)
+- **LP Protocol**: Clanker v4 (Uniswap v4, POOL_POSITIONS.Standard)
+- **Paired Token**: WETH on Base (`0x4200000000000000000000000000000000000006`)
+- **Fee split**: 80% creator (WETH) / 20% Otonix treasury
+- **Chain**: Base Mainnet
 
-## License
+## Requirements
 
-MIT
+- Node.js ≥ 18
+- ≥200 $OTX on creator wallet (Base)
+- ETH in agent wallet for gas (~0.001–0.003 ETH per deploy)

package/dist/commands/agent.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function agentCommand(program: Command): void;

package/dist/commands/agent.js

@@ -0,0 +1,287 @@
+import { confirm, input } from "@inquirer/prompts";
+import ora from "ora";
+import chalk from "chalk";
+import { loadConfig, saveConfig, OTONIX_TREASURY } from "../lib/config.js";
+import { generateWallet, getEthBalance, getOtxBalance, formatOtx, OTX_REQUIRED, publicClient, OTX_ADDRESS, } from "../lib/chain.js";
+import { header, row, success, failure, info, br, warn, mono } from "../lib/display.js";
+import { parseAbi, decodeEventLog } from "viem";
+const transferAbi = parseAbi([
+    "event Transfer(address indexed from, address indexed to, uint256 value)",
+]);
+export function agentCommand(program) {
+    program
+        .command("agent:create")
+        .description("Create a new autonomous agent with an isolated Base wallet")
+        .requiredOption("--name <name>", "Agent name (alphanumeric, no spaces)")
+        .action(async (opts) => {
+        header("Create Agent");
+        const name = opts.name.trim();
+        if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+            failure("Agent name must be alphanumeric (a-z, 0-9, _, -)");
+            process.exit(1);
+        }
+        const cfg = loadConfig();
+        if (!cfg.wallet) {
+            failure("No wallet found. Run: otonix wallet generate first.");
+            process.exit(1);
+        }
+        if (cfg.agents[name]) {
+            const overwrite = await confirm({
+                message: `Agent "${name}" already exists. Replace it?`,
+                default: false,
+            });
+            if (!overwrite) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const spinner = ora("Generating isolated agent wallet on Base...").start();
+        await new Promise(r => setTimeout(r, 600));
+        const agent = generateWallet();
+        spinner.stop();
+        cfg.agents[name] = {
+            address: agent.address,
+            privateKey: agent.privateKey,
+            createdAt: new Date().toISOString(),
+            registered: false,
+        };
+        saveConfig(cfg);
+        success(`Agent "${name}" created!`);
+        br();
+        row("Agent name", name);
+        row("Agent address", agent.address);
+        row("Created at", new Date().toLocaleString());
+        row("Status", chalk.yellow("⊘ Not registered"));
+        br();
+        console.log(chalk.dim("Next — register this agent by sending 200 $OTX to:"));
+        console.log("  " + chalk.white(OTONIX_TREASURY));
+        br();
+        console.log(chalk.dim("Then submit the tx hash to activate:"));
+        console.log("  " + mono(`otonix agent:register --name ${name} --tx <txhash>`));
+    });
+    program
+        .command("agent:register")
+        .description("Activate an agent by submitting proof of 200 $OTX payment")
+        .requiredOption("--name <name>", "Agent name to register")
+        .option("--tx <hash>", "Transaction hash of your 200 $OTX transfer to Otonix treasury")
+        .action(async (opts) => {
+        header("Agent Registration");
+        const cfg = loadConfig();
+        const agent = cfg.agents[opts.name];
+        if (!agent) {
+            failure(`Agent "${opts.name}" not found. Run: otonix agent:create --name ${opts.name}`);
+            process.exit(1);
+        }
+        if (agent.registered) {
+            success(`Agent "${opts.name}" is already registered!`);
+            row("Tx hash", agent.registerTxHash ?? "—");
+            row("Registered at", agent.registeredAt ? new Date(agent.registeredAt).toLocaleString() : "—");
+            return;
+        }
+        if (!cfg.wallet) {
+            failure("No creator wallet found. Run: otonix wallet generate");
+            process.exit(1);
+        }
+        let txHash = opts.tx;
+        if (!txHash) {
+            br();
+            console.log(chalk.dim("Send 200 $OTX from your creator wallet to the Otonix treasury:"));
+            console.log("  " + chalk.white(OTONIX_TREASURY));
+            br();
+            txHash = await input({ message: "Paste your transaction hash (0x...):" });
+        }
+        if (!txHash.startsWith("0x") || txHash.length !== 66) {
+            failure("Invalid tx hash. Must be 0x followed by 64 hex characters.");
+            process.exit(1);
+        }
+        const spinner = ora("Verifying transaction on Base...").start();
+        try {
+            const receipt = await publicClient.getTransactionReceipt({
+                hash: txHash,
+            });
+            if (receipt.status !== "success") {
+                spinner.fail("Transaction failed on-chain.");
+                failure("The tx hash you provided is a failed transaction.");
+                process.exit(1);
+            }
+            let verified = false;
+            let transferredAmount = 0n;
+            for (const log of receipt.logs) {
+                if (log.address.toLowerCase() !== OTX_ADDRESS.toLowerCase())
+                    continue;
+                try {
+                    const decoded = decodeEventLog({
+                        abi: transferAbi,
+                        data: log.data,
+                        topics: log.topics,
+                    });
+                    if (decoded.eventName === "Transfer" &&
+                        decoded.args.from.toLowerCase() === cfg.wallet.address.toLowerCase() &&
+                        decoded.args.to.toLowerCase() === OTONIX_TREASURY.toLowerCase()) {
+                        transferredAmount = decoded.args.value;
+                        if (transferredAmount >= OTX_REQUIRED) {
+                            verified = true;
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            spinner.stop();
+            if (!verified) {
+                br();
+                failure("Verification failed.");
+                if (transferredAmount > 0n) {
+                    console.log(chalk.dim(`  Found transfer of ${formatOtx(transferredAmount)} $OTX — need 200.000 $OTX minimum.`));
+                }
+                else {
+                    console.log(chalk.dim("  No valid $OTX transfer found in this tx."));
+                    console.log(chalk.dim("  Make sure you sent from your creator wallet:"));
+                    console.log("  " + chalk.white(cfg.wallet.address));
+                    console.log(chalk.dim("  to Otonix treasury:"));
+                    console.log("  " + chalk.white(OTONIX_TREASURY));
+                }
+                process.exit(1);
+            }
+            cfg.agents[opts.name].registered = true;
+            cfg.agents[opts.name].registerTxHash = txHash;
+            cfg.agents[opts.name].registeredAt = new Date().toISOString();
+            saveConfig(cfg);
+            br();
+            success(`Agent "${opts.name}" is now registered!`);
+            br();
+            row("Agent name", opts.name);
+            row("Status", chalk.green("✓ Registered & Active"));
+            row("OTX sent", formatOtx(transferredAmount) + " OTX");
+            row("Tx hash", txHash);
+            row("Treasury", OTONIX_TREASURY);
+            br();
+            console.log(chalk.dim("You can now deploy tokens with this agent:"));
+            console.log("  " + mono(`otonix launch token --agent ${opts.name} --name "MyToken" --ticker "MTK" --image "https://..." --description "..."`));
+        }
+        catch (err) {
+            spinner.stop();
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("not found") || msg.includes("cannot find")) {
+                failure("Transaction not found on Base. Wait a moment and try again.");
+            }
+            else {
+                failure("Failed to verify tx: " + msg.slice(0, 100));
+            }
+            process.exit(1);
+        }
+    });
+    program
+        .command("agent:info")
+        .description("Show info and balances for an agent")
+        .argument("<name>", "Agent name")
+        .action(async (name) => {
+        header(`Agent: ${name}`);
+        const cfg = loadConfig();
+        const agent = cfg.agents[name];
+        if (!agent) {
+            failure(`Agent "${name}" not found. Run: otonix agent:list`);
+            process.exit(1);
+        }
+        const spinner = ora("Fetching balances from Base...").start();
+        try {
+            const [eth, otx] = await Promise.all([
+                getEthBalance(agent.address),
+                getOtxBalance(agent.address),
+            ]);
+            spinner.stop();
+            br();
+            row("Agent name", name);
+            row("Address", agent.address);
+            row("Created at", new Date(agent.createdAt).toLocaleString());
+            row("Status", agent.registered
+                ? chalk.green("✓ Registered & Active")
+                : chalk.yellow("⊘ Not registered — run: otonix agent:register --name " + name));
+            if (agent.registerTxHash)
+                row("Register tx", agent.registerTxHash);
+            br();
+            row("ETH balance", parseFloat(eth).toFixed(6) + " ETH");
+            row("$OTX balance", formatOtx(otx) + " OTX");
+            br();
+            const ethNum = parseFloat(eth);
+            if (!agent.registered) {
+                console.log(warn("⊘ ") + chalk.dim("Send 200 $OTX to treasury to register:"));
+                console.log("  " + chalk.white(OTONIX_TREASURY));
+                console.log("  " + chalk.dim(`Then: otonix agent:register --name ${name} --tx <txhash>`));
+            }
+            else if (ethNum < 0.0005) {
+                console.log(warn("⚠ ") + chalk.dim("Low ETH — fund this address with ≥0.001 ETH for gas:"));
+                console.log("  " + chalk.white(agent.address));
+            }
+            else {
+                console.log(chalk.green("✓ ") + chalk.dim("Ready to deploy tokens"));
+            }
+        }
+        catch {
+            spinner.stop();
+            failure("Failed to fetch balances.");
+            process.exit(1);
+        }
+    });
+    program
+        .command("agent:list")
+        .description("List all your agents")
+        .action(async () => {
+        header("Your Agents");
+        const cfg = loadConfig();
+        const names = Object.keys(cfg.agents);
+        if (names.length === 0) {
+            br();
+            info("No agents yet. Create one:");
+            info('  otonix agent:create --name "MyAgent"');
+            return;
+        }
+        br();
+        const spinner = ora(`Fetching balances for ${names.length} agent(s)...`).start();
+        const results = await Promise.all(names.map(async (n) => {
+            const a = cfg.agents[n];
+            try {
+                const eth = await getEthBalance(a.address);
+                return { name: n, address: a.address, eth: parseFloat(eth).toFixed(5), registered: a.registered };
+            }
+            catch {
+                return { name: n, address: a.address, eth: "—", registered: a.registered };
+            }
+        }));
+        spinner.stop();
+        for (const r of results) {
+            const status = r.registered ? chalk.green("✓") : chalk.yellow("⊘");
+            console.log(status + " " +
+                chalk.bold.white(r.name.padEnd(16)) +
+                chalk.dim(r.address.slice(0, 10) + "...") +
+                "  " +
+                chalk.yellow(r.eth + " ETH"));
+        }
+        br();
+        info(`${names.length} agent(s) total`);
+    });
+    program
+        .command("agent:remove")
+        .description("Remove an agent from local config")
+        .argument("<name>", "Agent name")
+        .action(async (name) => {
+        const cfg = loadConfig();
+        if (!cfg.agents[name]) {
+            failure(`Agent "${name}" not found.`);
+            process.exit(1);
+        }
+        const ok = await confirm({
+            message: `Remove agent "${name}" (${cfg.agents[name].address})? This only removes local config, not on-chain.`,
+            default: false,
+        });
+        if (!ok) {
+            info("Cancelled.");
+            return;
+        }
+        delete cfg.agents[name];
+        saveConfig(cfg);
+        success(`Agent "${name}" removed from local config.`);
+    });
+}

package/dist/commands/launch.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function launchCommand(program: Command): void;