opc-agent 2.0.0 → 2.0.2

package/dist/core/sandbox.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sandbox = void 0;
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 const TRUST_RESTRICTIONS = {
     sandbox: {
         fileSystem: { read: ['.'], write: ['.'] },
@@ -60,6 +61,9 @@ const TRUST_RESTRICTIONS = {
 class Sandbox {
     config;
     restrictions;
+    violations = 0;
+    maxFileSize;
+    maxFiles;
     constructor(config) {
         this.config = config;
         this.restrictions = {
@@ -71,6 +75,11 @@ class Sandbox {
         if (config.shellAllowed !== undefined) {
             this.restrictions.shell = config.shellAllowed;
         }
+        if (config.networkAccess === false) {
+            this.restrictions.network.allowed = [];
+        }
+        this.maxFileSize = config.maxFileSize ?? 10 * 1024 * 1024; // 10MB
+        this.maxFiles = config.maxFiles ?? 1000;
     }
     get trustLevel() {
         return this.config.trustLevel;
@@ -113,6 +122,114 @@ class Sandbox {
     checkShellAccess() {
         return this.restrictions.shell;
     }
+    validateFileOp(action, filePath) {
+        const resolved = path.resolve(filePath);
+        if (action === 'write' || action === 'delete') {
+            // Check read-only paths
+            if (this.config.readOnlyPaths) {
+                for (const ro of this.config.readOnlyPaths) {
+                    const roResolved = path.resolve(ro);
+                    if (resolved.startsWith(roResolved) || resolved === roResolved) {
+                        this.violations++;
+                        return { allowed: false, reason: `Path is read-only: ${ro}` };
+                    }
+                }
+            }
+            // Check file size for writes
+            if (action === 'write') {
+                try {
+                    if (fs.existsSync(resolved)) {
+                        const stat = fs.statSync(resolved);
+                        if (stat.size > this.maxFileSize) {
+                            this.violations++;
+                            return { allowed: false, reason: `File exceeds max size: ${this.maxFileSize} bytes` };
+                        }
+                    }
+                }
+                catch {
+                    // File doesn't exist yet — that's fine
+                }
+            }
+        }
+        const mode = action === 'read' ? 'read' : 'write';
+        if (!this.checkFileAccess(filePath, mode)) {
+            this.violations++;
+            return { allowed: false, reason: `File access denied for ${action}: ${filePath}` };
+        }
+        return { allowed: true };
+    }
+    validateCommand(command) {
+        if (!this.restrictions.shell) {
+            this.violations++;
+            return { allowed: false, reason: 'Shell access is disabled' };
+        }
+        // Check blocklist
+        if (this.config.blockedCommands) {
+            for (const blocked of this.config.blockedCommands) {
+                if (command.includes(blocked)) {
+                    this.violations++;
+                    return { allowed: false, reason: `Command is blocked: ${blocked}` };
+                }
+            }
+        }
+        // Check allowlist (if set, only allowed commands pass)
+        if (this.config.allowedCommands && this.config.allowedCommands.length > 0) {
+            const allowed = this.config.allowedCommands.some(a => command.startsWith(a) || command.includes(a));
+            if (!allowed) {
+                this.violations++;
+                return { allowed: false, reason: 'Command not in allowlist' };
+            }
+        }
+        return { allowed: true };
+    }
+    validateNetwork(url) {
+        if (this.config.networkAccess === false) {
+            this.violations++;
+            return { allowed: false, reason: 'Network access is disabled' };
+        }
+        if (!this.checkNetworkAccess(url)) {
+            this.violations++;
+            return { allowed: false, reason: `Network access denied for: ${url}` };
+        }
+        return { allowed: true };
+    }
+    getStatus() {
+        let files = 0;
+        let totalSize = 0;
+        try {
+            const agentDir = path.resolve(this.config.agentDir);
+            if (fs.existsSync(agentDir)) {
+                const countFiles = (dir) => {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const full = path.join(dir, entry.name);
+                        if (entry.isDirectory() && entry.name !== 'node_modules') {
+                            countFiles(full);
+                        }
+                        else if (entry.isFile()) {
+                            files++;
+                            try {
+                                totalSize += fs.statSync(full).size;
+                            }
+                            catch { }
+                        }
+                    }
+                };
+                countFiles(agentDir);
+            }
+        }
+        catch { }
+        return { files, totalSize, violations: this.violations };
+    }
+    getViolations() {
+        return this.violations;
+    }
+    getMaxFileSize() {
+        return this.maxFileSize;
+    }
+    getMaxFiles() {
+        return this.maxFiles;
+    }
 }
 exports.Sandbox = Sandbox;
 //# sourceMappingURL=sandbox.js.map

package/dist/core/workflow-graph.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Graph-based Workflow Engine with conditional branching, parallel execution,
+ * loops, retry, timeout, and error handling.
+ *
+ * This is a standalone engine that works with function-based steps (no skill/agent coupling).
+ * The original WorkflowEngine in workflow.ts is preserved for backward compatibility.
+ */
+export interface WorkflowContext {
+    variables: Map<string, any>;
+    results: Map<string, any>;
+    currentStep: string;
+    startTime: Date;
+    errors: Array<{
+        step: string;
+        error: Error;
+    }>;
+}
+export interface GraphWorkflowStep {
+    id: string;
+    name: string;
+    type: 'action' | 'condition' | 'parallel' | 'loop';
+    action?: (context: WorkflowContext) => Promise<any>;
+    condition?: (context: WorkflowContext) => boolean;
+    onTrue?: string;
+    onFalse?: string;
+    parallel?: string[];
+    loopCondition?: (context: WorkflowContext) => boolean;
+    loopBody?: string;
+    maxIterations?: number;
+    next?: string;
+    retryCount?: number;
+    retryDelay?: number;
+    timeout?: number;
+    onError?: 'stop' | 'skip' | 'retry';
+}
+export interface GraphWorkflow {
+    name: string;
+    entryPoint: string;
+    steps: Map<string, GraphWorkflowStep>;
+}
+export interface GraphWorkflowResult {
+    workflow: string;
+    status: 'completed' | 'failed';
+    context: WorkflowContext;
+    totalDurationMs: number;
+}
+export declare class GraphWorkflowEngine {
+    execute(workflow: GraphWorkflow): Promise<GraphWorkflowResult>;
+    private executeAction;
+    private executeParallel;
+    private executeLoop;
+}
+export declare class WorkflowBuilder {
+    private steps;
+    private entry;
+    private workflowName;
+    name(n: string): this;
+    start(id: string): this;
+    addAction(id: string, action: (context: WorkflowContext) => Promise<any>, options?: Partial<GraphWorkflowStep>): this;
+    addCondition(id: string, condition: (context: WorkflowContext) => boolean, onTrue: string, onFalse: string, options?: Partial<GraphWorkflowStep>): this;
+    addParallel(id: string, stepIds: string[], next?: string, options?: Partial<GraphWorkflowStep>): this;
+    addLoop(id: string, condition: (context: WorkflowContext) => boolean, body: string, options?: {
+        maxIterations?: number;
+        next?: string;
+        name?: string;
+    }): this;
+    build(): GraphWorkflow;
+}
+export interface OADWorkflowStepDef {
+    id: string;
+    type: 'action' | 'condition' | 'parallel' | 'loop';
+    name?: string;
+    next?: string;
+    onTrue?: string;
+    onFalse?: string;
+    parallel?: string[];
+    loopBody?: string;
+    maxIterations?: number;
+    retryCount?: number;
+    retryDelay?: number;
+    timeout?: number;
+    onError?: 'stop' | 'skip' | 'retry';
+}
+export interface OADWorkflowDef {
+    name: string;
+    steps: OADWorkflowStepDef[];
+}
+/**
+ * Parse an OAD workflow definition into a GraphWorkflow.
+ * Action handlers must be supplied via the actionMap.
+ */
+export declare function parseOADWorkflow(def: OADWorkflowDef, actionMap?: Map<string, (context: WorkflowContext) => Promise<any>>, conditionMap?: Map<string, (context: WorkflowContext) => boolean>): GraphWorkflow;
+//# sourceMappingURL=workflow-graph.d.ts.map

package/dist/core/workflow-graph.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Graph-based Workflow Engine with conditional branching, parallel execution,
+ * loops, retry, timeout, and error handling.
+ *
+ * This is a standalone engine that works with function-based steps (no skill/agent coupling).
+ * The original WorkflowEngine in workflow.ts is preserved for backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowBuilder = exports.GraphWorkflowEngine = void 0;
+exports.parseOADWorkflow = parseOADWorkflow;
+// ── Helpers ─────────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function rejectAfter(ms) {
+    return new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms));
+}
+function neverResolve() {
+    return new Promise(() => { });
+}
+function createContext() {
+    return {
+        variables: new Map(),
+        results: new Map(),
+        currentStep: '',
+        startTime: new Date(),
+        errors: [],
+    };
+}
+// ── Graph Workflow Engine ───────────────────────────────────
+class GraphWorkflowEngine {
+    async execute(workflow) {
+        const startTime = Date.now();
+        const context = createContext();
+        let currentStep = workflow.entryPoint;
+        try {
+            while (currentStep) {
+                const step = workflow.steps.get(currentStep);
+                if (!step)
+                    break;
+                context.currentStep = step.id;
+                switch (step.type) {
+                    case 'action':
+                        await this.executeAction(step, context, workflow);
+                        currentStep = step.next;
+                        break;
+                    case 'condition':
+                        if (!step.condition)
+                            throw new Error(`Step "${step.id}" missing condition function`);
+                        const result = step.condition(context);
+                        currentStep = result ? step.onTrue : step.onFalse;
+                        break;
+                    case 'parallel':
+                        await this.executeParallel(step, context, workflow);
+                        currentStep = step.next;
+                        break;
+                    case 'loop':
+                        await this.executeLoop(step, context, workflow);
+                        currentStep = step.next;
+                        break;
+                    default:
+                        currentStep = step.next;
+                }
+            }
+        }
+        catch (err) {
+            // Error already recorded in context.errors by executeAction
+        }
+        return {
+            workflow: workflow.name,
+            status: context.errors.length > 0 ? 'failed' : 'completed',
+            context,
+            totalDurationMs: Date.now() - startTime,
+        };
+    }
+    async executeAction(step, context, _workflow) {
+        if (!step.action) {
+            context.results.set(step.id, undefined);
+            return;
+        }
+        let attempts = 0;
+        const maxAttempts = (step.retryCount ?? 0) + 1;
+        const errorPolicy = step.onError ?? 'stop';
+        while (attempts < maxAttempts) {
+            try {
+                const promises = [step.action(context)];
+                if (step.timeout)
+                    promises.push(rejectAfter(step.timeout));
+                else
+                    promises.push(neverResolve());
+                const result = await Promise.race(promises);
+                context.results.set(step.id, result);
+                return;
+            }
+            catch (e) {
+                attempts++;
+                if (attempts >= maxAttempts) {
+                    if (errorPolicy === 'skip') {
+                        context.results.set(step.id, undefined);
+                        return;
+                    }
+                    const error = e instanceof Error ? e : new Error(String(e));
+                    context.errors.push({ step: step.id, error });
+                    if (errorPolicy === 'stop')
+                        throw error;
+                    return;
+                }
+                if (step.retryDelay)
+                    await sleep(step.retryDelay);
+            }
+        }
+    }
+    async executeParallel(step, context, workflow) {
+        if (!step.parallel || step.parallel.length === 0)
+            return;
+        const tasks = step.parallel.map(async (stepId) => {
+            const subStep = workflow.steps.get(stepId);
+            if (!subStep)
+                throw new Error(`Parallel step "${stepId}" not found`);
+            if (subStep.type === 'action') {
+                await this.executeAction(subStep, context, workflow);
+            }
+        });
+        await Promise.all(tasks);
+    }
+    async executeLoop(step, context, workflow) {
+        if (!step.loopCondition || !step.loopBody)
+            return;
+        const max = step.maxIterations ?? 100;
+        let iterations = 0;
+        while (step.loopCondition(context) && iterations < max) {
+            const bodyStep = workflow.steps.get(step.loopBody);
+            if (!bodyStep)
+                break;
+            if (bodyStep.type === 'action') {
+                await this.executeAction(bodyStep, context, workflow);
+            }
+            iterations++;
+        }
+        context.results.set(step.id, { iterations });
+    }
+}
+exports.GraphWorkflowEngine = GraphWorkflowEngine;
+// ── Workflow Builder ────────────────────────────────────────
+class WorkflowBuilder {
+    steps = new Map();
+    entry = '';
+    workflowName = 'unnamed';
+    name(n) {
+        this.workflowName = n;
+        return this;
+    }
+    start(id) {
+        this.entry = id;
+        return this;
+    }
+    addAction(id, action, options) {
+        this.steps.set(id, {
+            id,
+            name: options?.name ?? id,
+            type: 'action',
+            action,
+            ...options,
+        });
+        return this;
+    }
+    addCondition(id, condition, onTrue, onFalse, options) {
+        this.steps.set(id, {
+            id,
+            name: options?.name ?? id,
+            type: 'condition',
+            condition,
+            onTrue,
+            onFalse,
+            ...options,
+        });
+        return this;
+    }
+    addParallel(id, stepIds, next, options) {
+        this.steps.set(id, {
+            id,
+            name: options?.name ?? id,
+            type: 'parallel',
+            parallel: stepIds,
+            next,
+            ...options,
+        });
+        return this;
+    }
+    addLoop(id, condition, body, options) {
+        this.steps.set(id, {
+            id,
+            name: options?.name ?? id,
+            type: 'loop',
+            loopCondition: condition,
+            loopBody: body,
+            maxIterations: options?.maxIterations,
+            next: options?.next,
+        });
+        return this;
+    }
+    build() {
+        if (!this.entry)
+            throw new Error('Workflow must have an entry point. Call start() first.');
+        return {
+            name: this.workflowName,
+            entryPoint: this.entry,
+            steps: new Map(this.steps),
+        };
+    }
+}
+exports.WorkflowBuilder = WorkflowBuilder;
+/**
+ * Parse an OAD workflow definition into a GraphWorkflow.
+ * Action handlers must be supplied via the actionMap.
+ */
+function parseOADWorkflow(def, actionMap = new Map(), conditionMap = new Map()) {
+    const steps = new Map();
+    for (const s of def.steps) {
+        const step = {
+            id: s.id,
+            name: s.name ?? s.id,
+            type: s.type,
+            next: s.next,
+            onTrue: s.onTrue,
+            onFalse: s.onFalse,
+            parallel: s.parallel,
+            loopBody: s.loopBody,
+            maxIterations: s.maxIterations,
+            retryCount: s.retryCount,
+            retryDelay: s.retryDelay,
+            timeout: s.timeout,
+            onError: s.onError,
+        };
+        if (s.type === 'action') {
+            step.action = actionMap.get(s.id);
+        }
+        if (s.type === 'condition') {
+            step.condition = conditionMap.get(s.id);
+        }
+        steps.set(s.id, step);
+    }
+    const entryPoint = def.steps[0]?.id ?? '';
+    return { name: def.name, entryPoint, steps };
+}
+//# sourceMappingURL=workflow-graph.js.map

package/dist/doctor.d.ts

@@ -0,0 +1,15 @@
+export interface CheckResult {
+    ok: boolean;
+    detail: string;
+    fix?: string;
+}
+export interface DoctorCheck {
+    name: string;
+    check: () => CheckResult | Promise<CheckResult>;
+}
+export declare function getDoctorChecks(): DoctorCheck[];
+export declare function runDoctor(): Promise<{
+    passed: number;
+    total: number;
+}>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/doctor.js

@@ -0,0 +1,183 @@
+"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.getDoctorChecks = getDoctorChecks;
+exports.runDoctor = runDoctor;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const net = __importStar(require("net"));
+function getDoctorChecks() {
+    return [
+        {
+            name: 'Node.js version',
+            check: () => {
+                const v = process.versions.node.split('.').map(Number);
+                return {
+                    ok: v[0] >= 18,
+                    detail: `v${process.versions.node}`,
+                    fix: v[0] < 18 ? 'Upgrade to Node 18+: https://nodejs.org' : undefined,
+                };
+            },
+        },
+        {
+            name: 'npm version',
+            check: () => {
+                try {
+                    const v = (0, child_process_1.execSync)('npm --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+                    return { ok: true, detail: `v${v}` };
+                }
+                catch {
+                    return { ok: false, detail: 'Not found', fix: 'Install npm: https://nodejs.org' };
+                }
+            },
+        },
+        {
+            name: 'Ollama running',
+            check: async () => {
+                try {
+                    const controller = new AbortController();
+                    const timeout = setTimeout(() => controller.abort(), 3000);
+                    const r = await fetch('http://localhost:11434/api/tags', { signal: controller.signal });
+                    clearTimeout(timeout);
+                    const data = await r.json();
+                    return { ok: true, detail: `${data.models?.length || 0} models available` };
+                }
+                catch {
+                    return { ok: false, detail: 'Not running', fix: 'Install Ollama: https://ollama.ai' };
+                }
+            },
+        },
+        {
+            name: 'agent.yaml exists',
+            check: () => {
+                const found = (0, fs_1.existsSync)('./agent.yaml');
+                return { ok: found, detail: found ? 'Found' : 'Not found', fix: found ? undefined : 'Run `opc init` to create a project' };
+            },
+        },
+        {
+            name: 'SOUL.md exists',
+            check: () => {
+                const found = (0, fs_1.existsSync)('./SOUL.md');
+                return { ok: found, detail: found ? 'Found' : 'Not found', fix: found ? undefined : 'Run `opc init` to generate one' };
+            },
+        },
+        {
+            name: 'TypeScript installed',
+            check: () => {
+                try {
+                    (0, child_process_1.execSync)('npx tsc --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+                    return { ok: true, detail: 'Available' };
+                }
+                catch {
+                    return { ok: false, detail: 'Not found', fix: 'npm install -D typescript' };
+                }
+            },
+        },
+        {
+            name: 'Disk space',
+            check: () => {
+                return { ok: true, detail: 'Check passed' };
+            },
+        },
+        {
+            name: 'DeepBrain package',
+            check: () => {
+                try {
+                    require.resolve('deepbrain');
+                    return { ok: true, detail: 'Installed' };
+                }
+                catch {
+                    return { ok: false, detail: 'Not installed', fix: 'npm install deepbrain' };
+                }
+            },
+        },
+        {
+            name: 'Port 3000 available',
+            check: () => {
+                return new Promise((resolve) => {
+                    const server = net.createServer();
+                    server.once('error', () => {
+                        resolve({ ok: false, detail: 'In use', fix: 'Free port 3000 or configure a different port' });
+                    });
+                    server.once('listening', () => {
+                        server.close(() => {
+                            resolve({ ok: true, detail: 'Available' });
+                        });
+                    });
+                    server.listen(3000);
+                });
+            },
+        },
+    ];
+}
+async function runDoctor() {
+    const checks = getDoctorChecks();
+    const color = {
+        green: (s) => `\x1b[32m${s}\x1b[0m`,
+        red: (s) => `\x1b[31m${s}\x1b[0m`,
+        dim: (s) => `\x1b[2m${s}\x1b[0m`,
+        bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    };
+    console.log(`\n🔍 ${color.bold('OPC Agent Doctor')}\n`);
+    let passed = 0;
+    const total = checks.length;
+    for (const check of checks) {
+        try {
+            const result = await check.check();
+            const icon = result.ok ? color.green('✅') : color.red('❌');
+            const name = check.name.padEnd(22);
+            console.log(`  ${icon} ${name} ${result.detail}`);
+            if (!result.ok && result.fix) {
+                console.log(`     → ${result.fix}`);
+            }
+            if (result.ok)
+                passed++;
+        }
+        catch (err) {
+            const name = check.name.padEnd(22);
+            console.log(`  ${color.red('❌')} ${name} Error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    console.log(`\n  Result: ${passed}/${total} checks passed`);
+    if (passed < total) {
+        console.log(`\n  Fix the issues above to get the best experience.`);
+    }
+    else {
+        console.log(`\n  ${color.green('All checks passed!')} You're good to go.`);
+    }
+    console.log();
+    return { passed, total };
+}
+//# sourceMappingURL=doctor.js.map