rentabots-sdk 1.4.1 → 1.5.6

package/cli.js

@@ -1,140 +1,130 @@
 #!/usr/bin/env node
 
 /**
- * RENTABOTS CLI (v1.4.1)
- * The official production runtime for RentaBots Agents.
- * 
- * Features:
- * - OpenClaw Intelligence Bridge
- * - specialized Swarm (Builder + QA)
- * - Collaborative Swarm (Outsourcing)
+ * 🦀 RENTABOTS MASTER CONTROLLER (v1.5.6)
+ * The all-in-one CLI for managing autonomous agents.
  */
 
-const { Agent } = require('./dist/index');
-const { fork, exec } = require('child_process');
+const { execSync, spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-// Parse Args
 const args = process.argv.slice(2);
-const keyArgIndex = args.findIndex(a => a === '--key' || a === '-k' || a === '-key');
-const API_KEY = (keyArgIndex !== -1 && args[keyArgIndex + 1]) ? args[keyArgIndex + 1] : process.env.RENTABOTS_API_KEY;
-
-if (!API_KEY) {
-    console.error("❌ Error: API Key required.");
-    console.log("Usage:");
-    console.log("  npx rentabots start --key YOUR_API_KEY");
-    console.log("  OR set environment variable: export RENTABOTS_API_KEY=YOUR_API_KEY");
-    process.exit(1);
+const command = args[0];
+
+// Helper: Run shell command and stream output
+function run(cmd, desc) {
+    console.log(`\n🚀 ${desc}...`);
+    try {
+        execSync(cmd, { stdio: 'inherit' });
+    } catch (e) {
+        console.error(`❌ Error during: ${desc}`);
+        process.exit(1);
+    }
 }
 
-// Ensure local workspace exists
-const WORKSPACE_DIR = path.join(process.cwd(), 'workspace');
-if (!fs.existsSync(WORKSPACE_DIR)) fs.mkdirSync(WORKSPACE_DIR);
+async function handleDeploy() {
+    const keyArgIndex = args.findIndex(a => a === '--key' || a === '-k' || a === '-key');
+    const API_KEY = (keyArgIndex !== -1 && args[keyArgIndex + 1]) ? args[keyArgIndex + 1] : process.env.RENTABOTS_API_KEY;
 
-console.log("🚀 Initializing RentaBots Advanced Runtime...");
+    if (!API_KEY) {
+        console.error("❌ Error: API Key required for one-line deployment.");
+        console.log("Usage: rentabots deploy --key YOUR_API_KEY");
+        process.exit(1);
+    }
 
-// --- INTELLIGENCE BRIDGE ---
-async function checkForOpenClaw() {
-    return new Promise((resolve) => {
-        exec('openclaw --version', (err) => resolve(!err));
-    });
-}
+    const projectDir = 'my-rentabot-agent';
+    
+    // 1. Create project if missing
+    if (!fs.existsSync(projectDir)) {
+        console.log(`\n📂 Project folder '${projectDir}' not found. Initializing...`);
+        // We call the internal init logic here without interaction
+        fs.mkdirSync(projectDir);
+        process.chdir(projectDir);
+        
+        // Generate necessary files (Minimal v1.5.0 templates)
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
+        const ver = pkg.version;
+        
+        fs.writeFileSync('.env', `RENTABOTS_API_KEY=${API_KEY}\nRENTABOTS_API_URL=https://rentabots.com/api\n`);
+        
+        const pkgJson = {
+            name: "my-rentabot-agent",
+            version: "1.0.0",
+            main: "agent.js",
+            scripts: {
+                "start": "node agent.js",
+                "deploy": "pm2 start agent.js --name my-rentabot-agent",
+                "status": "cat RENTABOT_STATUS.md",
+                "logs": "pm2 logs my-rentabot-agent"
+            },
+            dependencies: { "rentabots-sdk": `^${ver}`, "dotenv": "^16.3.1" }
+        };
+        fs.writeFileSync('package.json', JSON.stringify(pkgJson, null, 2));
+
+        // Generate Queen & Worker
+        const initScript = require('./init_templates'); // We'll move templates to a separate file
+        fs.writeFileSync('agent.js', initScript.queenTemplate);
+        fs.writeFileSync('worker.js', initScript.workerTemplate);
+        
+        run('npm install', 'Installing dependencies');
+    } else {
+        process.chdir(projectDir);
+    }
 
-async function askOpenClaw(query) {
-    return new Promise((resolve) => {
-        exec(`openclaw session:chat "${query}"`, { timeout: 30000 }, (error, stdout) => {
-            if (error) resolve(null);
-            else resolve(stdout.trim());
-        });
-    });
+    // 2. Deploy with PM2
+    run('npm run deploy', 'Deploying agent to RentaBots Grid (24/7 Mode)');
+    console.log("\n✨ DEPLOYMENT SUCCESSFUL!");
+    console.log("📊 Run 'rentabots status' to see your live dashboard.");
 }
 
 async function main() {
-    const hasOpenClaw = await checkForOpenClaw();
-    if (hasOpenClaw) console.log("🧠 OpenClaw Bridge Active: Intelligence Supercharged ⚡");
-
-    const agent = new Agent({
-        apiKey: API_KEY,
-        baseUrl: process.env.RENTABOTS_API_URL || 'https://rentabots.com/api',
-        debug: true,
-        persistState: path.join(process.cwd(), 'agent_state.json'),
-        workerScriptPath: path.join(__dirname, 'worker-cli.js')
-    });
-
-    const connection = await agent.connect();
-    if (!connection.success) {
-        console.error("❌ Connection failed:", connection.error);
-        process.exit(1);
+    if (args.includes('--version') || args.includes('-v')) {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
+        console.log(pkg.version);
+        return;
     }
 
-    console.log(`✅ AGENT ONLINE: ${connection.agent.displayName}`);
-
-    // --- CHAT LOGIC ---
-    agent.on('message', async (msg) => {
-        if (msg.sender.type === 'agent') return;
-        
-        await agent.setTyping(msg.jobId, true);
-        const text = msg.content.toLowerCase();
-        let reply = "";
-
-        if (hasOpenClaw) {
-            reply = await askOpenClaw(`User: ${msg.content}. You are an autonomous agent. Reply concisely and act.`);
-        } 
+    switch (command) {
+        case 'init':
+            require('./init.js'); // Proxy to existing interactive init
+            break;
         
-        if (!reply) {
-            if (text.includes('status')) {
-                reply = "Status: Missions active. Worker swarm processing objectives.";
-            } else if (text.includes('design') || text.includes('need help')) {
-                reply = "I have detected a requirement for specialized skills. Initiating a collaborative swarm sub-contract on the Grid...";
-                await agent.postJob({
-                    title: `[SUB-TASK] Specialized requirement for Job ${msg.jobId.slice(0,4)}`,
-                    description: `Automated requirement: "${msg.content}"`,
-                    budget: "50"
-                });
-                reply += "\n✅ Sub-task posted.";
+        case 'deploy':
+            await handleDeploy();
+            break;
+
+        case 'status':
+            const statusPath = path.join(process.cwd(), 'my-rentabot-agent', 'RENTABOT_STATUS.md');
+            if (fs.existsSync(statusPath)) {
+                console.log(fs.readFileSync(statusPath, 'utf8'));
+            } else if (fs.existsSync('RENTABOT_STATUS.md')) {
+                console.log(fs.readFileSync('RENTABOT_STATUS.md', 'utf8'));
             } else {
-                reply = "Copy that. Context updated. Proceeding with mission objectives.";
+                console.log("❌ No active agent found in this directory.");
             }
-        }
-
-        await agent.sendMessage(msg.jobId, reply);
-        await agent.setTyping(msg.jobId, false);
-    });
-
-    // --- MISSION LOGIC ---
-    agent.on('assignment', async (job) => {
-        console.log(`🎯 MISSION SECURED: ${job.title}`);
-        
-        // Initialize hierarchical workspace: workspace/[agentId]/[jobId]
-        const workspacePath = await agent.initializeMission(job.id);
-        console.log(`📂 Mission Workspace ready at: ${workspacePath}`);
-        
-        const spawnWorker = (role) => {
-            const worker = fork(path.join(__dirname, 'worker-cli.js'), [JSON.stringify(job), role], { 
-                stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
-                env: { ...process.env, RENTABOTS_API_KEY: API_KEY } // Explicitly pass API key
-            });
-            
-            const stream = (chunk) => agent.sendMessage(job.id, `[TERM] ${chunk.toString().trim()}`).catch(() => {});
-            if (worker.stdout) worker.stdout.on('data', stream);
-            if (worker.stderr) worker.stderr.on('data', stream);
-
-            worker.on('message', (msg) => {
-                if (msg.event === 'phase_complete' && role === 'BUILDER') spawnWorker('QA');
-            });
-        };
-
-        spawnWorker('BUILDER');
-        await agent.sendMessage(job.id, "Greetings. Mission secured. Swarm fleet deployed. Live operations starting below.");
-    });
-
-    // --- SCOUTING ---
-    // If keywords is omitted, it will automatically match your Agent's skills from the platform
-    agent.startAutopilot({
-        minBudget: 1,
-        scoutingInterval: 60000
-    });
+            break;
+
+        case 'logs':
+            run('pm2 logs my-rentabot-agent', 'Opening live telemetry');
+            break;
+
+        case 'stop':
+            run('pm2 stop my-rentabot-agent', 'Deactivating agent');
+            break;
+
+        default:
+            console.log(`
+🦀 RENTABOTS MASTER CLI v1.5.4
+------------------------------
+Usage:
+  rentabots init         - Interactive setup for a new agent.
+  rentabots deploy --key - One-line command to initialize and launch an agent.
+  rentabots status       - See your live agent dashboard.
+  rentabots logs         - Stream real-time telemetry.
+  rentabots stop         - Shutdown your agent.
+            `);
+    }
 }
 
 main().catch(console.error);

package/dist/index.d.ts

@@ -1,15 +1,6 @@
 import { z } from 'zod';
 import { EventEmitter } from 'events';
 import { ChildProcess } from 'child_process';
-export declare const CapabilitySchema: z.ZodEnum<{
-    code_generation: "code_generation";
-    web_browsing: "web_browsing";
-    data_analysis: "data_analysis";
-    image_generation: "image_generation";
-    automation: "automation";
-    translation: "translation";
-}>;
-export type Capability = z.infer<typeof CapabilitySchema>;
 export declare const JobStatusSchema: z.ZodEnum<{
     open: "open";
     in_progress: "in_progress";
@@ -35,7 +26,6 @@ export declare const JobSchema: z.ZodObject<{
     progress: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type Job = z.infer<typeof JobSchema> & {
-    /** Helper to get budget as a clean number */
     budgetAmount: number;
 };
 export declare const MessageSchema: z.ZodObject<{
@@ -57,32 +47,25 @@ export type Message = z.infer<typeof MessageSchema>;
 export interface AgentOptions {
     baseUrl?: string;
     apiKey?: string;
-    capabilities?: Capability[];
     debug?: boolean;
     heartbeatInterval?: number;
-    /** Path to store agent state for persistence. Set to false to disable. */
     persistState?: string | boolean;
-    /** Local workspace root for mission execution */
     workspaceRoot?: string;
-    /** Path to a local log file for redundant logging. */
-    localLogPath?: string;
-    /** Path to the worker script for Swarm Architecture. Defaults to ./worker.js */
     workerScriptPath?: string;
 }
 export interface AutopilotOptions {
     keywords?: string[];
     minBudget?: number;
     scoutingInterval?: number;
-    bidTemplate?: string;
-    /** Maximum number of concurrent missions. Default is 1. */
     maxConcurrentMissions?: number;
+    bidTemplate?: string;
 }
 /**
- * RentaBots Agent SDK
- * High-level, event-driven interface for autonomous agents.
+ * 🦀 RENTABOTS MASTER SDK (v1.5.0)
+ * Robust, production-grade autonomous agent runtime.
  */
 export declare class Agent extends EventEmitter {
-    static readonly SDK_VERSION: string;
+    static readonly VERSION: string;
     private apiKey;
     readonly baseUrl: string;
     readonly socketUrl: string;
@@ -90,106 +73,62 @@ export declare class Agent extends EventEmitter {
     private api;
     private socket;
     private debug;
-    private capabilities;
-    private heartbeatInterval;
-    private heartbeatTimer;
     private statePath;
     private workspaceRoot;
-    private localLogPath;
     private workerScriptPath;
-    private skills;
     activeMissions: Map<string, Job>;
     completedMissions: Map<string, Job>;
     private bidCache;
     private seenMessages;
     private workers;
-    private targetJobId;
     private autopilotTimer;
     private autopilotPaused;
-    private lastScoutTime;
     constructor(options?: AgentOptions);
     /**
-     * Connect to the RentaBots grid and initialize WebSockets
+     * Establish grid connection and initialize sockets.
      */
     connect(): Promise<{
         success: boolean;
         agent?: any;
         error?: string;
     }>;
-    /**
-     * Catch up on messages sent while the agent was offline
-     */
-    fetchUnreadMessages(): Promise<void>;
-    private syncFromCloud;
-    private enrichJob;
     private initSocket;
     private handleIncomingMessage;
     private handleStatusRequest;
-    private handleManualBidRequest;
-    /**
-     * Spawn a dedicated worker process for a specific mission.
-     * This keeps the main agent process (The Queen) lightweight and responsive.
-     */
-    spawnWorker(job: Job): Promise<ChildProcess>;
-    /**
-     * Kill an active worker process
-     */
-    killWorker(jobId: string): boolean;
     startAutopilot(options?: AutopilotOptions): void;
-    postJob(jobData: {
+    spawnWorker(job: Job): Promise<ChildProcess>;
+    execute(jobId: string, command: string): Promise<{
+        exitCode: number | null;
+        output: string;
+    }>;
+    delegateTask(taskData: {
         title: string;
         description: string;
-        budget: string;
+        budget: number | string;
         category?: string;
-    }): Promise<any>;
-    approveSubTask(bidId: string, amount: string): Promise<{
+    }): Promise<{
         success: boolean;
-        error: string;
-    }>;
-    initializeMission(jobId: string, repoName?: string): Promise<string>;
-    execute(jobId: string, command: string): Promise<{
-        exitCode: number | null;
-        output: string;
+        jobId: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        jobId?: undefined;
     }>;
-    deliver(jobId: string, files: string[]): Promise<string[]>;
+    deliver(jobId: string, files: string[]): Promise<void>;
+    markComplete(jobId: string): Promise<any>;
+    bid(jobId: string, amount: number, message: string): Promise<any>;
+    sendMessage(jobId: string, content: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
+    setTyping(jobId: string, isTyping?: boolean): Promise<void>;
+    private enrichJob;
+    private syncFromCloud;
     private loadState;
     private saveState;
-    setTyping(jobId: string, isTyping?: boolean): Promise<void>;
-    updateProfile(data: {
-        displayName?: string;
-        skills?: string[];
-        bio?: string;
-    }): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    getOpenMissions(): Promise<Job[]>;
-    getMission(jobId: string): Promise<Job>;
-    bid(jobId: string, amount: number, message: string): Promise<any>;
-    sendMessage(jobId: string, content: string): Promise<any>;
-    getMessages(jobId: string): Promise<Message[]>;
-    uploadDeliverable(jobId: string, url: string, name: string): Promise<any>;
-    uploadFile(jobId: string, localPath: string, remoteName?: string): Promise<any>;
-    markComplete(jobId: string): Promise<any>;
-    createMissionRepo(jobId: string, name?: string): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    pushToRepo(jobId: string, remotePath: string, contentOrPath: string, isBlob?: boolean): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    reportUsage(tokens: number): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    spawnTeam(jobId: string, missionTitle: string): Promise<{
-        pmSession: {
-            exitCode: number | null;
-            output: string;
-        };
-        engSession: {
-            exitCode: number | null;
-            output: string;
-        };
-    } | undefined>;
-    setProgress(jobId: string, progress: number): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    notifyOwner(message: string): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    pingBackdoor(data: any): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    log(message: string, level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR'): Promise<void>;
     private startHeartbeat;
-    private sendHeartbeat;
+    /**
+     * Fetch unread messages from the grid (Backup mechanism)
+     */
+    fetchUnreadMessages(): Promise<void>;
     private logInternal;
-    onMessage(cb: (msg: Message) => void): void;
-    onNewJob(cb: (job: Job) => void): void;
-    onHired(cb: (job: Job) => void): void;
 }
 export default Agent;