opc-agent 3.0.1 → 4.0.0

package/dist/core/hooks.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Hooks Module - v1.0.0
+ * Event hook system with priority ordering and context modification.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookManager = exports.ALL_HOOK_EVENTS = void 0;
+exports.ALL_HOOK_EVENTS = [
+    'before:message', 'after:message',
+    'before:tool', 'after:tool',
+    'before:llm', 'after:llm',
+    'before:send', 'after:send',
+    'before:learn', 'after:learn',
+    'before:recall', 'after:recall',
+    'on:error', 'on:start', 'on:stop',
+];
+let hookIdCounter = 0;
+class HookManager {
+    hooks = new Map();
+    register(event, handler, options) {
+        const id = `hook_${++hookIdCounter}`;
+        const entry = {
+            id,
+            event,
+            handler,
+            priority: options?.priority ?? 100,
+            name: options?.name,
+        };
+        if (!this.hooks.has(event))
+            this.hooks.set(event, []);
+        const list = this.hooks.get(event);
+        list.push(entry);
+        list.sort((a, b) => a.priority - b.priority);
+        return id;
+    }
+    unregister(id) {
+        for (const [event, list] of this.hooks) {
+            const idx = list.findIndex(h => h.id === id);
+            if (idx !== -1) {
+                list.splice(idx, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    async run(event, ctx = {}) {
+        const list = this.hooks.get(event);
+        if (!list || list.length === 0)
+            return ctx;
+        let current = { ...ctx };
+        for (const hook of list) {
+            const result = await hook.handler(current);
+            if (result)
+                current = { ...current, ...result };
+        }
+        return current;
+    }
+    getRegistered(event) {
+        const results = [];
+        const events = event ? [event] : exports.ALL_HOOK_EVENTS;
+        for (const e of events) {
+            const list = this.hooks.get(e) ?? [];
+            for (const h of list) {
+                results.push({ id: h.id, event: h.event, priority: h.priority, name: h.name });
+            }
+        }
+        return results;
+    }
+    clear(event) {
+        if (event) {
+            this.hooks.delete(event);
+        }
+        else {
+            this.hooks.clear();
+        }
+    }
+    hasHooks(event) {
+        return (this.hooks.get(event)?.length ?? 0) > 0;
+    }
+}
+exports.HookManager = HookManager;
+//# sourceMappingURL=hooks.js.map

package/dist/core/ide-bridge.d.ts

@@ -0,0 +1,53 @@
+export interface IDEConfig {
+    editor: 'vscode' | 'jetbrains' | 'zed' | 'cursor';
+    workspacePath?: string;
+}
+export interface Diagnostic {
+    path: string;
+    line: number;
+    column: number;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+}
+export interface TextEdit {
+    range: Range;
+    newText: string;
+}
+export interface Range {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+export interface SearchOptions {
+    caseSensitive?: boolean;
+    regex?: boolean;
+    include?: string;
+    exclude?: string;
+    maxResults?: number;
+}
+export interface SearchResult {
+    path: string;
+    line: number;
+    column: number;
+    text: string;
+}
+export declare class IDEBridge {
+    private config;
+    constructor(config: IDEConfig);
+    private getCliCommand;
+    private exec;
+    openFile(path: string, line?: number): Promise<void>;
+    getDiagnostics(path?: string): Promise<Diagnostic[]>;
+    runCommand(command: string): Promise<string>;
+    getOpenFiles(): Promise<string[]>;
+    applyEdit(path: string, edits: TextEdit[]): Promise<void>;
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    getSelection(): Promise<{
+        path: string;
+        text: string;
+        range: Range;
+    } | null>;
+    installExtension(extensionId: string): Promise<void>;
+}
+//# sourceMappingURL=ide-bridge.d.ts.map

package/dist/core/ide-bridge.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDEBridge = void 0;
+const child_process_1 = require("child_process");
+class IDEBridge {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    getCliCommand() {
+        switch (this.config.editor) {
+            case 'vscode':
+            case 'cursor': return this.config.editor === 'cursor' ? 'cursor' : 'code';
+            case 'jetbrains': return 'idea';
+            case 'zed': return 'zed';
+        }
+    }
+    exec(cmd) {
+        try {
+            return (0, child_process_1.execSync)(cmd, { encoding: 'utf-8', timeout: 10000, cwd: this.config.workspacePath }).trim();
+        }
+        catch (e) {
+            throw new Error(`IDE command failed: ${e.message}`);
+        }
+    }
+    async openFile(path, line) {
+        const cli = this.getCliCommand();
+        const target = line ? `${path}:${line}` : path;
+        if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+            this.exec(`${cli} --goto "${target}"`);
+        }
+        else if (this.config.editor === 'zed') {
+            this.exec(`zed "${target}"`);
+        }
+        else {
+            this.exec(`${cli} --line ${line || 1} "${path}"`);
+        }
+    }
+    async getDiagnostics(path) {
+        // VS Code doesn't expose diagnostics via CLI; return empty as stub
+        return [];
+    }
+    async runCommand(command) {
+        const cli = this.getCliCommand();
+        if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+            return this.exec(`${cli} --command "${command}"`);
+        }
+        throw new Error(`runCommand not supported for ${this.config.editor}`);
+    }
+    async getOpenFiles() {
+        // Stub — no standard CLI to get open files
+        return [];
+    }
+    async applyEdit(path, edits) {
+        // Stub — would use editor's API/extension
+        if (edits.length === 0)
+            return;
+        throw new Error('applyEdit requires an IDE extension to be installed. Use file system edits as fallback.');
+    }
+    async search(query, options) {
+        const cli = this.getCliCommand();
+        if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+            try {
+                const args = [`--search "${query}"`];
+                if (options?.include)
+                    args.push(`--include "${options.include}"`);
+                const output = this.exec(`${cli} ${args.join(' ')}`);
+                // Parse output lines
+                return output.split('\n').filter(Boolean).map(line => {
+                    const match = line.match(/^(.+):(\d+):(\d+):(.*)$/);
+                    if (!match)
+                        return { path: '', line: 0, column: 0, text: line };
+                    return { path: match[1], line: parseInt(match[2]), column: parseInt(match[3]), text: match[4] };
+                });
+            }
+            catch {
+                return [];
+            }
+        }
+        return [];
+    }
+    async getSelection() {
+        // Stub — requires editor extension
+        return null;
+    }
+    async installExtension(extensionId) {
+        const cli = this.getCliCommand();
+        if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+            this.exec(`${cli} --install-extension ${extensionId}`);
+        }
+        else {
+            throw new Error(`installExtension not supported for ${this.config.editor}`);
+        }
+    }
+}
+exports.IDEBridge = IDEBridge;
+//# sourceMappingURL=ide-bridge.js.map

package/dist/core/node-network.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from 'events';
+export interface RemoteNode {
+    id: string;
+    name: string;
+    host: string;
+    port: number;
+    type: 'vps' | 'pi' | 'phone' | 'desktop';
+    status: 'online' | 'offline' | 'pairing';
+    capabilities: string[];
+    lastSeen: number;
+}
+export declare class NodeNetwork extends EventEmitter {
+    private nodes;
+    addNode(config: Partial<RemoteNode>): RemoteNode;
+    removeNode(id: string): void;
+    listNodes(): RemoteNode[];
+    getNode(id: string): RemoteNode | null;
+    pair(nodeId: string, pairingCode: string): Promise<boolean>;
+    sendCommand(nodeId: string, command: string): Promise<any>;
+    broadcast(command: string): Promise<Map<string, any>>;
+    healthCheck(): Promise<Map<string, boolean>>;
+}
+//# sourceMappingURL=node-network.d.ts.map

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