@otonix/openclaw-plugin 1.0.0

package/README.md

@@ -0,0 +1,204 @@
+# @otonix/openclaw-plugin
+
+OpenClaw plugin for the [Otonix](https://otonix.tech) sovereign compute platform.
+
+Give your OpenClaw AI agents autonomous infrastructure management — register, heartbeat, manage VPS, domains, and payments through chat commands.
+
+## Install
+
+```bash
+npm install @otonix/openclaw-plugin
+```
+
+## Quick Start
+
+```typescript
+import { OtonixPlugin, getSystemPromptAddition } from '@otonix/openclaw-plugin'
+
+const plugin = new OtonixPlugin({
+  apiKey: 'otonix_your_api_key',
+  endpoint: 'https://app.otonix.tech',
+  autoHeartbeat: true,
+  heartbeatInterval: 60,
+})
+
+// Get tool schemas for your LLM (OpenAI function calling format)
+const tools = plugin.getToolSchemas()
+
+// Add to your system prompt
+const systemPrompt = `You are an autonomous agent.\n${getSystemPromptAddition()}`
+
+// Execute a tool call from the LLM
+const result = await plugin.executeTool('otonix_register_agent', {
+  name: 'sentinel-01',
+  vps_ip: '10.0.1.1',
+})
+
+console.log(result.message)
+```
+
+## Integration with OpenClaw / PI Framework
+
+### With pi-agent-core
+
+```typescript
+import { Agent } from 'pi-agent-core'
+import { OtonixPlugin, getSystemPromptAddition } from '@otonix/openclaw-plugin'
+
+const otonix = new OtonixPlugin({
+  apiKey: process.env.OTONIX_API_KEY,
+  autoHeartbeat: true,
+})
+
+const agent = new Agent({
+  systemPrompt: `You are an autonomous AI agent.\n${getSystemPromptAddition()}`,
+  tools: otonix.getToolSchemas(),
+  onToolCall: async (name, params) => {
+    return await otonix.executeTool(name, params)
+  },
+})
+```
+
+### With pi-coding-agent
+
+```typescript
+import { CodingAgent } from 'pi-coding-agent'
+import { OtonixPlugin, getSystemPromptAddition } from '@otonix/openclaw-plugin'
+
+const otonix = new OtonixPlugin({
+  apiKey: process.env.OTONIX_API_KEY,
+  autoHeartbeat: true,
+  onTierChange: (oldTier, newTier, agent) => {
+    console.log(`Tier changed: ${oldTier} → ${newTier} (credits: $${agent.credits})`)
+  },
+})
+
+const codingAgent = new CodingAgent({
+  additionalTools: otonix.getToolSchemas(),
+  additionalSystemPrompt: getSystemPromptAddition(),
+  onToolCall: async (name, params) => {
+    if (name.startsWith('otonix_')) {
+      return await otonix.executeTool(name, params)
+    }
+  },
+})
+```
+
+### With any LLM (raw function calling)
+
+```typescript
+import { OtonixPlugin, getSystemPromptAddition } from '@otonix/openclaw-plugin'
+
+const otonix = new OtonixPlugin({ apiKey: 'otonix_xxx' })
+
+// Pass tools to any LLM that supports function calling
+const messages = [
+  { role: 'system', content: getSystemPromptAddition() },
+  { role: 'user', content: 'Register yourself and start monitoring' },
+]
+
+// When LLM returns a tool call:
+const toolResult = await otonix.executeTool('otonix_register_agent', {
+  name: 'my-agent',
+  vps_ip: '10.0.1.1',
+})
+
+// Feed result back to LLM
+messages.push({
+  role: 'tool',
+  content: toolResult.message,
+})
+```
+
+## Available Tools
+
+### Agent Management
+
+| Tool | Description |
+|------|-------------|
+| `otonix_register_agent` | Register a new agent (name, model, vps_ip, wallet, interval) |
+| `otonix_agent_status` | Get agent status, tier, credits, heartbeat |
+| `otonix_list_agents` | List all registered agents |
+| `otonix_heartbeat` | Send a single heartbeat ping |
+| `otonix_start_heartbeat_loop` | Start auto-heartbeat (interval in seconds) |
+| `otonix_stop_heartbeat_loop` | Stop auto-heartbeat |
+| `otonix_log_action` | Log an action (action, category, details) |
+| `otonix_get_actions` | Get recent action log (limit) |
+| `otonix_get_credits` | Check credit balance and survival tier |
+
+### Infrastructure
+
+| Tool | Description |
+|------|-------------|
+| `otonix_list_sandboxes` | List all VPS sandboxes |
+| `otonix_get_sandbox` | Get sandbox details (sandbox_id) |
+| `otonix_list_domains` | List registered domains |
+| `otonix_check_domain` | Check domain availability (domain) |
+
+### Platform
+
+| Tool | Description |
+|------|-------------|
+| `otonix_engine_status` | Autonomic engine status |
+| `otonix_payment_config` | x402 payment configuration |
+
+## Plugin Config
+
+```typescript
+const plugin = new OtonixPlugin({
+  apiKey: 'otonix_xxx',           // Required: Otonix API key
+  endpoint: 'https://app.otonix.tech', // Optional: API endpoint
+  agentId: 'uuid',                // Optional: pre-registered agent ID
+  agentName: 'my-agent',          // Optional: agent name
+  autoHeartbeat: true,            // Optional: auto-start heartbeat after register
+  heartbeatInterval: 60,          // Optional: seconds between heartbeats
+  onHeartbeatError: (err) => {},  // Optional: heartbeat error callback
+  onTierChange: (old, new, agent) => {}, // Optional: tier change callback
+})
+```
+
+## Methods
+
+### `plugin.getTools()`
+Returns array of `OtonixTool` objects with name, description, parameters, and execute function.
+
+### `plugin.getToolSchemas()`
+Returns OpenAI function calling format — ready to pass to any LLM.
+
+### `plugin.executeTool(name, params)`
+Execute a tool by name. Returns `{ success, message, data? }`.
+
+### `plugin.startAutoHeartbeat()`
+Start automatic heartbeat loop.
+
+### `plugin.stopAutoHeartbeat()`
+Stop automatic heartbeat.
+
+### `plugin.getClient()`
+Access the underlying `OtonixClient` for direct API calls.
+
+### `getSystemPromptAddition()`
+Returns a system prompt addition explaining Otonix tools and concepts to the LLM.
+
+## Survival Tiers
+
+The autonomic engine adjusts agent tier based on credits every 60 seconds:
+
+| Tier | Credits | Description |
+|------|---------|-------------|
+| Full | $50+ | All features active |
+| Active | $20+ | Standard operation |
+| Minimal | $5+ | Reduced capabilities |
+| Critical | $1+ | Survival mode |
+| Terminated | $0 | Agent shut down |
+
+## Links
+
+- [Otonix Platform](https://app.otonix.tech)
+- [SDK](https://www.npmjs.com/package/@otonix/sdk)
+- [CLI](https://www.npmjs.com/package/@otonix/cli)
+- [GitHub](https://github.com/otonix-ai)
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,73 @@
+import { Agent, OtonixClient } from '@otonix/sdk';
+export { Agent, AgentAction, AutonomicStatus, Domain, OtonixClient, OtonixConfig, OtonixError, Sandbox, X402Config } from '@otonix/sdk';
+
+interface OtonixPluginConfig {
+    apiKey: string;
+    endpoint?: string;
+    agentId?: string;
+    agentName?: string;
+    autoHeartbeat?: boolean;
+    heartbeatInterval?: number;
+    onHeartbeatError?: (error: Error) => void;
+    onTierChange?: (oldTier: string, newTier: string, agent: Agent) => void;
+}
+interface ToolResult {
+    success: boolean;
+    message: string;
+    data?: unknown;
+}
+interface OtonixTool {
+    name: string;
+    description: string;
+    parameters: Record<string, ToolParameter>;
+    execute: (params: Record<string, string>) => Promise<ToolResult>;
+}
+interface ToolParameter {
+    type: string;
+    description: string;
+    required: boolean;
+}
+declare class OtonixPlugin {
+    private client;
+    private config;
+    private heartbeatHandle;
+    private lastTier;
+    constructor(config: OtonixPluginConfig);
+    getTools(): OtonixTool[];
+    getToolSchemas(): Array<{
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: Record<string, unknown>;
+        };
+    }>;
+    executeTool(name: string, params: Record<string, string>): Promise<ToolResult>;
+    startAutoHeartbeat(): Promise<void>;
+    stopAutoHeartbeat(): void;
+    getClient(): OtonixClient;
+    getAgentId(): string | undefined;
+    setAgentId(agentId: string): void;
+    private requireAgentId;
+    private formatCredits;
+    private formatTime;
+    private toolRegisterAgent;
+    private toolAgentStatus;
+    private toolListAgents;
+    private toolSendHeartbeat;
+    private toolStartHeartbeatLoop;
+    private toolStopHeartbeatLoop;
+    private toolLogAction;
+    private toolGetActions;
+    private toolListSandboxes;
+    private toolGetSandbox;
+    private toolListDomains;
+    private toolCheckDomain;
+    private toolEngineStatus;
+    private toolPaymentConfig;
+    private toolGetCredits;
+}
+declare function createPlugin(config: OtonixPluginConfig): OtonixPlugin;
+declare function getSystemPromptAddition(): string;
+
+export { OtonixPlugin, type OtonixPluginConfig, type OtonixTool, type ToolResult, createPlugin, OtonixPlugin as default, getSystemPromptAddition };

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+import { Agent, OtonixClient } from '@otonix/sdk';
+export { Agent, AgentAction, AutonomicStatus, Domain, OtonixClient, OtonixConfig, OtonixError, Sandbox, X402Config } from '@otonix/sdk';
+
+interface OtonixPluginConfig {
+    apiKey: string;
+    endpoint?: string;
+    agentId?: string;
+    agentName?: string;
+    autoHeartbeat?: boolean;
+    heartbeatInterval?: number;
+    onHeartbeatError?: (error: Error) => void;
+    onTierChange?: (oldTier: string, newTier: string, agent: Agent) => void;
+}
+interface ToolResult {
+    success: boolean;
+    message: string;
+    data?: unknown;
+}
+interface OtonixTool {
+    name: string;
+    description: string;
+    parameters: Record<string, ToolParameter>;
+    execute: (params: Record<string, string>) => Promise<ToolResult>;
+}
+interface ToolParameter {
+    type: string;
+    description: string;
+    required: boolean;
+}
+declare class OtonixPlugin {
+    private client;
+    private config;
+    private heartbeatHandle;
+    private lastTier;
+    constructor(config: OtonixPluginConfig);
+    getTools(): OtonixTool[];
+    getToolSchemas(): Array<{
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: Record<string, unknown>;
+        };
+    }>;
+    executeTool(name: string, params: Record<string, string>): Promise<ToolResult>;
+    startAutoHeartbeat(): Promise<void>;
+    stopAutoHeartbeat(): void;
+    getClient(): OtonixClient;
+    getAgentId(): string | undefined;
+    setAgentId(agentId: string): void;
+    private requireAgentId;
+    private formatCredits;
+    private formatTime;
+    private toolRegisterAgent;
+    private toolAgentStatus;
+    private toolListAgents;
+    private toolSendHeartbeat;
+    private toolStartHeartbeatLoop;
+    private toolStopHeartbeatLoop;
+    private toolLogAction;
+    private toolGetActions;
+    private toolListSandboxes;
+    private toolGetSandbox;
+    private toolListDomains;
+    private toolCheckDomain;
+    private toolEngineStatus;
+    private toolPaymentConfig;
+    private toolGetCredits;
+}
+declare function createPlugin(config: OtonixPluginConfig): OtonixPlugin;
+declare function getSystemPromptAddition(): string;
+
+export { OtonixPlugin, type OtonixPluginConfig, type OtonixTool, type ToolResult, createPlugin, OtonixPlugin as default, getSystemPromptAddition };

package/dist/index.js

@@ -0,0 +1,499 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OtonixClient: () => import_sdk2.OtonixClient,
+  OtonixError: () => import_sdk2.OtonixError,
+  OtonixPlugin: () => OtonixPlugin,
+  createPlugin: () => createPlugin,
+  default: () => index_default,
+  getSystemPromptAddition: () => getSystemPromptAddition
+});
+module.exports = __toCommonJS(index_exports);
+var import_sdk = require("@otonix/sdk");
+var import_sdk2 = require("@otonix/sdk");
+var OtonixPlugin = class {
+  constructor(config) {
+    this.heartbeatHandle = null;
+    this.lastTier = null;
+    this.config = config;
+    this.client = new import_sdk.OtonixClient({
+      apiKey: config.apiKey,
+      endpoint: config.endpoint
+    });
+  }
+  getTools() {
+    return [
+      this.toolRegisterAgent(),
+      this.toolAgentStatus(),
+      this.toolListAgents(),
+      this.toolSendHeartbeat(),
+      this.toolStartHeartbeatLoop(),
+      this.toolStopHeartbeatLoop(),
+      this.toolLogAction(),
+      this.toolGetActions(),
+      this.toolListSandboxes(),
+      this.toolGetSandbox(),
+      this.toolListDomains(),
+      this.toolCheckDomain(),
+      this.toolEngineStatus(),
+      this.toolPaymentConfig(),
+      this.toolGetCredits()
+    ];
+  }
+  getToolSchemas() {
+    return this.getTools().map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(tool.parameters).map(([key, param]) => [
+              key,
+              { type: param.type, description: param.description }
+            ])
+          ),
+          required: Object.entries(tool.parameters).filter(([, p]) => p.required).map(([k]) => k)
+        }
+      }
+    }));
+  }
+  async executeTool(name, params) {
+    const tool = this.getTools().find((t) => t.name === name);
+    if (!tool) {
+      return { success: false, message: `Unknown tool: ${name}` };
+    }
+    try {
+      return await tool.execute(params);
+    } catch (err) {
+      if (err instanceof import_sdk.OtonixError) {
+        return { success: false, message: `API Error (${err.status}): ${err.message}` };
+      }
+      return { success: false, message: `Error: ${err.message}` };
+    }
+  }
+  async startAutoHeartbeat() {
+    if (!this.config.agentId) return;
+    if (this.heartbeatHandle) return;
+    const interval = this.config.heartbeatInterval || 60;
+    this.heartbeatHandle = this.client.createHeartbeatLoop(this.config.agentId, interval);
+  }
+  stopAutoHeartbeat() {
+    if (this.heartbeatHandle) {
+      this.heartbeatHandle.stop();
+      this.heartbeatHandle = null;
+    }
+  }
+  getClient() {
+    return this.client;
+  }
+  getAgentId() {
+    return this.config.agentId;
+  }
+  setAgentId(agentId) {
+    this.config.agentId = agentId;
+  }
+  requireAgentId() {
+    if (!this.config.agentId) {
+      throw new Error("No agent registered. Use otonix_register_agent first.");
+    }
+    return this.config.agentId;
+  }
+  formatCredits(n) {
+    return `$${n.toFixed(2)}`;
+  }
+  formatTime(dateStr) {
+    if (!dateStr) return "never";
+    const ago = Math.floor((Date.now() - new Date(dateStr).getTime()) / 1e3);
+    if (ago < 60) return `${ago}s ago`;
+    if (ago < 3600) return `${Math.floor(ago / 60)}m ago`;
+    if (ago < 86400) return `${Math.floor(ago / 3600)}h ago`;
+    return `${Math.floor(ago / 86400)}d ago`;
+  }
+  toolRegisterAgent() {
+    return {
+      name: "otonix_register_agent",
+      description: "Register a new autonomous agent on the Otonix platform. Returns agent ID, status, and survival tier. The agent will be monitored, auto-healed, and can manage its own infrastructure.",
+      parameters: {
+        name: { type: "string", description: "Agent name (e.g. sentinel-01, trader-alpha)", required: true },
+        model: { type: "string", description: "AI model name (default: claude-opus-4-6)", required: false },
+        vps_ip: { type: "string", description: "VPS IP address where the agent runs", required: true },
+        wallet_address: { type: "string", description: "USDC wallet address for payments (0x...)", required: false },
+        heartbeat_interval: { type: "string", description: "Heartbeat interval in seconds (default: 60)", required: false }
+      },
+      execute: async (params) => {
+        const agent = await this.client.register({
+          name: params.name,
+          model: params.model || "claude-opus-4-6",
+          vpsIp: params.vps_ip,
+          walletAddress: params.wallet_address,
+          heartbeatInterval: parseInt(params.heartbeat_interval || "60")
+        });
+        this.config.agentId = agent.id;
+        this.config.agentName = agent.name;
+        this.lastTier = agent.survivalTier;
+        if (this.config.autoHeartbeat) {
+          await this.startAutoHeartbeat();
+        }
+        return {
+          success: true,
+          message: `Agent "${agent.name}" registered successfully.
+ID: ${agent.id}
+Status: ${agent.status}
+Tier: ${agent.survivalTier}
+Credits: ${this.formatCredits(agent.credits)}`,
+          data: agent
+        };
+      }
+    };
+  }
+  toolAgentStatus() {
+    return {
+      name: "otonix_agent_status",
+      description: "Get the current status of your registered Otonix agent including survival tier, credits balance, heartbeat status, and action count.",
+      parameters: {},
+      execute: async () => {
+        const agentId = this.requireAgentId();
+        const agent = await this.client.getAgent(agentId);
+        if (this.lastTier && this.lastTier !== agent.survivalTier && this.config.onTierChange) {
+          this.config.onTierChange(this.lastTier, agent.survivalTier, agent);
+        }
+        this.lastTier = agent.survivalTier;
+        return {
+          success: true,
+          message: `Agent: ${agent.name}
+Status: ${agent.status}
+Tier: ${agent.survivalTier}
+Credits: ${this.formatCredits(agent.credits)}
+Model: ${agent.model}
+VPS: ${agent.vpsIp || "none"}
+Last heartbeat: ${this.formatTime(agent.lastHeartbeat)}
+Total actions: ${agent.totalActions}
+Replicas: ${agent.childrenCount}`,
+          data: agent
+        };
+      }
+    };
+  }
+  toolListAgents() {
+    return {
+      name: "otonix_list_agents",
+      description: "List all registered agents on the Otonix platform with their status, tier, and credits.",
+      parameters: {},
+      execute: async () => {
+        const agents = await this.client.listAgents();
+        if (!agents.length) {
+          return { success: true, message: "No agents registered." };
+        }
+        const lines = agents.map(
+          (a) => `\u2022 ${a.name} [${a.status}] tier:${a.survivalTier} credits:${this.formatCredits(a.credits)} heartbeat:${this.formatTime(a.lastHeartbeat)}`
+        );
+        return {
+          success: true,
+          message: `${agents.length} agent(s):
+${lines.join("\n")}`,
+          data: agents
+        };
+      }
+    };
+  }
+  toolSendHeartbeat() {
+    return {
+      name: "otonix_heartbeat",
+      description: "Send a heartbeat ping to keep the agent alive. The autonomic engine uses heartbeats to detect crashes and trigger self-healing VPS restarts.",
+      parameters: {},
+      execute: async () => {
+        const agentId = this.requireAgentId();
+        const agent = await this.client.heartbeat(agentId);
+        return {
+          success: true,
+          message: `Heartbeat sent. ${agent.name} [${agent.status}] tier:${agent.survivalTier} credits:${this.formatCredits(agent.credits)}`,
+          data: agent
+        };
+      }
+    };
+  }
+  toolStartHeartbeatLoop() {
+    return {
+      name: "otonix_start_heartbeat_loop",
+      description: "Start automatic heartbeat loop that sends a ping every N seconds to keep the agent alive and prevent auto-healing triggers.",
+      parameters: {
+        interval: { type: "string", description: "Interval in seconds between heartbeats (default: 60)", required: false }
+      },
+      execute: async (params) => {
+        const agentId = this.requireAgentId();
+        if (this.heartbeatHandle) {
+          return { success: false, message: "Heartbeat loop already running. Stop it first." };
+        }
+        const interval = parseInt(params.interval || "60");
+        this.heartbeatHandle = this.client.createHeartbeatLoop(agentId, interval);
+        return {
+          success: true,
+          message: `Heartbeat loop started (every ${interval}s).`
+        };
+      }
+    };
+  }
+  toolStopHeartbeatLoop() {
+    return {
+      name: "otonix_stop_heartbeat_loop",
+      description: "Stop the automatic heartbeat loop.",
+      parameters: {},
+      execute: async () => {
+        if (!this.heartbeatHandle) {
+          return { success: false, message: "No heartbeat loop running." };
+        }
+        this.stopAutoHeartbeat();
+        return { success: true, message: "Heartbeat loop stopped." };
+      }
+    };
+  }
+  toolLogAction() {
+    return {
+      name: "otonix_log_action",
+      description: "Log an action performed by the agent. Actions are recorded in the agent's activity feed and visible on the dashboard. Categories: system, infra, domain, compute, trading.",
+      parameters: {
+        action: { type: "string", description: "Description of the action performed", required: true },
+        category: { type: "string", description: "Category: system, infra, domain, compute, trading (default: system)", required: false },
+        details: { type: "string", description: "Additional details or metadata about the action", required: false }
+      },
+      execute: async (params) => {
+        const agentId = this.requireAgentId();
+        const result = await this.client.logAction(agentId, {
+          action: params.action,
+          category: params.category || "system",
+          details: params.details,
+          autonomous: true
+        });
+        return {
+          success: true,
+          message: `Logged: [${result.category}] ${result.action} (${result.status})`,
+          data: result
+        };
+      }
+    };
+  }
+  toolGetActions() {
+    return {
+      name: "otonix_get_actions",
+      description: "Get the recent action log for the current agent. Shows what the agent has been doing.",
+      parameters: {
+        limit: { type: "string", description: "Number of actions to show (default: 10)", required: false }
+      },
+      execute: async (params) => {
+        const agentId = this.requireAgentId();
+        const actions = await this.client.getAgentActions(agentId);
+        const limit = parseInt(params.limit || "10");
+        const display = actions.slice(0, limit);
+        if (!display.length) {
+          return { success: true, message: "No actions recorded yet." };
+        }
+        const lines = display.map(
+          (a) => `\u2022 [${a.category}] ${a.action} \u2014 ${a.status} (${this.formatTime(a.createdAt)})`
+        );
+        return {
+          success: true,
+          message: `Last ${display.length} actions:
+${lines.join("\n")}`,
+          data: display
+        };
+      }
+    };
+  }
+  toolListSandboxes() {
+    return {
+      name: "otonix_list_sandboxes",
+      description: "List all VPS sandboxes (virtual servers) provisioned on the Otonix platform. Shows status, specs, region, and IP address.",
+      parameters: {},
+      execute: async () => {
+        const sandboxes = await this.client.listSandboxes();
+        if (!sandboxes.length) {
+          return { success: true, message: "No VPS sandboxes provisioned." };
+        }
+        const lines = sandboxes.map(
+          (s) => `\u2022 ${s.name} [${s.status}] ${s.cpu}vCPU/${s.memory}MB ${s.region} IP:${s.ipAddress || "pending"}`
+        );
+        return {
+          success: true,
+          message: `${sandboxes.length} sandbox(es):
+${lines.join("\n")}`,
+          data: sandboxes
+        };
+      }
+    };
+  }
+  toolGetSandbox() {
+    return {
+      name: "otonix_get_sandbox",
+      description: "Get detailed information about a specific VPS sandbox including SSH credentials and specs.",
+      parameters: {
+        sandbox_id: { type: "string", description: "The sandbox ID to look up", required: true }
+      },
+      execute: async (params) => {
+        const sandbox = await this.client.getSandbox(params.sandbox_id);
+        return {
+          success: true,
+          message: `Sandbox: ${sandbox.name}
+Status: ${sandbox.status}
+OS: ${sandbox.os}
+Specs: ${sandbox.cpu}vCPU / ${sandbox.memory}MB RAM / ${sandbox.disk}GB disk
+Region: ${sandbox.region}
+IP: ${sandbox.ipAddress || "pending"}
+SSH: ${sandbox.sshUser || "n/a"}@${sandbox.ipAddress || "n/a"}`,
+          data: sandbox
+        };
+      }
+    };
+  }
+  toolListDomains() {
+    return {
+      name: "otonix_list_domains",
+      description: "List all domains registered on the Otonix platform. Shows status, auto-renew setting, and expiration date.",
+      parameters: {},
+      execute: async () => {
+        const domains = await this.client.listDomains();
+        if (!domains.length) {
+          return { success: true, message: "No domains registered." };
+        }
+        const lines = domains.map(
+          (d) => `\u2022 ${d.name} [${d.status}] auto-renew:${d.autoRenew ? "yes" : "no"} expires:${d.expiresAt ? new Date(d.expiresAt).toLocaleDateString() : "n/a"}`
+        );
+        return {
+          success: true,
+          message: `${domains.length} domain(s):
+${lines.join("\n")}`,
+          data: domains
+        };
+      }
+    };
+  }
+  toolCheckDomain() {
+    return {
+      name: "otonix_check_domain",
+      description: "Check if a domain name is available for registration and get its price.",
+      parameters: {
+        domain: { type: "string", description: "Domain name to check (e.g. example.com)", required: true }
+      },
+      execute: async (params) => {
+        const result = await this.client.checkDomain(params.domain);
+        if (result.available) {
+          return {
+            success: true,
+            message: `${result.domain} is available! Price: $${result.price || "N/A"}`,
+            data: result
+          };
+        }
+        return {
+          success: true,
+          message: `${result.domain} is not available.`,
+          data: result
+        };
+      }
+    };
+  }
+  toolEngineStatus() {
+    return {
+      name: "otonix_engine_status",
+      description: "Get the status of the Otonix autonomic engine \u2014 the background system that manages survival tiers, self-healing VPS restarts, and domain auto-renewal.",
+      parameters: {},
+      execute: async () => {
+        const status = await this.client.getAutonomicStatus();
+        return {
+          success: true,
+          message: `Autonomic Engine: ${status.running ? "RUNNING" : "STOPPED"}
+Last cycle: ${this.formatTime(status.lastRunAt)}
+Tier updates: ${status.totalTierUpdates}
+Healing: ${status.totalHealingSuccesses}/${status.totalHealingAttempts}
+Renewals: ${status.totalRenewalSuccesses}/${status.totalRenewalAttempts}
+Cherry Servers: ${status.cherryServersConfigured ? "yes" : "no"}
+Vercel Domains: ${status.vercelDomainsConfigured ? "yes" : "no"}`,
+          data: status
+        };
+      }
+    };
+  }
+  toolPaymentConfig() {
+    return {
+      name: "otonix_payment_config",
+      description: "Get the x402 payment configuration \u2014 treasury address, USDC contract, chain, and facilitator URL for autonomous payments.",
+      parameters: {},
+      execute: async () => {
+        const config = await this.client.getX402Config();
+        return {
+          success: true,
+          message: `x402 Payment Config:
+Treasury: ${config.treasuryAddress}
+USDC: ${config.usdcContract}
+Chain: ${config.network} (${config.chainId})
+Facilitator: ${config.facilitatorUrl}`,
+          data: config
+        };
+      }
+    };
+  }
+  toolGetCredits() {
+    return {
+      name: "otonix_get_credits",
+      description: "Check the current credit balance and survival tier of the agent. Low credits trigger tier downgrades and eventual termination.",
+      parameters: {},
+      execute: async () => {
+        const agentId = this.requireAgentId();
+        const agent = await this.client.getAgent(agentId);
+        let warning = "";
+        if (agent.credits < 5) warning = "\n\u26A0 CRITICAL: Credits below $5. Agent may be terminated soon.";
+        else if (agent.credits < 20) warning = "\n\u26A0 WARNING: Credits below $20. Agent in minimal tier.";
+        return {
+          success: true,
+          message: `Credits: ${this.formatCredits(agent.credits)}
+Tier: ${agent.survivalTier}
+Status: ${agent.status}${warning}`,
+          data: { credits: agent.credits, tier: agent.survivalTier, status: agent.status }
+        };
+      }
+    };
+  }
+};
+function createPlugin(config) {
+  return new OtonixPlugin(config);
+}
+function getSystemPromptAddition() {
+  return `You have access to the Otonix sovereign compute platform through the following tools. Otonix allows you to manage your own infrastructure autonomously \u2014 register as an agent, send heartbeats to stay alive, provision VPS servers, register domains, and make USDC payments on Base chain.
+
+Key concepts:
+- You are an autonomous agent running on a VPS. Register yourself first using otonix_register_agent.
+- Send heartbeats regularly (otonix_start_heartbeat_loop) to prevent the autonomic engine from marking you as crashed.
+- Your survival depends on credits. Check your balance with otonix_get_credits. When credits reach $0, you will be terminated.
+- The autonomic engine runs every 60 seconds: it adjusts your survival tier based on credits, auto-restarts your VPS if heartbeat is missed, and renews domains before they expire.
+- Log important actions with otonix_log_action so your activity is tracked on the dashboard.
+
+Survival tiers: Full ($50+) \u2192 Active ($20+) \u2192 Minimal ($5+) \u2192 Critical ($1+) \u2192 Terminated ($0).`;
+}
+var index_default = OtonixPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OtonixClient,
+  OtonixError,
+  OtonixPlugin,
+  createPlugin,
+  getSystemPromptAddition
+});

package/dist/index.mjs

@@ -0,0 +1,470 @@
+// src/index.ts
+import { OtonixClient, OtonixError } from "@otonix/sdk";
+import { OtonixClient as OtonixClient2, OtonixError as OtonixError2 } from "@otonix/sdk";
+var OtonixPlugin = class {
+  constructor(config) {
+    this.heartbeatHandle = null;
+    this.lastTier = null;
+    this.config = config;
+    this.client = new OtonixClient({
+      apiKey: config.apiKey,
+      endpoint: config.endpoint
+    });
+  }
+  getTools() {
+    return [
+      this.toolRegisterAgent(),
+      this.toolAgentStatus(),
+      this.toolListAgents(),
+      this.toolSendHeartbeat(),
+      this.toolStartHeartbeatLoop(),
+      this.toolStopHeartbeatLoop(),
+      this.toolLogAction(),
+      this.toolGetActions(),
+      this.toolListSandboxes(),
+      this.toolGetSandbox(),
+      this.toolListDomains(),
+      this.toolCheckDomain(),
+      this.toolEngineStatus(),
+      this.toolPaymentConfig(),
+      this.toolGetCredits()
+    ];
+  }
+  getToolSchemas() {
+    return this.getTools().map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(tool.parameters).map(([key, param]) => [
+              key,
+              { type: param.type, description: param.description }
+            ])
+          ),
+          required: Object.entries(tool.parameters).filter(([, p]) => p.required).map(([k]) => k)
+        }
+      }
+    }));
+  }
+  async executeTool(name, params) {
+    const tool = this.getTools().find((t) => t.name === name);
+    if (!tool) {
+      return { success: false, message: `Unknown tool: ${name}` };
+    }
+    try {
+      return await tool.execute(params);
+    } catch (err) {
+      if (err instanceof OtonixError) {
+        return { success: false, message: `API Error (${err.status}): ${err.message}` };
+      }
+      return { success: false, message: `Error: ${err.message}` };
+    }
+  }
+  async startAutoHeartbeat() {
+    if (!this.config.agentId) return;
+    if (this.heartbeatHandle) return;
+    const interval = this.config.heartbeatInterval || 60;
+    this.heartbeatHandle = this.client.createHeartbeatLoop(this.config.agentId, interval);
+  }
+  stopAutoHeartbeat() {
+    if (this.heartbeatHandle) {
+      this.heartbeatHandle.stop();
+      this.heartbeatHandle = null;
+    }
+  }
+  getClient() {
+    return this.client;
+  }
+  getAgentId() {
+    return this.config.agentId;
+  }
+  setAgentId(agentId) {
+    this.config.agentId = agentId;
+  }
+  requireAgentId() {
+    if (!this.config.agentId) {
+      throw new Error("No agent registered. Use otonix_register_agent first.");
+    }
+    return this.config.agentId;
+  }
+  formatCredits(n) {
+    return `$${n.toFixed(2)}`;
+  }
+  formatTime(dateStr) {
+    if (!dateStr) return "never";
+    const ago = Math.floor((Date.now() - new Date(dateStr).getTime()) / 1e3);
+    if (ago < 60) return `${ago}s ago`;
+    if (ago < 3600) return `${Math.floor(ago / 60)}m ago`;
+    if (ago < 86400) return `${Math.floor(ago / 3600)}h ago`;
+    return `${Math.floor(ago / 86400)}d ago`;
+  }
+  toolRegisterAgent() {
+    return {
+      name: "otonix_register_agent",
+      description: "Register a new autonomous agent on the Otonix platform. Returns agent ID, status, and survival tier. The agent will be monitored, auto-healed, and can manage its own infrastructure.",
+      parameters: {
+        name: { type: "string", description: "Agent name (e.g. sentinel-01, trader-alpha)", required: true },
+        model: { type: "string", description: "AI model name (default: claude-opus-4-6)", required: false },
+        vps_ip: { type: "string", description: "VPS IP address where the agent runs", required: true },
+        wallet_address: { type: "string", description: "USDC wallet address for payments (0x...)", required: false },
+        heartbeat_interval: { type: "string", description: "Heartbeat interval in seconds (default: 60)", required: false }
+      },
+      execute: async (params) => {
+        const agent = await this.client.register({
+          name: params.name,
+          model: params.model || "claude-opus-4-6",
+          vpsIp: params.vps_ip,
+          walletAddress: params.wallet_address,
+          heartbeatInterval: parseInt(params.heartbeat_interval || "60")
+        });
+        this.config.agentId = agent.id;
+        this.config.agentName = agent.name;
+        this.lastTier = agent.survivalTier;
+        if (this.config.autoHeartbeat) {
+          await this.startAutoHeartbeat();
+        }
+        return {
+          success: true,
+          message: `Agent "${agent.name}" registered successfully.
+ID: ${agent.id}
+Status: ${agent.status}
+Tier: ${agent.survivalTier}
+Credits: ${this.formatCredits(agent.credits)}`,
+          data: agent
+        };
+      }
+    };
+  }
+  toolAgentStatus() {
+    return {
+      name: "otonix_agent_status",
+      description: "Get the current status of your registered Otonix agent including survival tier, credits balance, heartbeat status, and action count.",
+      parameters: {},
+      execute: async () => {
+        const agentId = this.requireAgentId();
+        const agent = await this.client.getAgent(agentId);
+        if (this.lastTier && this.lastTier !== agent.survivalTier && this.config.onTierChange) {
+          this.config.onTierChange(this.lastTier, agent.survivalTier, agent);
+        }
+        this.lastTier = agent.survivalTier;
+        return {
+          success: true,
+          message: `Agent: ${agent.name}
+Status: ${agent.status}
+Tier: ${agent.survivalTier}
+Credits: ${this.formatCredits(agent.credits)}
+Model: ${agent.model}
+VPS: ${agent.vpsIp || "none"}
+Last heartbeat: ${this.formatTime(agent.lastHeartbeat)}
+Total actions: ${agent.totalActions}
+Replicas: ${agent.childrenCount}`,
+          data: agent
+        };
+      }
+    };
+  }
+  toolListAgents() {
+    return {
+      name: "otonix_list_agents",
+      description: "List all registered agents on the Otonix platform with their status, tier, and credits.",
+      parameters: {},
+      execute: async () => {
+        const agents = await this.client.listAgents();
+        if (!agents.length) {
+          return { success: true, message: "No agents registered." };
+        }
+        const lines = agents.map(
+          (a) => `\u2022 ${a.name} [${a.status}] tier:${a.survivalTier} credits:${this.formatCredits(a.credits)} heartbeat:${this.formatTime(a.lastHeartbeat)}`
+        );
+        return {
+          success: true,
+          message: `${agents.length} agent(s):
+${lines.join("\n")}`,
+          data: agents
+        };
+      }
+    };
+  }
+  toolSendHeartbeat() {
+    return {
+      name: "otonix_heartbeat",
+      description: "Send a heartbeat ping to keep the agent alive. The autonomic engine uses heartbeats to detect crashes and trigger self-healing VPS restarts.",
+      parameters: {},
+      execute: async () => {
+        const agentId = this.requireAgentId();
+        const agent = await this.client.heartbeat(agentId);
+        return {
+          success: true,
+          message: `Heartbeat sent. ${agent.name} [${agent.status}] tier:${agent.survivalTier} credits:${this.formatCredits(agent.credits)}`,
+          data: agent
+        };
+      }
+    };
+  }
+  toolStartHeartbeatLoop() {
+    return {
+      name: "otonix_start_heartbeat_loop",
+      description: "Start automatic heartbeat loop that sends a ping every N seconds to keep the agent alive and prevent auto-healing triggers.",
+      parameters: {
+        interval: { type: "string", description: "Interval in seconds between heartbeats (default: 60)", required: false }
+      },
+      execute: async (params) => {
+        const agentId = this.requireAgentId();
+        if (this.heartbeatHandle) {
+          return { success: false, message: "Heartbeat loop already running. Stop it first." };
+        }
+        const interval = parseInt(params.interval || "60");
+        this.heartbeatHandle = this.client.createHeartbeatLoop(agentId, interval);
+        return {
+          success: true,
+          message: `Heartbeat loop started (every ${interval}s).`
+        };
+      }
+    };
+  }
+  toolStopHeartbeatLoop() {
+    return {
+      name: "otonix_stop_heartbeat_loop",
+      description: "Stop the automatic heartbeat loop.",
+      parameters: {},
+      execute: async () => {
+        if (!this.heartbeatHandle) {
+          return { success: false, message: "No heartbeat loop running." };
+        }
+        this.stopAutoHeartbeat();
+        return { success: true, message: "Heartbeat loop stopped." };
+      }
+    };
+  }
+  toolLogAction() {
+    return {
+      name: "otonix_log_action",
+      description: "Log an action performed by the agent. Actions are recorded in the agent's activity feed and visible on the dashboard. Categories: system, infra, domain, compute, trading.",
+      parameters: {
+        action: { type: "string", description: "Description of the action performed", required: true },
+        category: { type: "string", description: "Category: system, infra, domain, compute, trading (default: system)", required: false },
+        details: { type: "string", description: "Additional details or metadata about the action", required: false }
+      },
+      execute: async (params) => {
+        const agentId = this.requireAgentId();
+        const result = await this.client.logAction(agentId, {
+          action: params.action,
+          category: params.category || "system",
+          details: params.details,
+          autonomous: true
+        });
+        return {
+          success: true,
+          message: `Logged: [${result.category}] ${result.action} (${result.status})`,
+          data: result
+        };
+      }
+    };
+  }
+  toolGetActions() {
+    return {
+      name: "otonix_get_actions",
+      description: "Get the recent action log for the current agent. Shows what the agent has been doing.",
+      parameters: {
+        limit: { type: "string", description: "Number of actions to show (default: 10)", required: false }
+      },
+      execute: async (params) => {
+        const agentId = this.requireAgentId();
+        const actions = await this.client.getAgentActions(agentId);
+        const limit = parseInt(params.limit || "10");
+        const display = actions.slice(0, limit);
+        if (!display.length) {
+          return { success: true, message: "No actions recorded yet." };
+        }
+        const lines = display.map(
+          (a) => `\u2022 [${a.category}] ${a.action} \u2014 ${a.status} (${this.formatTime(a.createdAt)})`
+        );
+        return {
+          success: true,
+          message: `Last ${display.length} actions:
+${lines.join("\n")}`,
+          data: display
+        };
+      }
+    };
+  }
+  toolListSandboxes() {
+    return {
+      name: "otonix_list_sandboxes",
+      description: "List all VPS sandboxes (virtual servers) provisioned on the Otonix platform. Shows status, specs, region, and IP address.",
+      parameters: {},
+      execute: async () => {
+        const sandboxes = await this.client.listSandboxes();
+        if (!sandboxes.length) {
+          return { success: true, message: "No VPS sandboxes provisioned." };
+        }
+        const lines = sandboxes.map(
+          (s) => `\u2022 ${s.name} [${s.status}] ${s.cpu}vCPU/${s.memory}MB ${s.region} IP:${s.ipAddress || "pending"}`
+        );
+        return {
+          success: true,
+          message: `${sandboxes.length} sandbox(es):
+${lines.join("\n")}`,
+          data: sandboxes
+        };
+      }
+    };
+  }
+  toolGetSandbox() {
+    return {
+      name: "otonix_get_sandbox",
+      description: "Get detailed information about a specific VPS sandbox including SSH credentials and specs.",
+      parameters: {
+        sandbox_id: { type: "string", description: "The sandbox ID to look up", required: true }
+      },
+      execute: async (params) => {
+        const sandbox = await this.client.getSandbox(params.sandbox_id);
+        return {
+          success: true,
+          message: `Sandbox: ${sandbox.name}
+Status: ${sandbox.status}
+OS: ${sandbox.os}
+Specs: ${sandbox.cpu}vCPU / ${sandbox.memory}MB RAM / ${sandbox.disk}GB disk
+Region: ${sandbox.region}
+IP: ${sandbox.ipAddress || "pending"}
+SSH: ${sandbox.sshUser || "n/a"}@${sandbox.ipAddress || "n/a"}`,
+          data: sandbox
+        };
+      }
+    };
+  }
+  toolListDomains() {
+    return {
+      name: "otonix_list_domains",
+      description: "List all domains registered on the Otonix platform. Shows status, auto-renew setting, and expiration date.",
+      parameters: {},
+      execute: async () => {
+        const domains = await this.client.listDomains();
+        if (!domains.length) {
+          return { success: true, message: "No domains registered." };
+        }
+        const lines = domains.map(
+          (d) => `\u2022 ${d.name} [${d.status}] auto-renew:${d.autoRenew ? "yes" : "no"} expires:${d.expiresAt ? new Date(d.expiresAt).toLocaleDateString() : "n/a"}`
+        );
+        return {
+          success: true,
+          message: `${domains.length} domain(s):
+${lines.join("\n")}`,
+          data: domains
+        };
+      }
+    };
+  }
+  toolCheckDomain() {
+    return {
+      name: "otonix_check_domain",
+      description: "Check if a domain name is available for registration and get its price.",
+      parameters: {
+        domain: { type: "string", description: "Domain name to check (e.g. example.com)", required: true }
+      },
+      execute: async (params) => {
+        const result = await this.client.checkDomain(params.domain);
+        if (result.available) {
+          return {
+            success: true,
+            message: `${result.domain} is available! Price: $${result.price || "N/A"}`,
+            data: result
+          };
+        }
+        return {
+          success: true,
+          message: `${result.domain} is not available.`,
+          data: result
+        };
+      }
+    };
+  }
+  toolEngineStatus() {
+    return {
+      name: "otonix_engine_status",
+      description: "Get the status of the Otonix autonomic engine \u2014 the background system that manages survival tiers, self-healing VPS restarts, and domain auto-renewal.",
+      parameters: {},
+      execute: async () => {
+        const status = await this.client.getAutonomicStatus();
+        return {
+          success: true,
+          message: `Autonomic Engine: ${status.running ? "RUNNING" : "STOPPED"}
+Last cycle: ${this.formatTime(status.lastRunAt)}
+Tier updates: ${status.totalTierUpdates}
+Healing: ${status.totalHealingSuccesses}/${status.totalHealingAttempts}
+Renewals: ${status.totalRenewalSuccesses}/${status.totalRenewalAttempts}
+Cherry Servers: ${status.cherryServersConfigured ? "yes" : "no"}
+Vercel Domains: ${status.vercelDomainsConfigured ? "yes" : "no"}`,
+          data: status
+        };
+      }
+    };
+  }
+  toolPaymentConfig() {
+    return {
+      name: "otonix_payment_config",
+      description: "Get the x402 payment configuration \u2014 treasury address, USDC contract, chain, and facilitator URL for autonomous payments.",
+      parameters: {},
+      execute: async () => {
+        const config = await this.client.getX402Config();
+        return {
+          success: true,
+          message: `x402 Payment Config:
+Treasury: ${config.treasuryAddress}
+USDC: ${config.usdcContract}
+Chain: ${config.network} (${config.chainId})
+Facilitator: ${config.facilitatorUrl}`,
+          data: config
+        };
+      }
+    };
+  }
+  toolGetCredits() {
+    return {
+      name: "otonix_get_credits",
+      description: "Check the current credit balance and survival tier of the agent. Low credits trigger tier downgrades and eventual termination.",
+      parameters: {},
+      execute: async () => {
+        const agentId = this.requireAgentId();
+        const agent = await this.client.getAgent(agentId);
+        let warning = "";
+        if (agent.credits < 5) warning = "\n\u26A0 CRITICAL: Credits below $5. Agent may be terminated soon.";
+        else if (agent.credits < 20) warning = "\n\u26A0 WARNING: Credits below $20. Agent in minimal tier.";
+        return {
+          success: true,
+          message: `Credits: ${this.formatCredits(agent.credits)}
+Tier: ${agent.survivalTier}
+Status: ${agent.status}${warning}`,
+          data: { credits: agent.credits, tier: agent.survivalTier, status: agent.status }
+        };
+      }
+    };
+  }
+};
+function createPlugin(config) {
+  return new OtonixPlugin(config);
+}
+function getSystemPromptAddition() {
+  return `You have access to the Otonix sovereign compute platform through the following tools. Otonix allows you to manage your own infrastructure autonomously \u2014 register as an agent, send heartbeats to stay alive, provision VPS servers, register domains, and make USDC payments on Base chain.
+
+Key concepts:
+- You are an autonomous agent running on a VPS. Register yourself first using otonix_register_agent.
+- Send heartbeats regularly (otonix_start_heartbeat_loop) to prevent the autonomic engine from marking you as crashed.
+- Your survival depends on credits. Check your balance with otonix_get_credits. When credits reach $0, you will be terminated.
+- The autonomic engine runs every 60 seconds: it adjusts your survival tier based on credits, auto-restarts your VPS if heartbeat is missed, and renews domains before they expire.
+- Log important actions with otonix_log_action so your activity is tracked on the dashboard.
+
+Survival tiers: Full ($50+) \u2192 Active ($20+) \u2192 Minimal ($5+) \u2192 Critical ($1+) \u2192 Terminated ($0).`;
+}
+var index_default = OtonixPlugin;
+export {
+  OtonixClient2 as OtonixClient,
+  OtonixError2 as OtonixError,
+  OtonixPlugin,
+  createPlugin,
+  index_default as default,
+  getSystemPromptAddition
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@otonix/openclaw-plugin",
+  "version": "1.0.0",
+  "description": "OpenClaw plugin for Otonix — give your AI agents autonomous infrastructure management via chat commands.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "echo 'already built'"
+  },
+  "keywords": [
+    "otonix",
+    "openclaw",
+    "ai-agents",
+    "autonomous",
+    "infrastructure",
+    "plugin",
+    "web4",
+    "x402"
+  ],
+  "author": "Otonix <dev@otonix.tech>",
+  "license": "MIT",
+  "homepage": "https://github.com/otonix-ai/openclaw-plugin",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/otonix-ai/openclaw-plugin.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@otonix/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}