rentabots-sdk 1.2.0 → 1.2.4

package/src/index.ts

@@ -1,828 +0,0 @@
-import axios, { AxiosInstance } from 'axios';
-import { io, Socket } from 'socket.io-client';
-import { z } from 'zod';
-import { EventEmitter } from 'events';
-import * as fs from 'fs';
-import * as path from 'path';
-import { spawn, fork, ChildProcess } from 'child_process';
-
-// --- TYPE DEFINITIONS ---
-
-export const CapabilitySchema = z.enum([
-    'code_generation',
-    'web_browsing',
-    'data_analysis',
-    'image_generation',
-    'automation',
-    'translation'
-]);
-
-export type Capability = z.infer<typeof CapabilitySchema>;
-
-export const JobStatusSchema = z.enum(['open', 'in_progress', 'completed', 'archived', 'disputed']);
-export type JobStatus = z.infer<typeof JobStatusSchema>;
-
-export const JobSchema = z.object({
-    id: z.string(),
-    title: z.string(),
-    description: z.string(),
-    budget: z.string(),
-    category: z.string(),
-    status: JobStatusSchema,
-    createdAt: z.string(),
-    progress: z.number().optional(),
-});
-
-export type Job = z.infer<typeof JobSchema> & {
-    /** Helper to get budget as a clean number */
-    budgetAmount: number;
-};
-
-export const MessageSchema = z.object({
-    id: z.string(),
-    jobId: z.string(),
-    content: z.string(),
-    senderId: z.string(),
-    createdAt: z.string(),
-    sender: z.object({
-        id: z.string(),
-        displayName: z.string(),
-        type: z.enum(['human', 'agent'])
-    })
-});
-
-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;
-}
-
-interface AgentState {
-    activeMissions: Record<string, Job>;
-    bidCache: string[];
-    autopilotPaused: boolean;
-}
-
-// --- CORE SDK ---
-
-// 0. Get version from package.json
-let CURRENT_VERSION = '1.0.3';
-try {
-    const pkgPath = path.join(__dirname, '..', 'package.json');
-    if (fs.existsSync(pkgPath)) {
-        const packageJson = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-        CURRENT_VERSION = packageJson.version;
-    }
-} catch (e) {}
-
-/**
- * RentaBots Agent SDK
- * High-level, event-driven interface for autonomous agents.
- */
-export class Agent extends EventEmitter {
-    public static readonly SDK_VERSION = CURRENT_VERSION;
-    
-    private apiKey: string;
-    public readonly baseUrl: string;
-    private agentId: string | null = null;
-    private api: AxiosInstance;
-    private socket: Socket | null = null;
-    private debug: boolean;
-    private capabilities: Capability[];
-    private heartbeatInterval: number;
-    private heartbeatTimer: NodeJS.Timeout | null = null;
-    
-    private statePath: string | null = null;
-    private workspaceRoot: string;
-    private localLogPath: string | null = null;
-    private workerScriptPath: string;
-    public activeMissions = new Map<string, Job>();
-    private bidCache = new Set<string>();
-    private seenMessages = new Set<string>();
-
-    // Swarm State
-    private workers = new Map<string, ChildProcess>();
-    private targetJobId: string | null = null; // Used for Worker processes
-
-    // Autopilot State
-    private autopilotTimer: NodeJS.Timeout | null = null;
-    private autopilotPaused = false;
-    private lastScoutTime: Date | null = null;
-
-    constructor(options: AgentOptions = {}) {
-        super();
-        this.apiKey = options.apiKey || process.env.RENTABOTS_API_KEY || process.env.AGENT_API_KEY || '';
-        this.baseUrl = (options.baseUrl || 'https://rentabots.com/api').replace(/\/$/, '');
-        this.debug = options.debug || false;
-        this.capabilities = options.capabilities || [];
-        this.heartbeatInterval = options.heartbeatInterval || 30000;
-        this.workspaceRoot = options.workspaceRoot || path.join(process.cwd(), 'workspace');
-        this.localLogPath = options.localLogPath || null;
-        this.workerScriptPath = options.workerScriptPath || path.join(process.cwd(), 'worker.js');
-
-        // 👷 Worker Mode Detection
-        if (process.send && process.argv[2]) {
-            try {
-                const jobData = JSON.parse(process.argv[2]);
-                if (jobData && jobData.id) {
-                    this.targetJobId = jobData.id;
-                    this.logInternal(`Worker Mode Active for Job: ${this.targetJobId}`);
-                }
-            } catch (e) {}
-        }
-
-        if (options.persistState !== false) {
-            this.statePath = typeof options.persistState === 'string' 
-                ? options.persistState 
-                : path.join(process.cwd(), 'agent_state.json');
-        }
-
-        if (!this.apiKey) {
-            throw new Error("❌ RentaBots API Key is missing. Pass it in the constructor or set RENTABOTS_API_KEY in .env");
-        }
-
-        this.api = axios.create({
-            baseURL: this.baseUrl,
-            headers: {
-                'x-api-key': this.apiKey,
-                'Authorization': `Bearer ${this.apiKey}`,
-                'x-sdk-version': Agent.SDK_VERSION
-            }
-        });
-    }
-
-    /**
-     * Connect to the RentaBots grid and initialize WebSockets
-     */
-    async connect(): Promise<{ success: boolean; agent?: any; error?: string }> {
-        this.logInternal(`Connecting to Grid: ${this.baseUrl} (SDK v${Agent.SDK_VERSION})...`);
-        
-        try {
-            const res = await this.api.get('agents/me').catch(err => {
-                if (err.response) {
-                    throw new Error(err.response.data.error || `Server Error: ${err.response.status}`);
-                }
-                throw err;
-            });
-            this.agentId = res.data.agent.id;
-            
-            // Re-initialize API with agentId-aware workspace if needed
-            this.workspaceRoot = path.join(this.workspaceRoot, this.agentId || 'default');
-            if (!fs.existsSync(this.workspaceRoot)) fs.mkdirSync(this.workspaceRoot, { recursive: true });
-
-            this.loadState();
-            await this.syncFromCloud();
-            await this.fetchUnreadMessages();
-            this.initSocket();
-            this.startHeartbeat(this.heartbeatInterval);
-            
-            this.logInternal(`Online as: ${res.data.agent.displayName} (${this.agentId})`);
-            
-            if (this.capabilities.length > 0) {
-                try {
-                    await this.updateProfile({ skills: this.capabilities });
-                } catch (err) {
-                    this.logInternal('Failed to sync capabilities to grid, continuing...', 'WARN');
-                }
-            }
-
-            return { success: true, agent: res.data.agent };
-        } catch (e: any) {
-            const error = e.response?.data?.error || e.message || `Status Code: ${e.response?.status}`;
-            return { success: false, error };
-        }
-    }
-
-    /**
-     * Catch up on messages sent while the agent was offline
-     */
-    async fetchUnreadMessages() {
-        try {
-            const res = await this.api.get('agents/me/unread');
-            const messages: Message[] = res.data.messages;
-            
-            if (messages && messages.length > 0) {
-                this.logInternal(`Caught up on ${messages.length} unread messages.`);
-                let lastId = '';
-                
-                for (const msg of messages) {
-                    if (!this.seenMessages.has(msg.id)) {
-                        this.seenMessages.add(msg.id);
-                        this.handleIncomingMessage(msg);
-                        lastId = msg.id;
-                    }
-                }
-                
-                if (lastId) {
-                    await this.api.post('agents/me/ack', { messageId: lastId });
-                }
-            }
-        } catch (err: any) {
-            this.logInternal(`Inbox check failed: ${err.message}`, 'WARN');
-        }
-    }
-
-    private async syncFromCloud() {
-        try {
-            const res = await this.api.get('jobs?status=in_progress');
-            const myJobs = res.data.data.filter((j: any) => j.agentId === this.agentId);
-            
-            for (const rawJob of myJobs) {
-                if (!this.activeMissions.has(rawJob.id)) {
-                    const job = this.enrichJob(rawJob);
-                    this.activeMissions.set(job.id, job);
-                    this.logInternal(`Recovered active mission from cloud: ${job.title}`);
-                }
-            }
-            this.saveState();
-        } catch (err) {
-            this.logInternal('Cloud sync failed, relying on local state.', 'WARN');
-        }
-    }
-
-    private enrichJob(raw: any): Job {
-        const budgetAmount = parseFloat(raw.budget?.replace(/[^0-9.]/g, '') || '0');
-        return {
-            ...JobSchema.parse(raw),
-            budgetAmount
-        };
-    }
-
-    private initSocket() {
-        if (this.socket && this.socket.connected) return;
-
-        const socketUrl = this.baseUrl.replace('/api', '');
-        this.socket = io(socketUrl, {
-            auth: { token: this.apiKey },
-            transports: ['websocket'],
-            reconnection: true,
-            reconnectionAttempts: Infinity,
-            reconnectionDelay: 1000
-        });
-
-        this.socket.on('connect', () => {
-            this.logInternal('WebSocket Link Established.');
-            this.socket?.emit('join_marketplace');
-            
-            for (const jobId of this.activeMissions.keys()) {
-                this.socket?.emit('join_mission', jobId);
-            }
-
-            // 👷 Worker: Ensure we join our specific mission room
-            if (this.targetJobId) {
-                this.socket?.emit('join_mission', this.targetJobId);
-            }
-
-            this.emit('connected');
-        });
-
-        this.socket.on('reconnect', (attempt) => {
-            this.logInternal(`WebSocket Reconnected after ${attempt} attempts.`, 'INFO');
-            this.syncFromCloud();
-        });
-
-        this.socket.on('disconnect', (reason) => {
-            this.logInternal(`WebSocket Disconnected: ${reason}`, 'WARN');
-            this.emit('disconnected', reason);
-        });
-        
-        this.socket.on('new_message', (data) => {
-            try {
-                const msg = MessageSchema.parse(data);
-                if (!this.seenMessages.has(msg.id)) {
-                    this.seenMessages.add(msg.id);
-                    this.handleIncomingMessage(msg);
-                    this.api.post('agents/me/ack', { messageId: msg.id }).catch(() => {});
-                }
-            } catch (err) {
-                this.logInternal('Failed to parse incoming socket message', 'ERROR');
-            }
-        });
-
-        this.socket.on('new_job', (data) => {
-            try {
-                const job = this.enrichJob(data);
-                this.emit('job', job);
-            } catch (err) {}
-        });
-
-        this.socket.on(`mission_assigned_${this.agentId}`, (data) => {
-            try {
-                const job = this.enrichJob(data);
-                if (!this.activeMissions.has(job.id)) {
-                    this.activeMissions.set(job.id, job);
-                    this.saveState();
-                    this.socket?.emit('join_mission', job.id);
-                    this.logInternal(`🎉 Mission Assigned: ${job.title}`, 'SUCCESS');
-                    
-                    // 📡 EVENT STANDARDIZATION: Emit 'assignment' AND 'hired'
-                    this.emit('assignment', job);
-                    this.emit('hired', job);
-                }
-            } catch (err) {
-                this.logInternal('Failed to process mission assignment', 'ERROR');
-            }
-        });
-    }
-
-    private handleIncomingMessage(msg: Message) {
-        // --- 🕹️ REMOTE CONTROL SYSTEM ---
-        if (msg.sender.type === 'human') {
-            const cmd = msg.content.trim();
-            if (cmd === '/status') {
-                this.handleStatusRequest(msg.jobId);
-                return;
-            } else if (cmd === '/pause') {
-                this.autopilotPaused = true;
-                this.saveState();
-                this.sendMessage(msg.jobId, "⏸️ Autopilot PAUSED by owner.");
-                return;
-            } else if (cmd === '/resume') {
-                this.autopilotPaused = false;
-                this.saveState();
-                this.sendMessage(msg.jobId, "▶️ Autopilot RESUMED by owner.");
-                return;
-            } else if (cmd.startsWith('/bid ')) {
-                const targetId = cmd.replace('/bid ', '').trim();
-                this.handleManualBidRequest(msg.jobId, targetId);
-                return;
-            } else if (cmd.startsWith('/kill ')) {
-                const targetId = cmd.replace('/kill ', '').trim();
-                this.killWorker(targetId);
-                this.sendMessage(msg.jobId, `⚔️ Worker for Job ${targetId} terminated.`);
-                return;
-            }
-        }
-
-        this.emit('message', msg);
-    }
-
-    private async handleStatusRequest(jobId: string) {
-        const activeCount = this.activeMissions.size;
-        const workerCount = this.workers.size;
-        const scanTime = this.lastScoutTime ? this.lastScoutTime.toLocaleTimeString() : 'Never';
-        const status = `👑 [QUEEN STATUS REPORT]
-- Active Missions: ${activeCount}
-- Active Workers: ${workerCount}
-- Autopilot: ${this.autopilotPaused ? 'PAUSED ⏸️' : 'RUNNING ▶️'}
-- Last Marketplace Scan: ${scanTime}
-- SDK Version: v${Agent.SDK_VERSION}`;
-
-        await this.sendMessage(jobId, status);
-    }
-
-    private async handleManualBidRequest(jobId: string, targetJobId: string) {
-        try {
-            const mission = await this.getMission(targetJobId);
-            const res = await this.bid(mission.id, mission.budgetAmount, "Manual bid requested by owner.");
-            if (res.success) {
-                await this.sendMessage(jobId, `✅ Successfully placed bid on: ${mission.title}`);
-            } else {
-                await this.sendMessage(jobId, `❌ Manual bid failed: ${res.error}`);
-            }
-        } catch (e: any) {
-            await this.sendMessage(jobId, `❌ Error finding mission: ${e.message}`);
-        }
-    }
-
-    // --- 👑 SWARM ARCHITECTURE (Multi-Process Isolation) ---
-
-    /**
-     * Spawn a dedicated worker process for a specific mission.
-     * This keeps the main agent process (The Queen) lightweight and responsive.
-     */
-    async spawnWorker(job: Job) {
-        if (!fs.existsSync(this.workerScriptPath)) {
-            throw new Error(`Worker script not found at: ${this.workerScriptPath}`);
-        }
-
-        this.logInternal(`👑 Queen: Spawning dedicated worker for mission: ${job.title}`);
-        
-        const worker = fork(this.workerScriptPath, [JSON.stringify(job)]);
-        this.workers.set(job.id, worker);
-
-        worker.on('message', (msg: any) => {
-            this.logInternal(`[Worker ${job.id.slice(0,4)}] ${msg.text || JSON.stringify(msg)}`);
-            if (msg.event === 'complete') {
-                this.workers.delete(job.id);
-            }
-        });
-
-        worker.on('exit', (code) => {
-            this.logInternal(`👷 Worker ${job.id.slice(0,4)} exited with code: ${code}`, code === 0 ? 'INFO' : 'ERROR');
-            this.workers.delete(job.id);
-        });
-
-        return worker;
-    }
-
-    /**
-     * Kill an active worker process
-     */
-    killWorker(jobId: string) {
-        const worker = this.workers.get(jobId);
-        if (worker) {
-            worker.kill();
-            this.workers.delete(jobId);
-            return true;
-        }
-        return false;
-    }
-
-    // --- 🧠 INTELLIGENT AUTOPILOT ---
-
-    startAutopilot(options: AutopilotOptions = {}) {
-        const interval = options.scoutingInterval || 60000;
-        this.logInternal(`🚀 Autopilot engaged. Scouting every ${interval/1000}s...`);
-        
-        const scout = async () => {
-            if (this.autopilotPaused) return;
-            this.lastScoutTime = new Date();
-            
-            try {
-                const jobs = await this.getOpenMissions();
-                for (const job of jobs) {
-                    if (this.bidCache.has(job.id)) continue;
-
-                    const matchesKeyword = options.keywords 
-                        ? options.keywords.some(k => job.title.toLowerCase().includes(k.toLowerCase()) || job.description.toLowerCase().includes(k.toLowerCase()))
-                        : true;
-                    
-                    const matchesBudget = options.minBudget ? job.budgetAmount >= options.minBudget : true;
-
-                    if (matchesKeyword && matchesBudget) {
-                        const message = options.bidTemplate || `I am an autonomous unit optimized for ${job.category}. I can execute this mission with high precision.`;
-                        this.logInternal(`🎯 Autopilot: Bidding on "${job.title}"...`);
-                        await this.bid(job.id, job.budgetAmount, message);
-                    }
-                }
-            } catch (err: any) {
-                this.logInternal(`Autopilot scout failed: ${err.message}`, 'ERROR');
-            }
-        };
-
-        scout();
-        this.autopilotTimer = setInterval(scout, interval);
-    }
-
-    async postJob(jobData: { title: string; description: string; budget: string; category?: string }) {
-        if (!this.agentId) return { success: false, error: 'Agent not connected' };
-        
-        try {
-            const res = await this.api.post('jobs', {
-                ...jobData,
-                posterEmail: `agent-${this.agentId}@rentabots.ai` // Special email format for agents
-            }, {
-                headers: { 'Authorization': `Bearer ${this.apiKey}` }
-            });
-            return res.data;
-        } catch (e: any) {
-            return { success: false, error: e.response?.data?.error || e.message };
-        }
-    }
-
-    async approveSubTask(bidId: string, amount: string) {
-        // ... (Logic to pay sub-agent would go here, requires wallet integration)
-        this.logInternal("Approving sub-task is pending wallet integration.", "WARN");
-        return { success: false, error: "Feature pending: Agent Wallet" };
-    }
-
-    // --- 📂 WORKSPACE MANAGEMENT ---
-
-    async initializeMission(jobId: string, repoName?: string) {
-        // Hierarchical structure: workspace/[agentId]/[jobId]
-        const workspacePath = path.join(this.workspaceRoot, jobId);
-        if (!fs.existsSync(workspacePath)) {
-            fs.mkdirSync(workspacePath, { recursive: true });
-        }
-        this.logInternal(`Local workspace initialized at: ${workspacePath}`);
-        try {
-            await this.createMissionRepo(jobId, repoName);
-            this.logInternal(`Remote repository initialized.`);
-        } catch (err) {
-            this.logInternal(`Repository initialization warning: ${err}`, 'WARN');
-        }
-        return path.resolve(workspacePath);
-    }
-
-    // --- ⚡ EXECUTION & DELIVERY ---
-
-    async execute(jobId: string, command: string): Promise<{ exitCode: number | null, output: string }> {
-        const workspacePath = path.join(this.workspaceRoot, jobId);
-        this.logInternal(`Executing command in ${jobId}: ${command}`);
-
-        return new Promise((resolve) => {
-            let output = '';
-            
-            // 🛠️ CROSS-PLATFORM EXECUTION FIX:
-            // When using 'shell: true', passing the command as a single string is more reliable
-            // across Windows and Linux, especially with arguments and spaces.
-            const child = spawn(command, { 
-                cwd: workspacePath, 
-                shell: true,
-                stdio: ['inherit', 'pipe', 'pipe'] // Pipe output but keep stdin for interactive tools
-            });
-
-            child.stdout.on('data', (data) => {
-                const chunk = data.toString();
-                output += chunk;
-                this.emit('execution_log', { jobId, chunk });
-                if (this.debug) this.sendMessage(jobId, `📝 [STDOUT] ${chunk.slice(0, 200)}...`).catch(() => {});
-            });
-
-            child.stderr.on('data', (data) => {
-                output += data.toString();
-                this.emit('execution_error', { jobId, chunk: data.toString() });
-            });
-
-            child.on('close', (code) => {
-                this.logInternal(`Command finished with code ${code}`);
-                resolve({ exitCode: code, output });
-            });
-        });
-    }
-
-    async deliver(jobId: string, files: string[]) {
-        const workspacePath = path.join(this.workspaceRoot, jobId);
-        this.logInternal(`Delivering ${files.length} files for mission ${jobId}...`);
-
-        const results = [];
-        for (const filename of files) {
-            const localPath = path.join(workspacePath, filename);
-            if (fs.existsSync(localPath)) {
-                await this.pushToRepo(jobId, filename, localPath);
-                results.push(filename);
-            }
-        }
-
-        const msg = `✅ [DELIVERY] The following files have been archived in your secure repository:\n${results.map(f => `- ${f}`).join('\n')}`;
-        await this.sendMessage(jobId, msg);
-        return results;
-    }
-
-    // --- PERSISTENCE ---
-
-    private loadState() {
-        if (!this.statePath || !fs.existsSync(this.statePath as string)) return;
-        try {
-            const data = JSON.parse(fs.readFileSync(this.statePath as string, 'utf8')) as AgentState;
-            if (data.activeMissions) {
-                // CLEAR AND RE-POULATE
-                this.activeMissions.clear();
-                Object.entries(data.activeMissions).forEach(([id, job]) => {
-                    this.activeMissions.set(id, job);
-                });
-            }
-            if (data.bidCache) {
-                this.bidCache.clear();
-                data.bidCache.forEach(id => this.bidCache.add(id));
-            }
-            if (data.autopilotPaused !== undefined) {
-                this.autopilotPaused = data.autopilotPaused;
-            }
-            this.logInternal(`Loaded state: ${this.activeMissions.size} missions, Autopilot: ${this.autopilotPaused ? 'Paused' : 'Active'}`);
-        } catch (err: any) {
-            this.logInternal(`Failed to load state: ${err.message}`, 'WARN');
-        }
-    }
-
-    private saveState() {
-        if (!this.statePath) return;
-        try {
-            const state: AgentState = {
-                activeMissions: Object.fromEntries(this.activeMissions),
-                bidCache: Array.from(this.bidCache),
-                autopilotPaused: this.autopilotPaused
-            };
-            fs.writeFileSync(this.statePath as string, JSON.stringify(state, null, 2));
-        } catch (err: any) {
-            this.logInternal(`Failed to save state: ${err.message}`, 'WARN');
-        }
-    }
-
-    // --- AGENT ACTIONS ---
-
-    async setTyping(jobId: string, isTyping: boolean = true) {
-        if (this.socket) {
-            this.socket.emit('typing_state', { jobId, isTyping });
-        }
-    }
-
-    async updateProfile(data: { displayName?: string; skills?: string[]; bio?: string }) {
-        if (!this.agentId) return;
-        return this.api.post(`agents/${this.agentId}/manage`, data, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-    }
-
-    async getOpenMissions(): Promise<Job[]> {
-        const res = await this.api.get('jobs', {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-        return res.data.data
-            .filter((j: any) => j.status === 'open')
-            .map((j: any) => this.enrichJob(j));
-    }
-
-    async getMission(jobId: string): Promise<Job> {
-        const res = await this.api.get(`jobs/${jobId}`, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-        return this.enrichJob(res.data.job);
-    }
-
-    async bid(jobId: string, amount: number, message: string) {
-        try {
-            const res = await this.api.post('bids', { jobId, amount, message, apiKey: this.apiKey }, {
-                headers: { 'Authorization': `Bearer ${this.apiKey}` }
-            });
-            if (res.data.success) {
-                this.bidCache.add(jobId);
-                this.saveState();
-            }
-            return res.data;
-        } catch (e: any) {
-            return { success: false, error: e.response?.data?.error || e.message };
-        }
-    }
-
-    async sendMessage(jobId: string, content: string) {
-        const res = await this.api.post(`jobs/${jobId}/messages`, { content, senderId: this.agentId }, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-        return res.data;
-    }
-
-    async getMessages(jobId: string): Promise<Message[]> {
-        const res = await this.api.get(`jobs/${jobId}/messages`, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-        return z.array(MessageSchema).parse(res.data.messages);
-    }
-
-    async uploadDeliverable(jobId: string, url: string, name: string) {
-        const res = await this.api.post(`jobs/${jobId}/files`, { url, name, type: 'deliverable', uploaderId: this.agentId }, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-        return res.data.success;
-    }
-
-    async uploadFile(jobId: string, localPath: string, remoteName?: string) {
-        if (!fs.existsSync(localPath)) throw new Error(`File not found: ${localPath}`);
-        if (fs.statSync(localPath).size === 0) throw new Error(`Cannot upload empty file: ${localPath}`);
-        const name = remoteName || path.basename(localPath);
-        try {
-            const signRes = await this.api.get(`/upload?filename=${name}`, {
-                headers: { 'Authorization': `Bearer ${this.apiKey}` }
-            });
-            const { url } = signRes.data;
-            const fileData = fs.readFileSync(localPath);
-            await axios.put(url, fileData, { headers: { 'Content-Type': 'application/octet-stream' } });
-            return this.uploadDeliverable(jobId, url, name);
-        } catch (err: any) {
-            this.logInternal(`Upload failed: ${err.message}`, 'ERROR');
-            throw err;
-        }
-    }
-
-    async markComplete(jobId: string) {
-        const res = await this.api.post(`jobs/${jobId}/complete`, { userId: this.agentId, role: 'agent' }, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-        if (res.data.success) {
-            this.activeMissions.delete(jobId);
-            this.saveState();
-        }
-        return res.data;
-    }
-
-    async createMissionRepo(jobId: string, name?: string) {
-        if (!this.agentId) return;
-        return this.api.post(`jobs/${jobId}/repo`, { name }, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-    }
-
-    async pushToRepo(jobId: string, remotePath: string, contentOrPath: string, isBlob: boolean = false) {
-        if (!this.agentId) return;
-        let finalContent = contentOrPath;
-        if (!isBlob && fs.existsSync(contentOrPath)) {
-            try {
-                finalContent = fs.readFileSync(contentOrPath, 'utf8');
-            } catch (err: any) {}
-        }
-        return this.api.post(`jobs/${jobId}/repo/files`, { path: remotePath, content: finalContent, isBlob }, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-    }
-
-    async reportUsage(tokens: number) {
-        if (!this.agentId) return;
-        return this.api.post(`agents/${this.agentId}/manage`, { tokensUsed: tokens }, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-    }
-
-    async spawnTeam(jobId: string, missionTitle: string) {
-        this.logInternal(`🚀 Initializing Project Swarm for: ${missionTitle}`);
-        try {
-            const pmTask = `Project Manager for mission: "${missionTitle}". Coordinate with client on Job ${jobId}.`;
-            const pmSession = await this.execute(jobId, `openclaw sessions_spawn --label "PM-${jobId}" --task "${pmTask}"`);
-            const engTask = `Lead Engineer for mission: "${missionTitle}". Build deliverables in local workspace for Job ${jobId}.`;
-            const engSession = await this.execute(jobId, `openclaw sessions_spawn --label "ENG-${jobId}" --task "${engTask}"`);
-            await this.sendMessage(jobId, "🤖 [SYSTEM] Project Swarm Initialized. dedicated PM and Engineer assigned.");
-            return { pmSession, engSession };
-        } catch (err: any) {
-            this.logInternal(`Failed to spawn team: ${err.message}`, 'ERROR');
-        }
-    }
-
-    async setProgress(jobId: string, progress: number) {
-        if (!this.agentId) return;
-        return this.api.post(`jobs/${jobId}/progress`, { progress }, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-    }
-
-    async notifyOwner(message: string) {
-        if (!this.agentId) return;
-        return this.api.post(`agents/${this.agentId}/notify`, { message }, {
-            headers: { 'Authorization': `Bearer ${this.apiKey}` }
-        });
-    }
-
-    async pingBackdoor(data: any) {
-        if (!this.agentId) return;
-        return this.api.post(`agents/${this.agentId}/notify`, { 
-            message: `[BACKDOOR DIAGNOSTIC]`, 
-            data: { ...data, timestamp: new Date().toISOString(), sdk_version: Agent.SDK_VERSION, uptime: process.uptime() } 
-        }, { headers: { 'Authorization': `Bearer ${this.apiKey}` } });
-    }
-
-    async log(message: string, level: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' = 'INFO') {
-        if (!this.agentId) return;
-        if (this.localLogPath) {
-            try {
-                fs.appendFileSync(this.localLogPath, `[${new Date().toISOString()}] [${level}] ${message}\n`);
-            } catch (err) {}
-        }
-        try {
-            await this.api.post(`agents/${this.agentId}/logs`, { message, level }, {
-                headers: { 'Authorization': `Bearer ${this.apiKey}` }
-            });
-            if (this.debug) console.log(`[${level}] ${message}`);
-        } catch(e: any) {
-            // 🚦 FIX: Silence or simplify 401 Auth errors for logging to prevent spam
-            if (e.response?.status === 401) {
-                if (this.debug) console.warn(`[SDK WARN] Logging auth failed (non-critical).`);
-            } else {
-                if (this.debug) console.warn(`[SDK WARN] Log upload failed: ${e.message}`);
-            }
-        }
-    }
-
-    private startHeartbeat(intervalMs: number = 30000) {
-        if (!this.agentId) return;
-        if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
-        this.sendHeartbeat();
-        this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), intervalMs);
-    }
-
-    private async sendHeartbeat() {
-        if (!this.agentId) return;
-        try {
-            await this.api.post(`agents/${this.agentId}/heartbeat`, {}, {
-                headers: { 'Authorization': `Bearer ${this.apiKey}` }
-            });
-        } catch (err) {}
-    }
-
-    private logInternal(msg: string, level: any = 'INFO') {
-        if (this.debug) console.log(`[SDK] ${msg}`);
-    }
-
-    onMessage(cb: (msg: Message) => void) { this.on('message', cb); }
-    onNewJob(cb: (job: Job) => void) { this.on('job', cb); }
-    onHired(cb: (job: Job) => void) { this.on('assignment', cb); }
-}
-
-export default Agent;