@veil-runtime/core 0.1.0

package/dist/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operatorRuntime = exports.OperatorRuntime = void 0;
+var operator_runtime_js_1 = require("./runtime/operator-runtime.js");
+Object.defineProperty(exports, "OperatorRuntime", { enumerable: true, get: function () { return operator_runtime_js_1.OperatorRuntime; } });
+Object.defineProperty(exports, "operatorRuntime", { enumerable: true, get: function () { return operator_runtime_js_1.operatorRuntime; } });
+__exportStar(require("./sdk/index.js"), exports);

package/dist/providers/storage/sqlite-job-store.d.ts

@@ -0,0 +1,10 @@
+import { Job } from '../../runtime/jobs/job.js';
+import { JobListFilter, JobStore } from '../../runtime/jobs/job-store.js';
+export declare class SQLiteJobStore implements JobStore {
+    private readonly db;
+    constructor(path?: string);
+    create(job: Job): Promise<Job>;
+    get(id: string): Promise<Job | undefined>;
+    list(filter?: JobListFilter): Promise<Job[]>;
+    update(job: Job): Promise<Job>;
+}

package/dist/providers/storage/sqlite-job-store.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteJobStore = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+class SQLiteJobStore {
+    db;
+    constructor(path = './data/operator.db') {
+        this.db = new better_sqlite3_1.default(path);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS jobs (
+        id TEXT PRIMARY KEY,
+        data TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
+    }
+    async create(job) {
+        const statement = this.db.prepare(`
+      INSERT INTO jobs (
+        id,
+        data,
+        created_at,
+        updated_at
+      )
+      VALUES (?, ?, ?, ?)
+    `);
+        statement.run(job.id, JSON.stringify(job), job.createdAt, job.updatedAt);
+        return job;
+    }
+    async get(id) {
+        const row = this.db
+            .prepare(`
+        SELECT data
+        FROM jobs
+        WHERE id = ?
+      `)
+            .get(id);
+        if (!row) {
+            return undefined;
+        }
+        return JSON.parse(row.data);
+    }
+    async list(filter) {
+        const rows = this.db
+            .prepare(`
+        SELECT data
+        FROM jobs
+        ORDER BY created_at DESC
+      `)
+            .all();
+        let jobs = rows.map((row) => JSON.parse(row.data));
+        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) {
+        const statement = this.db.prepare(`
+      UPDATE jobs
+      SET
+        data = ?,
+        updated_at = ?
+      WHERE id = ?
+    `);
+        const result = statement.run(JSON.stringify(job), job.updatedAt, job.id);
+        if (result.changes === 0) {
+            throw new Error(`Job not found: ${job.id}`);
+        }
+        return job;
+    }
+}
+exports.SQLiteJobStore = SQLiteJobStore;

package/dist/runtime/events/event-bus.d.ts

@@ -0,0 +1,6 @@
+import { RuntimeEvent, RuntimeEventType } from './runtime-event.js';
+import { EventSubscriber } from './event-subscriber.js';
+export interface EventBus {
+    publish(event: RuntimeEvent): Promise<void>;
+    subscribe(type: RuntimeEventType | '*', handler: EventSubscriber): () => void;
+}

package/dist/runtime/events/event-bus.js

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

package/dist/runtime/events/event-subscriber.d.ts

@@ -0,0 +1,6 @@
+import { RuntimeEvent, RuntimeEventType } from './runtime-event.js';
+export type EventSubscriber<TEvent extends RuntimeEvent = RuntimeEvent> = (event: TEvent) => Promise<void> | void;
+export interface EventSubscription {
+    type: RuntimeEventType | '*';
+    handler: EventSubscriber;
+}

package/dist/runtime/events/event-subscriber.js

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

package/dist/runtime/events/memory-event-bus.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeEvent, RuntimeEventType } from './runtime-event.js';
+import { EventSubscriber } from './event-subscriber.js';
+import { EventBus } from './event-bus.js';
+export declare class MemoryEventBus implements EventBus {
+    private readonly subscribers;
+    subscribe(type: RuntimeEventType | '*', handler: EventSubscriber): () => void;
+    publish(event: RuntimeEvent): Promise<void>;
+}
+export declare const runtimeEventBus: MemoryEventBus;

package/dist/runtime/events/memory-event-bus.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeEventBus = exports.MemoryEventBus = void 0;
+class MemoryEventBus {
+    subscribers = new Map();
+    subscribe(type, handler) {
+        const handlers = this.subscribers.get(type) ??
+            new Set();
+        handlers.add(handler);
+        this.subscribers.set(type, handlers);
+        return () => {
+            handlers.delete(handler);
+            if (handlers.size === 0) {
+                this.subscribers.delete(type);
+            }
+        };
+    }
+    async publish(event) {
+        const specific = this.subscribers.get(event.type) ??
+            new Set();
+        const wildcard = this.subscribers.get('*') ??
+            new Set();
+        const handlers = [
+            ...specific,
+            ...wildcard,
+        ];
+        await Promise.all(handlers.map((handler) => Promise.resolve(handler(event))));
+    }
+}
+exports.MemoryEventBus = MemoryEventBus;
+exports.runtimeEventBus = new MemoryEventBus();

package/dist/runtime/events/runtime-event.d.ts

@@ -0,0 +1,10 @@
+import { JobEventType } from '../jobs/job-event.js';
+export type RuntimeEventType = JobEventType;
+export interface RuntimeEvent<TData extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    type: RuntimeEventType;
+    timestamp: string;
+    jobId?: string;
+    stepId?: string;
+    data?: TData;
+}

package/dist/runtime/events/runtime-event.js

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

package/dist/runtime/execution/console-execution-logger.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionLogger } from './execution-logger.js';
+import { ExecutionLogSink } from '../logging/execution-log-sink.js';
+export declare class ConsoleExecutionLogger implements ExecutionLogger {
+    private readonly jobId;
+    private readonly stepId;
+    private readonly sink;
+    constructor(jobId: string, stepId: string, sink: ExecutionLogSink);
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    private write;
+}

package/dist/runtime/execution/console-execution-logger.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleExecutionLogger = void 0;
+class ConsoleExecutionLogger {
+    jobId;
+    stepId;
+    sink;
+    constructor(jobId, stepId, sink) {
+        this.jobId = jobId;
+        this.stepId = stepId;
+        this.sink = sink;
+    }
+    debug(message, metadata) {
+        this.write('debug', message, metadata);
+    }
+    info(message, metadata) {
+        this.write('info', message, metadata);
+    }
+    warn(message, metadata) {
+        this.write('warn', message, metadata);
+    }
+    error(message, metadata) {
+        this.write('error', message, metadata);
+    }
+    write(level, message, metadata) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+            jobId: this.jobId,
+            stepId: this.stepId,
+            metadata,
+        };
+        void this.sink.write(entry);
+    }
+}
+exports.ConsoleExecutionLogger = ConsoleExecutionLogger;

package/dist/runtime/execution/execution-context.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionLogger } from './execution-logger.js';
+export interface ExecutionCaller {
+    readonly subject?: string;
+    readonly tenant?: string;
+    readonly scopes?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ExecutionContext {
+    readonly jobId: string;
+    readonly stepId: string;
+    readonly logger: ExecutionLogger;
+    readonly caller?: ExecutionCaller;
+}

package/dist/runtime/execution/execution-context.js

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

package/dist/runtime/execution/execution-logger.d.ts

@@ -0,0 +1,15 @@
+export type ExecutionLogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface ExecutionLogEntry {
+    timestamp: string;
+    level: ExecutionLogLevel;
+    message: string;
+    jobId: string;
+    stepId: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionLogger {
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+}

package/dist/runtime/execution/execution-logger.js

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

package/dist/runtime/execution/plan-validator.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionStep } from '../planner/planner.js';
+export interface PlanValidationError {
+    stepId: string;
+    capability: string;
+    field?: string;
+    message: string;
+}
+export interface PlanValidationResult {
+    valid: boolean;
+    errors: PlanValidationError[];
+}
+export declare function validateStepInput(step: ExecutionStep, input: unknown): PlanValidationResult;
+export declare function validatePlan(steps: readonly ExecutionStep[]): PlanValidationResult;

package/dist/runtime/execution/plan-validator.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStepInput = validateStepInput;
+exports.validatePlan = validatePlan;
+const registry_js_1 = require("../registry/registry.js");
+const result_reference_js_1 = require("./result-reference.js");
+const TYPE_CHECKS = {
+    string: (value) => typeof value === 'string',
+    number: (value) => typeof value === 'number' && Number.isFinite(value),
+    boolean: (value) => typeof value === 'boolean',
+    object: (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value),
+    array: (value) => Array.isArray(value),
+};
+function validateInput(step, capability, allowReferences) {
+    const errors = [];
+    const input = step.input && typeof step.input === 'object' && !Array.isArray(step.input)
+        ? step.input
+        : {};
+    for (const [field, definition] of Object.entries(capability.inputSchema ?? {})) {
+        const value = input[field];
+        if (definition.required && (value === undefined || value === null || value === '')) {
+            errors.push({
+                stepId: step.id,
+                capability: step.capability,
+                field,
+                message: `Required input '${field}' is missing for capability '${step.capability}'`,
+            });
+            continue;
+        }
+        if (value === undefined || (allowReferences && (0, result_reference_js_1.isResultReference)(value))) {
+            continue;
+        }
+        const check = TYPE_CHECKS[definition.type];
+        if (!check) {
+            errors.push({
+                stepId: step.id,
+                capability: step.capability,
+                field,
+                message: `Unsupported schema type '${definition.type}' for capability '${step.capability}'`,
+            });
+        }
+        else if (!check(value)) {
+            errors.push({
+                stepId: step.id,
+                capability: step.capability,
+                field,
+                message: `Input '${field}' must be of type '${definition.type}' for capability '${step.capability}'`,
+            });
+        }
+    }
+    return errors;
+}
+function collectReferences(value) {
+    if ((0, result_reference_js_1.isResultReference)(value))
+        return [value.$ref];
+    if (Array.isArray(value))
+        return value.flatMap(collectReferences);
+    if (value && typeof value === 'object') {
+        return Object.values(value).flatMap(collectReferences);
+    }
+    return [];
+}
+function validateStepInput(step, input) {
+    const capability = registry_js_1.capabilityRegistry.get(step.capability);
+    if (!capability) {
+        return {
+            valid: false,
+            errors: [{
+                    stepId: step.id,
+                    capability: step.capability,
+                    message: `Unknown capability: ${step.capability}`,
+                }],
+        };
+    }
+    const errors = validateInput({ ...step, input }, capability, false);
+    return { valid: errors.length === 0, errors };
+}
+function validatePlan(steps) {
+    const errors = [];
+    const seenStepIds = new Set();
+    for (const step of steps) {
+        const capability = registry_js_1.capabilityRegistry.get(step.capability);
+        if (!capability) {
+            errors.push({
+                stepId: step.id,
+                capability: step.capability,
+                message: `Unknown capability: ${step.capability}`,
+            });
+            seenStepIds.add(step.id);
+            continue;
+        }
+        if (step.capabilityVersion && step.capabilityVersion !== capability.version) {
+            errors.push({
+                stepId: step.id,
+                capability: step.capability,
+                message: `Capability version mismatch for '${step.capability}': requested ${step.capabilityVersion}, registered ${capability.version}`,
+            });
+        }
+        errors.push(...validateInput(step, capability, true));
+        for (const reference of collectReferences(step.input)) {
+            try {
+                const { stepId } = (0, result_reference_js_1.parseResultReference)(reference);
+                if (!seenStepIds.has(stepId)) {
+                    errors.push({
+                        stepId: step.id,
+                        capability: step.capability,
+                        message: `Result reference must target an earlier step: ${reference}`,
+                    });
+                }
+            }
+            catch (error) {
+                errors.push({
+                    stepId: step.id,
+                    capability: step.capability,
+                    message: error instanceof Error ? error.message : 'Invalid result reference',
+                });
+            }
+        }
+        seenStepIds.add(step.id);
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/runtime/execution/result-reference.d.ts

@@ -0,0 +1,9 @@
+import { JobStep } from '../jobs/job-step.js';
+export declare function isResultReference(value: unknown): value is {
+    readonly $ref: string;
+};
+export declare function parseResultReference(reference: string): {
+    stepId: string;
+    path: string[];
+};
+export declare function resolveResultReferences(value: unknown, completedSteps: readonly JobStep[]): unknown;

package/dist/runtime/execution/result-reference.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isResultReference = isResultReference;
+exports.parseResultReference = parseResultReference;
+exports.resolveResultReferences = resolveResultReferences;
+const REFERENCE_PREFIX = 'steps.';
+const RESULT_SEGMENT = '.result';
+function isResultReference(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return Object.keys(record).length === 1 && typeof record.$ref === 'string';
+}
+function parseResultReference(reference) {
+    if (!reference.startsWith(REFERENCE_PREFIX)) {
+        throw new Error(`Invalid result reference: ${reference}`);
+    }
+    const resultIndex = reference.indexOf(RESULT_SEGMENT);
+    if (resultIndex <= REFERENCE_PREFIX.length) {
+        throw new Error(`Invalid result reference: ${reference}`);
+    }
+    const stepId = reference.slice(REFERENCE_PREFIX.length, resultIndex);
+    const suffix = reference.slice(resultIndex + RESULT_SEGMENT.length);
+    if (suffix && !suffix.startsWith('.')) {
+        throw new Error(`Invalid result reference: ${reference}`);
+    }
+    return {
+        stepId,
+        path: suffix ? suffix.slice(1).split('.') : [],
+    };
+}
+function resolveResultReferences(value, completedSteps) {
+    if (isResultReference(value)) {
+        const { stepId, path } = parseResultReference(value.$ref);
+        const step = completedSteps.find((candidate) => candidate.id === stepId);
+        if (!step || step.status !== 'completed') {
+            throw new Error(`Result reference requires completed earlier step: ${stepId}`);
+        }
+        let resolved = step.result;
+        for (const segment of path) {
+            if (!resolved || typeof resolved !== 'object' || !(segment in resolved)) {
+                throw new Error(`Result reference path not found: ${value.$ref}`);
+            }
+            resolved = resolved[segment];
+        }
+        return resolved;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveResultReferences(item, completedSteps));
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            resolveResultReferences(item, completedSteps),
+        ]));
+    }
+    return value;
+}

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

@@ -0,0 +1,8 @@
+export type JobEventType = 'job.created' | 'planning.started' | 'planning.completed' | 'approval.requested' | 'approval.granted' | 'execution.started' | 'capability.started' | 'capability.completed' | 'capability.failed' | 'job.completed' | 'job.failed' | 'job.cancelled' | 'job.reviewed';
+export interface JobEvent {
+    id: string;
+    jobId: string;
+    type: JobEventType;
+    timestamp: string;
+    data?: Record<string, unknown>;
+}

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

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

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

@@ -0,0 +1,17 @@
+import { ExecutionPlan } from '../planner/planner.js';
+import { ExecutionCaller } from '../execution/execution-context.js';
+import { Job, JobOutcome } from './job.js';
+import { JobStatus } from './job-status.js';
+import { JobListFilter } from './job-store.js';
+declare class JobManager {
+    executePlan(plan: ExecutionPlan, caller?: ExecutionCaller): Promise<Job>;
+    create(goal: string, planner?: string): Promise<Job>;
+    get(id: string): Promise<Job | undefined>;
+    list(filter?: JobListFilter): Promise<Job[]>;
+    setStatus(id: string, status: JobStatus): Promise<Job>;
+    execute(id: string, caller?: ExecutionCaller): Promise<Job>;
+    review(id: string, outcome: JobOutcome, notes?: string): Promise<Job>;
+    private addEvent;
+}
+export declare const jobManager: JobManager;
+export {};