@otonix/cli 1.7.0 → 2.1.2

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,283 @@
+import { confirm } 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, sendOtx, OTX_REQUIRED, publicClient, } from "../lib/chain.js";
+import { header, row, success, failure, info, br, warn, mono } from "../lib/display.js";
+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 register (auto-sends 200 $OTX):"));
+        console.log("  " + mono(`otonix agent:register --name ${name}`));
+    });
+    program
+        .command("agent:register")
+        .description("Register an agent — auto-sends 200 $OTX to Otonix treasury and activates it")
+        .requiredOption("--name <name>", "Agent name to register")
+        .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!`);
+            br();
+            row("Status", chalk.green("✓ Registered & Active"));
+            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);
+        }
+        const balSpinner = ora("Checking creator wallet balance...").start();
+        let otxBal;
+        let ethBal;
+        try {
+            [otxBal, ethBal] = await Promise.all([
+                getOtxBalance(cfg.wallet.address),
+                getEthBalance(cfg.wallet.address),
+            ]);
+        }
+        catch {
+            balSpinner.stop();
+            failure("Failed to fetch balances. Check your connection.");
+            process.exit(1);
+        }
+        balSpinner.stop();
+        br();
+        row("Creator wallet", cfg.wallet.address);
+        row("$OTX balance", formatOtx(otxBal) + " OTX");
+        row("ETH balance", parseFloat(ethBal).toFixed(6) + " ETH (for gas)");
+        row("Registration fee", "200 $OTX → Otonix treasury");
+        row("Treasury", OTONIX_TREASURY);
+        br();
+        if (otxBal < OTX_REQUIRED) {
+            failure(`Insufficient $OTX. Need 200.000, have ${formatOtx(otxBal)}.`);
+            info("Buy $OTX at: https://dexscreener.com/base/0xF7E2a6226Ffe0693DD85406AC3A8917cbea5DC40");
+            process.exit(1);
+        }
+        if (parseFloat(ethBal) < 0.0001) {
+            failure("Insufficient ETH for gas. Send a small amount of ETH (Base) to your creator wallet.");
+            info("Creator wallet: " + cfg.wallet.address);
+            process.exit(1);
+        }
+        const confirmed = await confirm({
+            message: `Send 200 $OTX from your creator wallet to Otonix treasury to activate "${opts.name}"?`,
+            default: true,
+        });
+        if (!confirmed) {
+            info("Cancelled.");
+            return;
+        }
+        const sendSpinner = ora("Sending 200 $OTX to Otonix treasury...").start();
+        let txHash;
+        try {
+            txHash = await sendOtx(cfg.wallet.privateKey, OTONIX_TREASURY, OTX_REQUIRED);
+        }
+        catch (err) {
+            sendSpinner.stop();
+            const msg = err instanceof Error ? err.message : String(err);
+            failure("Failed to send $OTX: " + msg.slice(0, 120));
+            process.exit(1);
+        }
+        sendSpinner.text = `Waiting for confirmation... (${txHash.slice(0, 18)}...)`;
+        try {
+            const receipt = await publicClient.waitForTransactionReceipt({
+                hash: txHash,
+                timeout: 60_000,
+            });
+            sendSpinner.stop();
+            if (receipt.status !== "success") {
+                failure("Transaction failed on-chain.");
+                info("Tx: https://basescan.org/tx/" + txHash);
+                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", "200.000 OTX");
+            row("Tx hash", txHash);
+            row("Basescan", "https://basescan.org/tx/" + txHash);
+            br();
+            console.log(chalk.dim("You can now deploy tokens. Fund the agent with ETH first:"));
+            console.log("  " + chalk.dim("Agent address:") + " " + chalk.white(agent.address));
+            br();
+            console.log(chalk.dim("Then deploy:"));
+            console.log("  " + mono(`otonix launch token --agent ${opts.name} --name "MyToken" --ticker "MTK" --image "https://..." --description "..."`));
+        }
+        catch (err) {
+            sendSpinner.stop();
+            const msg = err instanceof Error ? err.message : String(err);
+            failure("Tx sent but confirmation timed out: " + msg.slice(0, 100));
+            info("Check manually: https://basescan.org/tx/" + txHash);
+            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("Not registered — run this to activate:"));
+                console.log("  " + chalk.cyan(`otonix agent:register --name ${name}`));
+                console.log("  " + chalk.dim("(auto-sends 200 $OTX from your creator wallet)"));
+            }
+            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;