opc-agent 3.0.1 → 4.0.1

package/dist/core/node-network.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeNetwork = void 0;
+const crypto_1 = require("crypto");
+const events_1 = require("events");
+class NodeNetwork extends events_1.EventEmitter {
+    nodes = new Map();
+    addNode(config) {
+        const node = {
+            id: config.id || (0, crypto_1.randomUUID)(),
+            name: config.name || 'unnamed',
+            host: config.host || 'localhost',
+            port: config.port || 8080,
+            type: config.type || 'desktop',
+            status: config.status || 'offline',
+            capabilities: config.capabilities || [],
+            lastSeen: Date.now(),
+        };
+        this.nodes.set(node.id, node);
+        return node;
+    }
+    removeNode(id) {
+        if (!this.nodes.has(id))
+            throw new Error(`Node ${id} not found`);
+        this.nodes.delete(id);
+    }
+    listNodes() {
+        return Array.from(this.nodes.values());
+    }
+    getNode(id) {
+        return this.nodes.get(id) || null;
+    }
+    async pair(nodeId, pairingCode) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            throw new Error(`Node ${nodeId} not found`);
+        if (!pairingCode || pairingCode.length < 4)
+            return false;
+        node.status = 'online';
+        node.lastSeen = Date.now();
+        return true;
+    }
+    async sendCommand(nodeId, command) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            throw new Error(`Node ${nodeId} not found`);
+        if (node.status !== 'online')
+            throw new Error(`Node ${nodeId} is ${node.status}`);
+        node.lastSeen = Date.now();
+        // Stub: return command echo
+        return { nodeId, command, status: 'sent', timestamp: Date.now() };
+    }
+    async broadcast(command) {
+        const results = new Map();
+        for (const [id, node] of this.nodes) {
+            if (node.status === 'online') {
+                try {
+                    results.set(id, await this.sendCommand(id, command));
+                }
+                catch (e) {
+                    results.set(id, { error: e.message });
+                }
+            }
+        }
+        return results;
+    }
+    async healthCheck() {
+        const results = new Map();
+        for (const [id, node] of this.nodes) {
+            results.set(id, node.status === 'online');
+            node.lastSeen = Date.now();
+        }
+        return results;
+    }
+}
+exports.NodeNetwork = NodeNetwork;
+//# sourceMappingURL=node-network.js.map

package/dist/core/profiles.d.ts

@@ -0,0 +1,27 @@
+export interface ProfileConfig {
+    model?: string;
+    systemPrompt?: string;
+    temperature?: number;
+    [key: string]: unknown;
+}
+export interface Profile {
+    name: string;
+    config: ProfileConfig;
+    createdAt: number;
+    lastUsed: number;
+}
+export declare class ProfileManager {
+    private profilesDir;
+    private currentName;
+    constructor(baseDir?: string);
+    private ensureDir;
+    private profileDir;
+    private profileFile;
+    create(name: string, config?: ProfileConfig): Profile;
+    switch(name: string): void;
+    list(): Profile[];
+    get(name: string): Profile;
+    delete(name: string): void;
+    current(): Profile;
+}
+//# sourceMappingURL=profiles.d.ts.map

package/dist/core/profiles.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// ─── ProfileManager ─────────────────────────────────────────
+class ProfileManager {
+    profilesDir;
+    currentName = 'default';
+    constructor(baseDir) {
+        this.profilesDir = baseDir ?? path.join(os.homedir(), '.opc', 'profiles');
+        this.ensureDir(this.profilesDir);
+        // Load current profile pointer
+        const pointerFile = path.join(this.profilesDir, '.current');
+        if (fs.existsSync(pointerFile)) {
+            this.currentName = fs.readFileSync(pointerFile, 'utf-8').trim();
+        }
+    }
+    ensureDir(dir) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    profileDir(name) {
+        return path.join(this.profilesDir, name);
+    }
+    profileFile(name) {
+        return path.join(this.profileDir(name), 'profile.json');
+    }
+    create(name, config = {}) {
+        const dir = this.profileDir(name);
+        if (fs.existsSync(dir)) {
+            throw new Error(`Profile '${name}' already exists`);
+        }
+        this.ensureDir(dir);
+        // Also create memory and sessions dirs
+        this.ensureDir(path.join(dir, 'memory'));
+        this.ensureDir(path.join(dir, 'sessions'));
+        const profile = {
+            name,
+            config,
+            createdAt: Date.now(),
+            lastUsed: Date.now(),
+        };
+        fs.writeFileSync(this.profileFile(name), JSON.stringify(profile, null, 2));
+        return profile;
+    }
+    switch(name) {
+        if (!fs.existsSync(this.profileDir(name))) {
+            throw new Error(`Profile '${name}' does not exist`);
+        }
+        this.currentName = name;
+        fs.writeFileSync(path.join(this.profilesDir, '.current'), name);
+        // Update lastUsed
+        const profile = this.get(name);
+        profile.lastUsed = Date.now();
+        fs.writeFileSync(this.profileFile(name), JSON.stringify(profile, null, 2));
+    }
+    list() {
+        if (!fs.existsSync(this.profilesDir))
+            return [];
+        return fs.readdirSync(this.profilesDir)
+            .filter(f => {
+            const full = path.join(this.profilesDir, f);
+            return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, 'profile.json'));
+        })
+            .map(f => this.get(f));
+    }
+    get(name) {
+        const file = this.profileFile(name);
+        if (!fs.existsSync(file)) {
+            throw new Error(`Profile '${name}' not found`);
+        }
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    delete(name) {
+        if (name === this.currentName) {
+            throw new Error(`Cannot delete the current active profile '${name}'`);
+        }
+        const dir = this.profileDir(name);
+        if (!fs.existsSync(dir)) {
+            throw new Error(`Profile '${name}' does not exist`);
+        }
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    current() {
+        try {
+            return this.get(this.currentName);
+        }
+        catch {
+            // Auto-create default
+            return this.create(this.currentName);
+        }
+    }
+}
+exports.ProfileManager = ProfileManager;
+//# sourceMappingURL=profiles.js.map

package/dist/core/sandbox.d.ts

@@ -51,4 +51,29 @@ export declare class Sandbox {
     getMaxFileSize(): number;
     getMaxFiles(): number;
 }
+export interface RemoteSandboxConfig {
+    backend: 'local' | 'docker' | 'ssh';
+    docker?: {
+        image: string;
+        volumes?: string[];
+    };
+    ssh?: {
+        host: string;
+        user: string;
+        keyPath?: string;
+    };
+    timeout?: number;
+}
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare class SandboxManager {
+    private defaultConfig;
+    constructor(config?: Partial<RemoteSandboxConfig>);
+    exec(command: string, config?: Partial<RemoteSandboxConfig>): Promise<ExecResult>;
+    upload(localPath: string, remotePath: string, config?: Partial<RemoteSandboxConfig>): Promise<void>;
+    download(remotePath: string, localPath: string, config?: Partial<RemoteSandboxConfig>): Promise<void>;
+}
 //# sourceMappingURL=sandbox.d.ts.map

package/dist/core/sandbox.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sandbox = void 0;
+exports.SandboxManager = exports.Sandbox = void 0;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const TRUST_RESTRICTIONS = {
@@ -232,4 +232,87 @@ class Sandbox {
     }
 }
 exports.Sandbox = Sandbox;
+class SandboxManager {
+    defaultConfig;
+    constructor(config) {
+        this.defaultConfig = {
+            backend: config?.backend ?? 'local',
+            docker: config?.docker,
+            ssh: config?.ssh,
+            timeout: config?.timeout ?? 30000,
+        };
+    }
+    async exec(command, config) {
+        const cfg = { ...this.defaultConfig, ...config };
+        const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        switch (cfg.backend) {
+            case 'local': {
+                try {
+                    const stdout = execSync(command, {
+                        timeout: cfg.timeout,
+                        encoding: 'utf-8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    return { stdout: stdout ?? '', stderr: '', exitCode: 0 };
+                }
+                catch (err) {
+                    return {
+                        stdout: err.stdout ?? '',
+                        stderr: err.stderr ?? '',
+                        exitCode: err.status ?? 1,
+                    };
+                }
+            }
+            case 'docker': {
+                if (!cfg.docker?.image)
+                    throw new Error('Docker image is required');
+                const volumes = (cfg.docker.volumes ?? []).map(v => `-v ${v}`).join(' ');
+                const dockerCmd = `docker run --rm ${volumes} ${cfg.docker.image} sh -c "${command.replace(/"/g, '\\"')}"`;
+                return this.exec(dockerCmd, { backend: 'local', timeout: cfg.timeout });
+            }
+            case 'ssh': {
+                if (!cfg.ssh?.host || !cfg.ssh?.user)
+                    throw new Error('SSH host and user are required');
+                const keyArg = cfg.ssh.keyPath ? `-i ${cfg.ssh.keyPath}` : '';
+                const sshCmd = `ssh ${keyArg} ${cfg.ssh.user}@${cfg.ssh.host} "${command.replace(/"/g, '\\"')}"`;
+                return this.exec(sshCmd, { backend: 'local', timeout: cfg.timeout });
+            }
+            default:
+                throw new Error(`Unknown sandbox backend: ${cfg.backend}`);
+        }
+    }
+    async upload(localPath, remotePath, config) {
+        const cfg = { ...this.defaultConfig, ...config };
+        if (cfg.backend === 'local') {
+            const fsp = await Promise.resolve().then(() => __importStar(require('fs')));
+            fsp.copyFileSync(localPath, remotePath);
+            return;
+        }
+        if (cfg.backend === 'ssh') {
+            const keyArg = cfg.ssh?.keyPath ? `-i ${cfg.ssh.keyPath}` : '';
+            await this.exec(`scp ${keyArg} "${localPath}" ${cfg.ssh.user}@${cfg.ssh.host}:"${remotePath}"`, { backend: 'local' });
+            return;
+        }
+        if (cfg.backend === 'docker') {
+            throw new Error('Upload to docker not yet supported. Use volumes instead.');
+        }
+    }
+    async download(remotePath, localPath, config) {
+        const cfg = { ...this.defaultConfig, ...config };
+        if (cfg.backend === 'local') {
+            const fsp = await Promise.resolve().then(() => __importStar(require('fs')));
+            fsp.copyFileSync(remotePath, localPath);
+            return;
+        }
+        if (cfg.backend === 'ssh') {
+            const keyArg = cfg.ssh?.keyPath ? `-i ${cfg.ssh.keyPath}` : '';
+            await this.exec(`scp ${keyArg} ${cfg.ssh.user}@${cfg.ssh.host}:"${remotePath}" "${localPath}"`, { backend: 'local' });
+            return;
+        }
+        if (cfg.backend === 'docker') {
+            throw new Error('Download from docker not yet supported. Use volumes instead.');
+        }
+    }
+}
+exports.SandboxManager = SandboxManager;
 //# sourceMappingURL=sandbox.js.map

package/dist/core/session-manager.d.ts

@@ -0,0 +1,33 @@
+import type { Message } from './types';
+export interface Session {
+    id: string;
+    agentId: string;
+    channel: string;
+    messages: Message[];
+    metadata: Record<string, any>;
+    createdAt: number;
+    lastActivity: number;
+    parentId?: string;
+    compactedAt?: number;
+}
+export declare class SessionManager {
+    private sessions;
+    private storageDir;
+    constructor(storageDir?: string);
+    create(agentId: string, channel: string, parentId?: string): Session;
+    get(id: string): Session | null;
+    list(filter?: {
+        agentId?: string;
+        channel?: string;
+        active?: boolean;
+    }): Session[];
+    addMessage(sessionId: string, message: Message): void;
+    compact(sessionId: string, brain?: any): Promise<void>;
+    prune(maxAge: number): number;
+    getLineage(sessionId: string): Session[];
+    fork(sessionId: string): Session;
+    export(sessionId: string): string;
+    save(): void;
+    load(): void;
+}
+//# sourceMappingURL=session-manager.d.ts.map

package/dist/core/session-manager.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+class SessionManager {
+    sessions = new Map();
+    storageDir;
+    constructor(storageDir) {
+        this.storageDir = storageDir || path.join(process.env.HOME || process.env.USERPROFILE || '~', '.opc', 'sessions');
+    }
+    create(agentId, channel, parentId) {
+        const session = {
+            id: crypto.randomUUID(),
+            agentId,
+            channel,
+            messages: [],
+            metadata: {},
+            createdAt: Date.now(),
+            lastActivity: Date.now(),
+            parentId,
+        };
+        this.sessions.set(session.id, session);
+        return session;
+    }
+    get(id) {
+        return this.sessions.get(id) || null;
+    }
+    list(filter) {
+        let result = Array.from(this.sessions.values());
+        if (filter?.agentId)
+            result = result.filter(s => s.agentId === filter.agentId);
+        if (filter?.channel)
+            result = result.filter(s => s.channel === filter.channel);
+        if (filter?.active !== undefined) {
+            const cutoff = Date.now() - 30 * 60 * 1000; // 30 min
+            result = result.filter(s => filter.active ? s.lastActivity > cutoff : s.lastActivity <= cutoff);
+        }
+        return result;
+    }
+    addMessage(sessionId, message) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session ${sessionId} not found`);
+        session.messages.push(message);
+        session.lastActivity = Date.now();
+    }
+    async compact(sessionId, brain) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session ${sessionId} not found`);
+        if (brain && typeof brain.compress === 'function') {
+            const compressed = await brain.compress(session.messages);
+            session.messages = [{ id: 'compacted', role: 'system', content: compressed, timestamp: Date.now() }];
+        }
+        else {
+            // Simple: keep first and last 5 messages
+            if (session.messages.length > 10) {
+                const first = session.messages.slice(0, 2);
+                const last = session.messages.slice(-5);
+                session.messages = [...first, { id: 'compacted', role: 'system', content: `[${session.messages.length - 7} messages compacted]`, timestamp: Date.now() }, ...last];
+            }
+        }
+        session.compactedAt = Date.now();
+    }
+    prune(maxAge) {
+        const cutoff = Date.now() - maxAge;
+        let pruned = 0;
+        for (const [id, session] of this.sessions) {
+            if (session.lastActivity < cutoff) {
+                this.sessions.delete(id);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    getLineage(sessionId) {
+        const lineage = [];
+        let current = this.sessions.get(sessionId);
+        while (current) {
+            lineage.unshift(current);
+            current = current.parentId ? this.sessions.get(current.parentId) || undefined : undefined;
+        }
+        return lineage;
+    }
+    fork(sessionId) {
+        const parent = this.sessions.get(sessionId);
+        if (!parent)
+            throw new Error(`Session ${sessionId} not found`);
+        return this.create(parent.agentId, parent.channel, parent.id);
+    }
+    export(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session ${sessionId} not found`);
+        const lines = [`# Session ${session.id}`, `Agent: ${session.agentId} | Channel: ${session.channel}`, `Created: ${new Date(session.createdAt).toISOString()}`, ''];
+        for (const msg of session.messages) {
+            lines.push(`**${msg.role}** (${new Date(msg.timestamp).toISOString()}):`);
+            lines.push(msg.content);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    save() {
+        if (!fs.existsSync(this.storageDir)) {
+            fs.mkdirSync(this.storageDir, { recursive: true });
+        }
+        for (const [id, session] of this.sessions) {
+            fs.writeFileSync(path.join(this.storageDir, `${id}.json`), JSON.stringify(session, null, 2));
+        }
+    }
+    load() {
+        if (!fs.existsSync(this.storageDir))
+            return;
+        const files = fs.readdirSync(this.storageDir).filter(f => f.endsWith('.json'));
+        for (const file of files) {
+            const data = JSON.parse(fs.readFileSync(path.join(this.storageDir, file), 'utf-8'));
+            this.sessions.set(data.id, data);
+        }
+    }
+}
+exports.SessionManager = SessionManager;
+//# sourceMappingURL=session-manager.js.map

package/dist/core/vision.d.ts

@@ -0,0 +1,45 @@
+export interface ImageInput {
+    type: 'base64' | 'url' | 'file';
+    data: string;
+    mimeType?: string;
+}
+export interface VisionResult {
+    description: string;
+    text_content?: string;
+    objects?: string[];
+}
+export declare function detectMimeType(buffer: Buffer): string;
+export interface VisionManagerConfig {
+    model?: string;
+    apiKey?: string;
+    baseURL?: string;
+    maxImageSize?: number;
+}
+export declare class VisionManager {
+    private config;
+    constructor(config?: VisionManagerConfig);
+    /**
+     * Load image data as base64, detecting MIME type.
+     */
+    loadImage(input: ImageInput): Promise<{
+        base64: string;
+        mimeType: string;
+    }>;
+    /**
+     * Prepare messages in OpenAI multimodal format.
+     */
+    prepareMessage(images: ImageInput[], text: string): Array<Record<string, unknown>>;
+    /**
+     * Analyze an image with optional prompt.
+     */
+    analyze(image: ImageInput, prompt?: string): Promise<VisionResult>;
+    /**
+     * Extract text (OCR) from an image.
+     */
+    extractText(image: ImageInput): Promise<string>;
+    /**
+     * Compare multiple images.
+     */
+    compareImages(images: ImageInput[], prompt?: string): Promise<string>;
+}
+//# sourceMappingURL=vision.d.ts.map