@veil-runtime/core 0.1.0

package/dist/runtime/jobs/job-manager.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobManager = void 0;
+const node_crypto_1 = require("node:crypto");
+const registry_js_1 = require("../registry/registry.js");
+const permissions_js_1 = require("../permissions/permissions.js");
+const plan_validator_js_1 = require("../execution/plan-validator.js");
+const result_reference_js_1 = require("../execution/result-reference.js");
+const memory_event_bus_js_1 = require("../events/memory-event-bus.js");
+const job_store_js_1 = require("./job-store.js");
+const console_execution_logger_js_1 = require("../execution/console-execution-logger.js");
+const console_log_sink_js_1 = require("../logging/console-log-sink.js");
+const composite_log_sink_js_1 = require("../logging/composite-log-sink.js");
+const sqlite_log_sink_js_1 = require("../logging/sqlite-log-sink.js");
+class JobManager {
+    async executePlan(plan, caller) {
+        if (!plan.steps.length) {
+            throw new Error('Execution plan contains no steps');
+        }
+        const validation = (0, plan_validator_js_1.validatePlan)(plan.steps);
+        if (!validation.valid) {
+            throw new Error(`Execution plan failed validation: ${validation.errors
+                .map((error) => error.message)
+                .join('; ')}`);
+        }
+        const goal = plan.goal?.trim() ||
+            'External execution plan';
+        const job = await this.create(goal);
+        job.idempotencyKey = plan.idempotencyKey;
+        job.steps = plan.steps.map((step) => ({
+            ...step,
+            status: 'pending',
+            createdAt: new Date().toISOString(),
+        }));
+        job.updatedAt =
+            new Date().toISOString();
+        await job_store_js_1.jobStore.update(job);
+        return this.execute(job.id, caller);
+    }
+    async create(goal, planner) {
+        if (!goal?.trim()) {
+            throw new Error('Job goal is required');
+        }
+        const now = new Date().toISOString();
+        const job = {
+            id: (0, node_crypto_1.randomUUID)(),
+            goal: goal.trim(),
+            planner,
+            status: 'created',
+            createdAt: now,
+            updatedAt: now,
+            steps: [],
+            events: [],
+        };
+        this.addEvent(job, 'job.created', {
+            goal: job.goal,
+        });
+        await job_store_js_1.jobStore.create(job);
+        return job;
+    }
+    async get(id) {
+        return job_store_js_1.jobStore.get(id);
+    }
+    async list(filter) {
+        return job_store_js_1.jobStore.list(filter);
+    }
+    async setStatus(id, status) {
+        const job = await job_store_js_1.jobStore.get(id);
+        if (!job) {
+            throw new Error(`Job not found: ${id}`);
+        }
+        job.status = status;
+        job.updatedAt = new Date().toISOString();
+        await job_store_js_1.jobStore.update(job);
+        return job;
+    }
+    async execute(id, caller) {
+        const job = await job_store_js_1.jobStore.get(id);
+        if (!job) {
+            throw new Error(`Job not found: ${id}`);
+        }
+        if (job.steps.length === 0) {
+            throw new Error('Job has no planned steps');
+        }
+        job.status = 'executing';
+        job.startedAt = new Date().toISOString();
+        job.updatedAt = job.startedAt;
+        this.addEvent(job, 'execution.started');
+        try {
+            for (const step of job.steps) {
+                const capability = registry_js_1.capabilityRegistry.get(step.capability);
+                if (!capability) {
+                    throw new Error(`Capability not found: ${step.capability}`);
+                }
+                const permission = (0, permissions_js_1.checkPermission)(capability.risk);
+                if (!permission.allowed) {
+                    throw new Error(permission.reason ??
+                        `Capability not permitted: ${step.capability}`);
+                }
+                step.status = 'running';
+                step.startedAt = new Date().toISOString();
+                this.addEvent(job, 'capability.started', {
+                    stepId: step.id,
+                    capability: step.capability,
+                });
+                try {
+                    const completedSteps = job.steps.slice(0, job.steps.indexOf(step));
+                    const resolvedInput = (0, result_reference_js_1.resolveResultReferences)(step.input, completedSteps);
+                    const inputValidation = (0, plan_validator_js_1.validateStepInput)(step, resolvedInput);
+                    if (!inputValidation.valid) {
+                        throw new Error(inputValidation.errors
+                            .map((validationError) => validationError.message)
+                            .join('; '));
+                    }
+                    const logger = new console_execution_logger_js_1.ConsoleExecutionLogger(job.id, step.id, new composite_log_sink_js_1.CompositeLogSink([
+                        new console_log_sink_js_1.ConsoleLogSink(),
+                        new sqlite_log_sink_js_1.SQLiteLogSink(),
+                    ]));
+                    const result = await capability.execute(resolvedInput, {
+                        jobId: job.id,
+                        stepId: step.id,
+                        logger,
+                        caller,
+                    });
+                    step.result = result;
+                    step.status = 'completed';
+                    step.completedAt = new Date().toISOString();
+                    this.addEvent(job, 'capability.completed', {
+                        stepId: step.id,
+                        capability: step.capability,
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error
+                        ? error.message
+                        : 'Unknown capability execution error';
+                    step.status = 'failed';
+                    step.error = message;
+                    step.completedAt = new Date().toISOString();
+                    this.addEvent(job, 'capability.failed', {
+                        stepId: step.id,
+                        capability: step.capability,
+                        error: message,
+                    });
+                    throw error;
+                }
+            }
+            job.status = 'completed';
+            job.outcome = 'success';
+            job.completedAt = new Date().toISOString();
+            job.updatedAt = job.completedAt;
+            job.result =
+                job.steps.length === 1
+                    ? job.steps[0].result
+                    : job.steps.map((step) => step.result);
+            this.addEvent(job, 'job.completed', {
+                stepCount: job.steps.length,
+            });
+            await job_store_js_1.jobStore.update(job);
+            return job;
+        }
+        catch (error) {
+            const message = error instanceof Error
+                ? error.message
+                : 'Unknown job execution error';
+            job.status = 'failed';
+            job.outcome = 'failed';
+            job.error = message;
+            job.completedAt = new Date().toISOString();
+            job.updatedAt = job.completedAt;
+            this.addEvent(job, 'job.failed', {
+                error: message,
+            });
+            await job_store_js_1.jobStore.update(job);
+            return job;
+        }
+    }
+    async review(id, outcome, notes) {
+        const job = await job_store_js_1.jobStore.get(id);
+        if (!job) {
+            throw new Error(`Job not found: ${id}`);
+        }
+        job.outcome = outcome;
+        job.updatedAt = new Date().toISOString();
+        this.addEvent(job, 'job.reviewed', {
+            outcome,
+            notes,
+        });
+        await job_store_js_1.jobStore.update(job);
+        return job;
+    }
+    addEvent(job, type, data) {
+        const event = {
+            id: (0, node_crypto_1.randomUUID)(),
+            jobId: job.id,
+            type,
+            timestamp: new Date().toISOString(),
+            data,
+        };
+        job.events.push(event);
+        void memory_event_bus_js_1.runtimeEventBus.publish({
+            id: event.id,
+            type: event.type,
+            timestamp: event.timestamp,
+            jobId: event.jobId,
+            stepId: typeof event.data?.stepId === 'string'
+                ? event.data.stepId
+                : undefined,
+            data: event.data,
+        });
+        return event;
+    }
+}
+exports.jobManager = new JobManager();

package/dist/runtime/jobs/job-memory.d.ts

@@ -0,0 +1,6 @@
+import { PlannerContext } from '../planner/planner.js';
+declare class JobMemory {
+    getPlannerContext(goal: string): Promise<PlannerContext>;
+}
+export declare const jobMemory: JobMemory;
+export {};

package/dist/runtime/jobs/job-memory.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobMemory = void 0;
+const job_store_js_1 = require("./job-store.js");
+const STOP_WORDS = new Set([
+    'read',
+    'write',
+    'check',
+    'run',
+    'show',
+    'tell',
+    'current',
+    'from',
+    'with',
+    'that',
+    'this',
+    'file',
+]);
+function extractKeywords(goal) {
+    return goal
+        .toLowerCase()
+        .split(/[^a-z0-9.]+/)
+        .filter((word) => word.length >= 4 &&
+        !STOP_WORDS.has(word))
+        .slice(0, 8);
+}
+function scoreJob(currentGoal, previousJob) {
+    const normalizedCurrentGoal = currentGoal.toLowerCase();
+    const previousGoal = previousJob.goal.toLowerCase();
+    const keywords = extractKeywords(currentGoal);
+    let score = keywords.reduce((total, keyword) => previousGoal.includes(keyword)
+        ? total + 1
+        : total, 0);
+    if (normalizedCurrentGoal.includes('linkedin') &&
+        previousGoal.includes('linkedin')) {
+        score += 3;
+    }
+    if (normalizedCurrentGoal.includes('git') &&
+        previousGoal.includes('git')) {
+        score += 3;
+    }
+    if (normalizedCurrentGoal.includes('readme') &&
+        previousGoal.includes('readme')) {
+        score += 3;
+    }
+    return score;
+}
+class JobMemory {
+    async getPlannerContext(goal) {
+        const jobs = await job_store_js_1.jobStore.list({
+            status: 'completed',
+        });
+        const relevant = jobs
+            .map((job) => ({
+            job,
+            score: scoreJob(goal, job),
+        }))
+            .filter(({ score }) => score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 3);
+        return {
+            previousJobs: relevant.map(({ job }) => ({
+                goal: job.goal,
+                status: job.status,
+                capabilities: job.steps.map((step) => step.capability),
+            })),
+        };
+    }
+}
+exports.jobMemory = new JobMemory();

package/dist/runtime/jobs/job-status.d.ts

@@ -0,0 +1 @@
+export type JobStatus = 'created' | 'planning' | 'awaiting_approval' | 'executing' | 'completed' | 'failed' | 'cancelled';

package/dist/runtime/jobs/job-status.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/jobs/job-step.d.ts

@@ -0,0 +1,10 @@
+export type JobStepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+export interface JobStep extends ExecutionStep {
+    status: JobStepStatus;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    result?: unknown;
+    error?: string;
+}
+import { ExecutionStep } from '../planner/planner.js';

package/dist/runtime/jobs/job-step.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/jobs/job-store.d.ts

@@ -0,0 +1,15 @@
+import { Job } from './job.js';
+export interface JobListFilter {
+    status?: string;
+    planner?: string;
+    capability?: string;
+    goal?: string;
+    limit?: number;
+}
+export interface JobStore {
+    create(job: Job): Promise<Job>;
+    get(id: string): Promise<Job | undefined>;
+    list(filter?: JobListFilter): Promise<Job[]>;
+    update(job: Job): Promise<Job>;
+}
+export declare const jobStore: JobStore;

package/dist/runtime/jobs/job-store.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobStore = void 0;
+const sqlite_job_store_js_1 = require("../../providers/storage/sqlite-job-store.js");
+class InMemoryJobStore {
+    jobs = new Map();
+    async create(job) {
+        if (this.jobs.has(job.id)) {
+            throw new Error(`Job already exists: ${job.id}`);
+        }
+        this.jobs.set(job.id, job);
+        return job;
+    }
+    async get(id) {
+        return this.jobs.get(id);
+    }
+    async list(filter) {
+        let jobs = Array.from(this.jobs.values());
+        if (filter?.status) {
+            jobs = jobs.filter((job) => job.status === filter.status);
+        }
+        if (filter?.planner) {
+            jobs = jobs.filter((job) => job.planner === filter.planner);
+        }
+        if (filter?.capability) {
+            jobs = jobs.filter((job) => job.steps.some((step) => step.capability === filter.capability));
+        }
+        if (filter?.goal) {
+            const goal = filter.goal.toLowerCase();
+            jobs = jobs.filter((job) => job.goal.toLowerCase().includes(goal));
+        }
+        if (filter?.limit && filter.limit > 0) {
+            jobs = jobs.slice(0, filter.limit);
+        }
+        return jobs;
+    }
+    async update(job) {
+        if (!this.jobs.has(job.id)) {
+            throw new Error(`Job not found: ${job.id}`);
+        }
+        this.jobs.set(job.id, job);
+        return job;
+    }
+}
+function createJobStore() {
+    const type = process.env.JOB_STORE?.toLowerCase() ?? 'memory';
+    if (type === 'sqlite') {
+        return new sqlite_job_store_js_1.SQLiteJobStore();
+    }
+    return new InMemoryJobStore();
+}
+exports.jobStore = createJobStore();

package/dist/runtime/jobs/job.d.ts

@@ -0,0 +1,20 @@
+import { JobStatus } from './job-status.js';
+import { JobEvent } from './job-event.js';
+import { JobStep } from './job-step.js';
+export type JobOutcome = 'success' | 'inconclusive' | 'failed';
+export interface Job {
+    id: string;
+    goal: string;
+    planner?: string;
+    idempotencyKey?: string;
+    status: JobStatus;
+    outcome?: JobOutcome;
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    steps: JobStep[];
+    result?: unknown;
+    error?: string;
+    events: JobEvent[];
+}

package/dist/runtime/jobs/job.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/logging/composite-log-sink.d.ts

@@ -0,0 +1,7 @@
+import { ExecutionLogEntry } from '../execution/execution-logger.js';
+import { ExecutionLogSink } from './execution-log-sink.js';
+export declare class CompositeLogSink implements ExecutionLogSink {
+    private readonly sinks;
+    constructor(sinks: ExecutionLogSink[]);
+    write(entry: ExecutionLogEntry): Promise<void>;
+}

package/dist/runtime/logging/composite-log-sink.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeLogSink = void 0;
+class CompositeLogSink {
+    sinks;
+    constructor(sinks) {
+        this.sinks = sinks;
+    }
+    async write(entry) {
+        await Promise.all(this.sinks.map((sink) => sink.write(entry)));
+    }
+}
+exports.CompositeLogSink = CompositeLogSink;

package/dist/runtime/logging/console-log-sink.d.ts

@@ -0,0 +1,6 @@
+import { ExecutionLogEntry } from '../execution/execution-logger.js';
+import { ExecutionLogSink } from './execution-log-sink.js';
+export declare class ConsoleLogSink implements ExecutionLogSink {
+    write(entry: ExecutionLogEntry): void;
+    private writeToConsole;
+}

package/dist/runtime/logging/console-log-sink.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogSink = void 0;
+class ConsoleLogSink {
+    write(entry) {
+        const output = JSON.stringify({
+            type: 'execution_log',
+            ...entry,
+        });
+        this.writeToConsole(entry.level, output);
+    }
+    writeToConsole(level, output) {
+        switch (level) {
+            case 'debug':
+                console.debug(output);
+                break;
+            case 'warn':
+                console.warn(output);
+                break;
+            case 'error':
+                console.error(output);
+                break;
+            default:
+                console.info(output);
+        }
+    }
+}
+exports.ConsoleLogSink = ConsoleLogSink;

package/dist/runtime/logging/execution-log-sink.d.ts

@@ -0,0 +1,4 @@
+import { ExecutionLogEntry } from '../execution/execution-logger.js';
+export interface ExecutionLogSink {
+    write(entry: ExecutionLogEntry): Promise<void> | void;
+}

package/dist/runtime/logging/execution-log-sink.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/logging/sqlite-log-sink.d.ts

@@ -0,0 +1,7 @@
+import { ExecutionLogEntry } from '../execution/execution-logger.js';
+import { ExecutionLogSink } from './execution-log-sink.js';
+export declare class SQLiteLogSink implements ExecutionLogSink {
+    private readonly db;
+    constructor(path?: string);
+    write(entry: ExecutionLogEntry): void;
+}

package/dist/runtime/logging/sqlite-log-sink.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteLogSink = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+class SQLiteLogSink {
+    db;
+    constructor(path = './data/operator.db') {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)((0, node_path_1.resolve)(path)), { recursive: true });
+        this.db = new better_sqlite3_1.default(path);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS execution_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp TEXT NOT NULL,
+        level TEXT NOT NULL,
+        message TEXT NOT NULL,
+        job_id TEXT NOT NULL,
+        step_id TEXT NOT NULL,
+        metadata TEXT
+      )
+    `);
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_execution_logs_job_id
+      ON execution_logs(job_id)
+    `);
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_execution_logs_step_id
+      ON execution_logs(step_id)
+    `);
+    }
+    write(entry) {
+        const statement = this.db.prepare(`
+      INSERT INTO execution_logs (
+        timestamp,
+        level,
+        message,
+        job_id,
+        step_id,
+        metadata
+      )
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        statement.run(entry.timestamp, entry.level, entry.message, entry.jobId, entry.stepId, entry.metadata
+            ? JSON.stringify(entry.metadata)
+            : null);
+    }
+}
+exports.SQLiteLogSink = SQLiteLogSink;

package/dist/runtime/modules/capability-module-manifest.d.ts

@@ -0,0 +1,11 @@
+export interface CapabilityModuleManifest {
+    name: string;
+    version: string;
+    description?: string;
+    capabilities: string[];
+    providerRequirements?: string[];
+    permissions?: string[];
+    operator?: {
+        minVersion?: string;
+    };
+}

package/dist/runtime/modules/capability-module-manifest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/modules/capability-module.d.ts

@@ -0,0 +1,6 @@
+import { Capability } from '../registry/capability.js';
+import { CapabilityModuleManifest } from './capability-module-manifest.js';
+export interface CapabilityModule {
+    manifest: CapabilityModuleManifest;
+    capabilities: Capability[];
+}

package/dist/runtime/modules/capability-module.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/operator-runtime.d.ts

@@ -0,0 +1,31 @@
+import { Job } from './jobs/job.js';
+import { JobListFilter } from './jobs/job-store.js';
+import { ExecutionCaller } from './execution/execution-context.js';
+import { CapabilityModule } from './modules/capability-module.js';
+import { ExecutionPlan } from './planner/planner.js';
+export interface RunJobOptions {
+    planner?: string;
+    strategy?: string;
+    caller?: ExecutionCaller;
+}
+export interface ExecutePlanOptions {
+    caller?: ExecutionCaller;
+}
+export declare class OperatorRuntime {
+    use(module: CapabilityModule): void;
+    executePlan(plan: ExecutionPlan, options?: ExecutePlanOptions): Promise<Job>;
+    run(goal: string, options?: RunJobOptions): Promise<Job>;
+    getJob(id: string): Promise<Job | undefined>;
+    listJobs(filter?: JobListFilter): Promise<Job[]>;
+    listCapabilities(): {
+        name: string;
+        version: string;
+        description: string;
+        risk: import("./registry/capability.js").CapabilityRisk;
+        inputSchema: Record<string, import("./registry/capability.js").CapabilityInputField>;
+    }[];
+    listPlanners(): {
+        name: string;
+    }[];
+}
+export declare const operatorRuntime: OperatorRuntime;

package/dist/runtime/operator-runtime.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operatorRuntime = exports.OperatorRuntime = void 0;
+const job_manager_js_1 = require("./jobs/job-manager.js");
+const job_memory_js_1 = require("./jobs/job-memory.js");
+const registry_js_1 = require("./registry/registry.js");
+const planner_registry_js_1 = require("./planner/planner-registry.js");
+const planner_router_registry_js_1 = require("./planner/planner-router-registry.js");
+const planner_strategy_registry_js_1 = require("./planner/strategies/planner-strategy-registry.js");
+function immutableCaller(caller) {
+    if (!caller)
+        return undefined;
+    return Object.freeze({
+        ...caller,
+        scopes: caller.scopes
+            ? Object.freeze([...caller.scopes])
+            : undefined,
+        metadata: caller.metadata
+            ? Object.freeze({ ...caller.metadata })
+            : undefined,
+    });
+}
+class OperatorRuntime {
+    use(module) {
+        const declared = new Set(module.manifest.capabilities);
+        for (const capability of module.capabilities) {
+            if (!declared.has(capability.name)) {
+                throw new Error(`Capability ${capability.name} is not declared in module manifest ${module.manifest.name}`);
+            }
+            registry_js_1.capabilityRegistry.register(capability);
+        }
+    }
+    async executePlan(plan, options = {}) {
+        return job_manager_js_1.jobManager.executePlan(plan, immutableCaller(options.caller));
+    }
+    async run(goal, options = {}) {
+        const router = planner_router_registry_js_1.plannerRouterRegistry.getDefault();
+        if (!router) {
+            throw new Error('No default planner router registered');
+        }
+        const selection = await router.select({
+            goal,
+            strategy: options.strategy,
+            planner: options.planner,
+        });
+        const strategy = planner_strategy_registry_js_1.plannerStrategyRegistry.get(selection.strategy);
+        if (!strategy) {
+            throw new Error(`Planner strategy not found: ${selection.strategy}`);
+        }
+        const plan = await strategy.execute({
+            goal,
+            planner: options.planner,
+            context: await job_memory_js_1.jobMemory.getPlannerContext(goal),
+        });
+        return this.executePlan(plan, { caller: options.caller });
+    }
+    async getJob(id) {
+        return job_manager_js_1.jobManager.get(id);
+    }
+    async listJobs(filter) {
+        return job_manager_js_1.jobManager.list(filter);
+    }
+    listCapabilities() {
+        return registry_js_1.capabilityRegistry.list();
+    }
+    listPlanners() {
+        return planner_registry_js_1.plannerRegistry.list();
+    }
+}
+exports.OperatorRuntime = OperatorRuntime;
+exports.operatorRuntime = new OperatorRuntime();