reqon-dsl 0.2.0 → 0.4.0

package/dist/lexer/tokens.js

@@ -29,6 +29,8 @@ export var ReqonTokenType;
     ReqonTokenType["NOSQL"] = "NOSQL";
     ReqonTokenType["SQL"] = "SQL";
     ReqonTokenType["MEMORY"] = "MEMORY";
+    ReqonTokenType["FILE"] = "FILE";
+    ReqonTokenType["POSTGREST"] = "POSTGREST";
     // Auth types
     ReqonTokenType["OAUTH2"] = "OAUTH2";
     ReqonTokenType["BEARER"] = "BEARER";
@@ -62,6 +64,12 @@ export var ReqonTokenType;
     ReqonTokenType["JUMP"] = "JUMP";
     // Type checking
     ReqonTokenType["IS"] = "IS";
+    // Transforms
+    ReqonTokenType["TRANSFORM"] = "TRANSFORM";
+    ReqonTokenType["APPLY"] = "APPLY";
+    ReqonTokenType["TO"] = "TO";
+    ReqonTokenType["AS"] = "AS";
+    ReqonTokenType["TRY"] = "TRY";
     // Webhook support
     ReqonTokenType["WAIT"] = "WAIT";
     ReqonTokenType["TIMEOUT"] = "TIMEOUT";
@@ -69,6 +77,16 @@ export var ReqonTokenType;
     ReqonTokenType["EXPECTED_EVENTS"] = "EXPECTED_EVENTS";
     ReqonTokenType["EVENT_FILTER"] = "EVENT_FILTER";
     ReqonTokenType["STORAGE"] = "STORAGE";
+    // Durability features
+    ReqonTokenType["CHECKPOINT"] = "CHECKPOINT";
+    ReqonTokenType["TRACE"] = "TRACE";
+    ReqonTokenType["PAUSE"] = "PAUSE";
+    ReqonTokenType["PERSIST"] = "PERSIST";
+    ReqonTokenType["DURATION"] = "DURATION";
+    ReqonTokenType["RESUME_ON"] = "RESUME_ON";
+    ReqonTokenType["AFTER_STEP"] = "AFTER_STEP";
+    ReqonTokenType["ON_FAILURE"] = "ON_FAILURE";
+    ReqonTokenType["FULL"] = "FULL";
 })(ReqonTokenType || (ReqonTokenType = {}));
 // Re-export Vague's TokenType for convenience
 export { TokenType as VagueTokenType } from 'vague-lang';
@@ -106,6 +124,8 @@ export const REQON_KEYWORDS = {
     nosql: ReqonTokenType.NOSQL,
     sql: ReqonTokenType.SQL,
     memory: ReqonTokenType.MEMORY,
+    file: ReqonTokenType.FILE,
+    postgrest: ReqonTokenType.POSTGREST,
     // Auth types
     oauth2: ReqonTokenType.OAUTH2,
     bearer: ReqonTokenType.BEARER,
@@ -136,6 +156,12 @@ export const REQON_KEYWORDS = {
     jump: ReqonTokenType.JUMP,
     // Type checking
     is: ReqonTokenType.IS,
+    // Transforms
+    transform: ReqonTokenType.TRANSFORM,
+    apply: ReqonTokenType.APPLY,
+    to: ReqonTokenType.TO,
+    as: ReqonTokenType.AS,
+    try: ReqonTokenType.TRY,
     // Webhook support
     wait: ReqonTokenType.WAIT,
     timeout: ReqonTokenType.TIMEOUT,
@@ -143,4 +169,14 @@ export const REQON_KEYWORDS = {
     expectedEvents: ReqonTokenType.EXPECTED_EVENTS,
     eventFilter: ReqonTokenType.EVENT_FILTER,
     storage: ReqonTokenType.STORAGE,
+    // Durability features
+    checkpoint: ReqonTokenType.CHECKPOINT,
+    trace: ReqonTokenType.TRACE,
+    pause: ReqonTokenType.PAUSE,
+    persist: ReqonTokenType.PERSIST,
+    duration: ReqonTokenType.DURATION,
+    resumeOn: ReqonTokenType.RESUME_ON,
+    afterStep: ReqonTokenType.AFTER_STEP,
+    onFailure: ReqonTokenType.ON_FAILURE,
+    full: ReqonTokenType.FULL,
 };

package/dist/loader/index.js

@@ -59,9 +59,7 @@ async function loadMissionFile(filePath) {
  */
 async function loadMissionFolder(folderPath, options) {
     // Find root file - try extensions in order of preference
-    const extensionsToTry = options.extension
-        ? [options.extension]
-        : SUPPORTED_EXTENSIONS;
+    const extensionsToTry = options.extension ? [options.extension] : SUPPORTED_EXTENSIONS;
     let rootFilePath = null;
     let ext = null;
     for (const extension of extensionsToTry) {
@@ -77,9 +75,8 @@ async function loadMissionFolder(folderPath, options) {
         }
     }
     if (!rootFilePath || !ext) {
-        const tried = extensionsToTry.map(e => `mission${e}`).join(' or ');
-        throw new Error(`Mission folder must contain a root file (${tried}). ` +
-            `Not found in: ${folderPath}`);
+        const tried = extensionsToTry.map((e) => `mission${e}`).join(' or ');
+        throw new Error(`Mission folder must contain a root file (${tried}). ` + `Not found in: ${folderPath}`);
     }
     // Load root file
     const rootSource = await readFile(rootFilePath, 'utf-8');
@@ -87,7 +84,7 @@ async function loadMissionFolder(folderPath, options) {
     // Find all other action files in the folder (same extension as root)
     const rootFileName = basename(rootFilePath);
     const files = await readdir(folderPath);
-    const actionFiles = files.filter(f => f.endsWith(ext) && f !== rootFileName);
+    const actionFiles = files.filter((f) => f.endsWith(ext) && f !== rootFileName);
     const sourceFiles = [rootFilePath];
     const externalActions = [];
     // Parse each action file
@@ -169,7 +166,7 @@ function validatePipelineActions(program) {
     const mission = program.statements.find((s) => s.type === 'MissionDefinition');
     if (!mission)
         return;
-    const actionNames = new Set(mission.actions.map(a => a.name));
+    const actionNames = new Set(mission.actions.map((a) => a.name));
     for (const stage of mission.pipeline.stages) {
         const stageActions = stage.actions ?? (stage.action ? [stage.action] : []);
         for (const actionName of stageActions) {

package/dist/mcp/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Reqon MCP Module
+ *
+ * Provides Model Context Protocol integration for Reqon.
+ *
+ * To run the MCP server:
+ *   npx reqon-mcp
+ *
+ * Or programmatically import from './server.js'
+ */
+export declare const MCP_SERVER_VERSION = "0.1.0";

package/dist/mcp/index.js

@@ -0,0 +1,11 @@
+/**
+ * Reqon MCP Module
+ *
+ * Provides Model Context Protocol integration for Reqon.
+ *
+ * To run the MCP server:
+ *   npx reqon-mcp
+ *
+ * Or programmatically import from './server.js'
+ */
+export const MCP_SERVER_VERSION = '0.1.0';

package/dist/mcp/sandbox.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Sandboxing helpers for the MCP server.
+ *
+ * The MCP server is driven by an LLM acting on untrusted input, so missions
+ * must not be able to reach the network/filesystem or escape the working
+ * directory unless the operator explicitly opts in.
+ */
+/**
+ * Resolve an untrusted path against a base working directory and assert the
+ * result stays inside it. Blocks `../` and absolute-path escapes.
+ *
+ * @throws if the resolved path escapes the working directory
+ */
+export declare function resolveWithinWorkingDir(workingDir: string, p: string): string;
+/**
+ * Decide the effective dryRun for an execution. Effects (real network/fs) are
+ * opt-in: when not allowed, force dryRun regardless of what the caller asked.
+ */
+export declare function resolveDryRun(allowEffects: boolean, requestedDryRun?: boolean): boolean;
+/** Default wall-clock budget for an untrusted mission execution. */
+export declare const DEFAULT_EXECUTION_TIMEOUT_MS = 30000;
+/** Thrown when an execution exceeds its allotted time budget. */
+export declare class ExecutionTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+/**
+ * Race a promise against a timeout. An untrusted (LLM-supplied) mission could
+ * otherwise loop or hang forever (e.g. a long pause/wait) and wedge the server.
+ * On timeout the returned promise rejects with an {@link ExecutionTimeoutError};
+ * the underlying work may keep running, but the caller is no longer blocked.
+ *
+ * A non-positive or non-finite timeout disables the guard.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T>;
+/**
+ * Whether a store of the given type may be registered under the current effects
+ * policy. File-backed stores write to disk, which is an effect, so they require
+ * effects to be enabled. In-memory stores are always allowed.
+ */
+export declare function isStoreTypeAllowed(storeType: string | undefined, allowEffects: boolean): boolean;

package/dist/mcp/sandbox.js

@@ -0,0 +1,76 @@
+/**
+ * Sandboxing helpers for the MCP server.
+ *
+ * The MCP server is driven by an LLM acting on untrusted input, so missions
+ * must not be able to reach the network/filesystem or escape the working
+ * directory unless the operator explicitly opts in.
+ */
+import { resolve, sep } from 'node:path';
+/**
+ * Resolve an untrusted path against a base working directory and assert the
+ * result stays inside it. Blocks `../` and absolute-path escapes.
+ *
+ * @throws if the resolved path escapes the working directory
+ */
+export function resolveWithinWorkingDir(workingDir, p) {
+    const base = resolve(workingDir);
+    const resolved = resolve(base, p);
+    if (resolved !== base && !resolved.startsWith(base + sep)) {
+        throw new Error(`Path "${p}" escapes the working directory`);
+    }
+    return resolved;
+}
+/**
+ * Decide the effective dryRun for an execution. Effects (real network/fs) are
+ * opt-in: when not allowed, force dryRun regardless of what the caller asked.
+ */
+export function resolveDryRun(allowEffects, requestedDryRun) {
+    if (!allowEffects)
+        return true;
+    return requestedDryRun ?? false;
+}
+/** Default wall-clock budget for an untrusted mission execution. */
+export const DEFAULT_EXECUTION_TIMEOUT_MS = 30_000;
+/** Thrown when an execution exceeds its allotted time budget. */
+export class ExecutionTimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs) {
+        super(`Execution exceeded the ${timeoutMs}ms timeout`);
+        this.timeoutMs = timeoutMs;
+        this.name = 'ExecutionTimeoutError';
+    }
+}
+/**
+ * Race a promise against a timeout. An untrusted (LLM-supplied) mission could
+ * otherwise loop or hang forever (e.g. a long pause/wait) and wedge the server.
+ * On timeout the returned promise rejects with an {@link ExecutionTimeoutError};
+ * the underlying work may keep running, but the caller is no longer blocked.
+ *
+ * A non-positive or non-finite timeout disables the guard.
+ */
+export function withTimeout(promise, timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        return promise;
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new ExecutionTimeoutError(timeoutMs)), timeoutMs);
+        // Don't let the timer keep the event loop alive on its own.
+        timer.unref?.();
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+/**
+ * Whether a store of the given type may be registered under the current effects
+ * policy. File-backed stores write to disk, which is an effect, so they require
+ * effects to be enabled. In-memory stores are always allowed.
+ */
+export function isStoreTypeAllowed(storeType, allowEffects) {
+    if (storeType === 'file')
+        return allowEffects;
+    return true;
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Reqon MCP Server
+ *
+ * Exposes Reqon pipeline capabilities via the Model Context Protocol.
+ *
+ * Tools:
+ * - reqon.execute: Execute a mission from DSL source
+ * - reqon.execute_file: Execute a mission from a file/folder path
+ * - reqon.query_store: Query data from a named store
+ * - reqon.list_stores: List available stores
+ *
+ * Resources:
+ * - reqon://stores - List all stores
+ * - reqon://stores/{name} - Access store data
+ */
+export {};