@reasonlayer/sdk 0.0.1

package/node_modules/@reasonlayer/runner/dist/mcp-supervisor.d.ts

@@ -0,0 +1,15 @@
+import { connectMcpServer } from "@flue/runtime";
+import type { EnvironmentIR } from "@reasonlayer/protocol";
+import type { ToolDefinition } from "@flue/runtime";
+export interface McpSupervisorOptions {
+    taskEnv: Record<string, string>;
+    signal?: AbortSignal;
+    connect?: typeof connectMcpServer;
+    startupTimeoutMs?: number;
+}
+export interface StartedMcpServers {
+    env: Record<string, string>;
+    tools: ToolDefinition[];
+    close(): Promise<void>;
+}
+export declare function startMcpServers(environment: EnvironmentIR | undefined, options: McpSupervisorOptions): Promise<StartedMcpServers>;

package/node_modules/@reasonlayer/runner/dist/mcp-supervisor.js

@@ -0,0 +1,142 @@
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+import { setTimeout as delay } from "node:timers/promises";
+import { connectMcpServer } from "@flue/runtime";
+import { mcpUrlEnvName } from "@reasonlayer/protocol";
+const DEFAULT_STARTUP_TIMEOUT_MS = 15_000;
+async function openPort() {
+    return await new Promise((resolve, reject) => {
+        const server = createServer();
+        server.on("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            const port = typeof address === "object" && address ? address.port : 0;
+            server.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(port);
+            });
+        });
+    });
+}
+function resolveSecret(taskEnv, secret, location) {
+    const value = taskEnv[secret.name];
+    if (value === undefined)
+        throw new Error(`missing secret "${secret.name}" for ${location}`);
+    return value;
+}
+function resolveSecretRecord(taskEnv, values, location) {
+    if (!values || Object.keys(values).length === 0)
+        return undefined;
+    return Object.fromEntries(Object.entries(values).map(([key, secret]) => [
+        key,
+        resolveSecret(taskEnv, secret, `${location}.${key}`),
+    ]));
+}
+async function connectWithRetry(name, url, headers, connect, process, startupTimeoutMs) {
+    const deadline = Date.now() + startupTimeoutMs;
+    let lastError;
+    while (Date.now() <= deadline) {
+        if (process && process.process.exitCode !== null) {
+            throw new Error(`MCP server "${name}" exited before it became ready: ${process.stderr.trim() || `exit ${process.process.exitCode}`}`);
+        }
+        try {
+            return await connect(name, {
+                url,
+                ...(headers !== undefined ? { headers } : {}),
+                timeoutMs: 5_000,
+            });
+        }
+        catch (err) {
+            lastError = err;
+            await delay(100);
+        }
+    }
+    throw new Error(`MCP server "${name}" did not become ready: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+}
+function spawnLocalServer(name, server, taskEnv, url, port) {
+    if (server.transport && server.transport !== "http") {
+        throw new Error(`MCP server "${name}" uses unsupported transport "${server.transport}"`);
+    }
+    const secretEnv = resolveSecretRecord(taskEnv, server.env, `mcp.${name}.env`);
+    const child = spawn(server.command, {
+        env: {
+            ...process.env,
+            ...(secretEnv ?? {}),
+            PORT: String(port),
+            MCP_PORT: String(port),
+            RL_MCP_URL: url,
+            [mcpUrlEnvName(name)]: url,
+        },
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const local = { name, process: child, stderr: "" };
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+        local.stderr += chunk;
+    });
+    return local;
+}
+async function closeLocal(process) {
+    if (process.process.exitCode !== null || process.process.killed)
+        return;
+    process.process.kill("SIGTERM");
+    await Promise.race([
+        new Promise((resolve) => process.process.once("close", () => resolve())),
+        delay(500).then(() => {
+            if (process.process.exitCode === null)
+                process.process.kill("SIGKILL");
+        }),
+    ]);
+}
+export async function startMcpServers(environment, options) {
+    if (!environment?.mcp || Object.keys(environment.mcp).length === 0) {
+        return { env: {}, tools: [], close: async () => { } };
+    }
+    const connect = options.connect ?? connectMcpServer;
+    const startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+    const env = {};
+    const locals = [];
+    const connections = [];
+    const tools = [];
+    try {
+        for (const [name, server] of Object.entries(environment.mcp)) {
+            if (server.kind === "command") {
+                const port = await openPort();
+                const url = `http://127.0.0.1:${port}/mcp`;
+                env[mcpUrlEnvName(name)] = url;
+                const local = spawnLocalServer(name, server, options.taskEnv, url, port);
+                locals.push(local);
+                const connection = await connectWithRetry(name, url, undefined, connect, local, startupTimeoutMs);
+                connections.push(connection);
+                tools.push(...connection.tools);
+                continue;
+            }
+            const headers = resolveSecretRecord(options.taskEnv, server.headers, `mcp.${name}.headers`);
+            env[mcpUrlEnvName(name)] = server.url;
+            const connection = await connectWithRetry(name, server.url, headers, connect, undefined, startupTimeoutMs);
+            connections.push(connection);
+            tools.push(...connection.tools);
+        }
+    }
+    catch (err) {
+        await Promise.allSettled(connections.map((connection) => connection.close()));
+        await Promise.allSettled(locals.map((local) => closeLocal(local)));
+        throw err;
+    }
+    const abort = () => {
+        void Promise.allSettled(locals.map((local) => closeLocal(local)));
+    };
+    options.signal?.addEventListener("abort", abort, { once: true });
+    return {
+        env,
+        tools,
+        async close() {
+            options.signal?.removeEventListener("abort", abort);
+            await Promise.allSettled(connections.map((connection) => connection.close()));
+            await Promise.allSettled(locals.map((local) => closeLocal(local)));
+        },
+    };
+}

package/node_modules/@reasonlayer/runner/dist/sandbox-env.d.ts

@@ -0,0 +1,36 @@
+import { type ChildProcess } from "node:child_process";
+import type { FileStat, SandboxApi, SessionEnv } from "@flue/runtime";
+export type { SandboxApi } from "@flue/runtime";
+export interface NodeSandboxApiOptions {
+    cwd?: string;
+}
+export declare function killProcessGroup(child: ChildProcess, signal: NodeJS.Signals): void;
+export declare class NodeSandboxApi implements SandboxApi {
+    readonly cwd: string;
+    constructor(options?: NodeSandboxApiOptions);
+    readFile(path: string): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    stat(path: string): Promise<FileStat>;
+    readdir(path: string): Promise<string[]>;
+    exists(path: string): Promise<boolean>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    exec(command: string, options?: {
+        cwd?: string;
+        env?: Record<string, string>;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+}
+export declare function createNodeSandboxApi(options?: NodeSandboxApiOptions): SandboxApi;
+export declare function createNodeSandboxSessionEnv(cwd?: string): SessionEnv;

package/node_modules/@reasonlayer/runner/dist/sandbox-env.js

@@ -0,0 +1,171 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, lstat, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { createSandboxSessionEnv } from "@flue/runtime";
+export function killProcessGroup(child, signal) {
+    if (!child.pid || child.exitCode !== null || child.killed)
+        return;
+    try {
+        if (process.platform === "win32")
+            child.kill(signal);
+        else
+            process.kill(-child.pid, signal);
+    }
+    catch {
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // Process already exited.
+        }
+    }
+}
+function exitCodeForSignal(signal) {
+    if (!signal)
+        return 1;
+    const signalNumbers = {
+        SIGHUP: 1,
+        SIGINT: 2,
+        SIGQUIT: 3,
+        SIGILL: 4,
+        SIGTRAP: 5,
+        SIGABRT: 6,
+        SIGBUS: 7,
+        SIGFPE: 8,
+        SIGKILL: 9,
+        SIGUSR1: 10,
+        SIGSEGV: 11,
+        SIGUSR2: 12,
+        SIGPIPE: 13,
+        SIGALRM: 14,
+        SIGTERM: 15,
+    };
+    return 128 + (signalNumbers[signal] ?? 0);
+}
+export class NodeSandboxApi {
+    cwd;
+    constructor(options = {}) {
+        this.cwd = resolve(options.cwd ?? process.cwd());
+    }
+    async readFile(path) {
+        return await readFile(path, "utf8");
+    }
+    async readFileBuffer(path) {
+        return new Uint8Array(await readFile(path));
+    }
+    async writeFile(path, content) {
+        await writeFile(path, typeof content === "string" ? content : Buffer.from(content));
+    }
+    async stat(path) {
+        const stat = await lstat(path);
+        return {
+            isFile: stat.isFile(),
+            isDirectory: stat.isDirectory(),
+            ...(stat.isSymbolicLink() ? { isSymbolicLink: true } : {}),
+            size: stat.size,
+            mtime: stat.mtime,
+        };
+    }
+    async readdir(path) {
+        return await readdir(path);
+    }
+    async exists(path) {
+        try {
+            await access(path, constants.F_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async mkdir(path, options) {
+        await mkdir(path, { recursive: options?.recursive });
+    }
+    async rm(path, options) {
+        await rm(path, { recursive: options?.recursive, force: options?.force });
+    }
+    async exec(command, options = {}) {
+        if (options.signal?.aborted) {
+            return { stdout: "", stderr: "command aborted before start\n", exitCode: 130 };
+        }
+        return await new Promise((resolveExec, reject) => {
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            let aborted = false;
+            let settled = false;
+            let timeout;
+            const child = spawn(command, {
+                cwd: options.cwd ?? this.cwd,
+                detached: process.platform !== "win32",
+                env: { ...process.env, ...(options.env ?? {}) },
+                shell: true,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                options.signal?.removeEventListener("abort", abort);
+                resolveExec(result);
+            };
+            const terminate = () => {
+                if (child.exitCode !== null || child.killed)
+                    return;
+                killProcessGroup(child, "SIGTERM");
+                setTimeout(() => {
+                    if (child.exitCode === null)
+                        killProcessGroup(child, "SIGKILL");
+                }, 250).unref?.();
+            };
+            const abort = () => {
+                aborted = true;
+                stderr += "command aborted\n";
+                terminate();
+            };
+            timeout =
+                options.timeoutMs !== undefined
+                    ? setTimeout(() => {
+                        timedOut = true;
+                        stderr += `command timed out after ${options.timeoutMs}ms\n`;
+                        terminate();
+                    }, options.timeoutMs)
+                    : undefined;
+            timeout?.unref?.();
+            options.signal?.addEventListener("abort", abort, { once: true });
+            child.stdout.setEncoding("utf8");
+            child.stderr.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk;
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk;
+            });
+            child.on("error", (err) => {
+                if (timedOut)
+                    finish({ stdout, stderr, exitCode: 124 });
+                else if (aborted)
+                    finish({ stdout, stderr, exitCode: 130 });
+                else
+                    reject(err);
+            });
+            child.on("close", (code, signal) => {
+                if (timedOut)
+                    finish({ stdout, stderr, exitCode: 124 });
+                else if (aborted)
+                    finish({ stdout, stderr, exitCode: 130 });
+                else
+                    finish({ stdout, stderr, exitCode: code ?? exitCodeForSignal(signal) });
+            });
+        });
+    }
+}
+export function createNodeSandboxApi(options = {}) {
+    return new NodeSandboxApi(options);
+}
+export function createNodeSandboxSessionEnv(cwd = process.cwd()) {
+    return createSandboxSessionEnv(createNodeSandboxApi({ cwd }), cwd);
+}

package/node_modules/@reasonlayer/runner/dist/task-child.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@reasonlayer/runner/dist/task-child.js

@@ -0,0 +1,72 @@
+import { executeClaimTask, } from "./index.js";
+let controller;
+let forcedExit;
+function send(message) {
+    return new Promise((resolve) => {
+        if (!process.send) {
+            resolve();
+            return;
+        }
+        process.send(message, () => resolve());
+    });
+}
+function exitAfterError(message, code) {
+    void send({ type: "result", result: { kind: "error", message } }).finally(() => process.exit(code));
+}
+process.once("SIGTERM", () => {
+    controller?.abort();
+    forcedExit = setTimeout(() => process.exit(143), 4_500);
+    forcedExit.unref?.();
+});
+process.once("message", (message) => {
+    if (!message || message.type !== "run") {
+        exitAfterError("invalid task child message", 1);
+        return;
+    }
+    void (async () => {
+        controller = new AbortController();
+        const reporter = {
+            push: async (event) => {
+                await send({ type: "transcript", event });
+            },
+        };
+        let result;
+        try {
+            const convexUrl = message.options?.convexUrl;
+            if (!convexUrl)
+                throw new Error("task child message is missing convexUrl");
+            const output = await executeClaimTask(message.claim, {
+                convexUrl,
+                ...(message.options?.cacheDir !== undefined ? { cacheDir: message.options.cacheDir } : {}),
+                ...(message.options?.materializeEnvironments !== undefined
+                    ? { materializeEnvironments: message.options.materializeEnvironments }
+                    : {}),
+                ...(message.options?.verifyDeviceEnvironments !== undefined
+                    ? { verifyDeviceEnvironments: message.options.verifyDeviceEnvironments }
+                    : {}),
+                signal: controller.signal,
+                reporter,
+            });
+            result = { kind: "ok", output };
+        }
+        catch (err) {
+            if (controller.signal.aborted) {
+                result = { kind: "canceled" };
+            }
+            else {
+                result = {
+                    kind: "error",
+                    message: err instanceof Error ? err.message : String(err),
+                    ...(err instanceof Error && err.stack !== undefined ? { stack: err.stack } : {}),
+                };
+            }
+        }
+        finally {
+            if (forcedExit)
+                clearTimeout(forcedExit);
+        }
+        await send({ type: "result", result });
+        process.disconnect?.();
+        process.exit(0);
+    })();
+});

package/node_modules/@reasonlayer/runner/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@reasonlayer/runner",
+  "version": "0.1.0",
+  "private": true,
+  "license": "Apache-2.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "pnpm --filter @reasonlayer/protocol build && pnpm --filter @reasonlayer/integrations build && tsc -p tsconfig.json",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "pnpm --filter @reasonlayer/protocol build && pnpm --filter @reasonlayer/integrations build && tsc -p tsconfig.json --noEmit"
+  }
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@reasonlayer/sdk",
+  "version": "0.0.1",
+  "description": "Author, validate, and compile Reasonlayer workflows.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reasonlayer/rl-1.git",
+    "directory": "packages/sdk"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./bundler": {
+      "types": "./dist/bundler/index.d.ts",
+      "import": "./dist/bundler/index.js"
+    },
+    "./testkit": {
+      "types": "./dist/testkit.d.ts",
+      "import": "./dist/testkit.js"
+    }
+  },
+  "bin": {
+    "rl": "./bin/rl.mjs"
+  },
+  "scripts": {
+    "build": "pnpm --filter @reasonlayer/runner build && tsc -p tsconfig.json",
+    "prepack": "pnpm build && node scripts/package-bundled-dependencies.mjs prepare",
+    "postpack": "node scripts/package-bundled-dependencies.mjs restore",
+    "test": "pnpm build && vitest run --exclude test/pinning.test.ts && vitest run test/pinning.test.ts",
+    "typecheck": "pnpm --filter @reasonlayer/runner build && tsc -p tsconfig.typecheck.json --noEmit"
+  },
+  "bundleDependencies": [
+    "@reasonlayer/integrations",
+    "@reasonlayer/protocol",
+    "@reasonlayer/runner"
+  ],
+  "dependencies": {
+    "@cfworker/json-schema": "^4.1.1",
+    "@flue/runtime": "1.0.0-beta.8",
+    "@napi-rs/keyring": "^1.3.0",
+    "@reasonlayer/integrations": "0.1.0",
+    "@reasonlayer/protocol": "0.1.0",
+    "@reasonlayer/runner": "0.1.0",
+    "@valibot/to-json-schema": "^1.3.0",
+    "convex": "^1.42.1",
+    "cron-parser": "5.6.1",
+    "esbuild": "^0.25.5",
+    "valibot": "^1.1.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.0"
+  }
+}