@reasonlayer/sdk 0.0.1

package/dist/cli/storage-upload.d.ts

@@ -0,0 +1,9 @@
+export interface StorageUpload {
+    storageId: string;
+    sha256: string;
+    size: number;
+}
+export declare function uploadStorage(requestUploadUrl: () => Promise<string>, bytes: Uint8Array, options: {
+    contentType?: string;
+    label: string;
+}): Promise<StorageUpload>;

package/dist/cli/storage-upload.js

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+export async function uploadStorage(requestUploadUrl, bytes, options) {
+    const uploadUrl = await requestUploadUrl();
+    const response = await fetch(uploadUrl, {
+        method: "POST",
+        headers: { "content-type": options.contentType ?? "application/octet-stream" },
+        body: bytes,
+    });
+    if (!response.ok) {
+        throw new Error(`storage upload failed for ${options.label} (HTTP ${response.status}): ${await response.text()}`);
+    }
+    const result = await response.json();
+    if (!result.storageId) {
+        throw new Error(`storage upload response for ${options.label} did not include storageId`);
+    }
+    return {
+        storageId: result.storageId,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        size: bytes.byteLength,
+    };
+}

package/dist/cli/watcher-compile.d.ts

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

package/dist/cli/watcher-compile.js

@@ -0,0 +1,20 @@
+import { buildWorkflow } from "../bundler/index.js";
+const [entry, outDir] = process.argv.slice(2);
+if (!entry || !outDir) {
+    process.stderr.write("watcher compiler requires <entry> <out-dir>\n");
+    process.exitCode = 2;
+}
+else {
+    try {
+        const result = await buildWorkflow(entry, outDir);
+        process.stdout.write(`${JSON.stringify(result.ok
+            ? { ok: true, manifest: result.manifest, flueVersion: result.flueVersion }
+            : { ok: false, errors: result.errors })}\n`);
+    }
+    catch (error) {
+        process.stdout.write(`${JSON.stringify({
+            ok: false,
+            errors: [{ message: error instanceof Error ? error.message : String(error) }],
+        })}\n`);
+    }
+}

package/dist/cli/watcher-process.d.ts

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

package/dist/cli/watcher-process.js

@@ -0,0 +1,312 @@
+import { createHash, randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { constants, watch } from "node:fs";
+import { access, readFile, rm, symlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { FN } from "@reasonlayer/protocol";
+import { RlConvexClient } from "./convex.js";
+import { uploadStorage } from "./storage-upload.js";
+import { parseLocalWorkspaceSession, } from "./workspace-session.js";
+import { changedWorkspaceFiles, deletedWorkspacePaths, materializeWorkspaceSnapshot, refreshWorkspacePaths, scanWorkspace, workspaceManifest, } from "./workspace-files.js";
+const DEBOUNCE_MS = 150;
+const HEARTBEAT_MS = 30_000;
+const COMPILE_TIMEOUT_MS = 30_000;
+const IDLE_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkoutSdkVersion(checkoutPath) {
+    const manifestPath = join(checkoutPath, "node_modules", "@reasonlayer", "sdk", "package.json");
+    const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    if (typeof manifest.version !== "string" || !manifest.version) {
+        throw new Error(`checkout SDK has no valid version in ${manifestPath}`);
+    }
+    return manifest.version;
+}
+async function upload(client, state, bytes, contentType = "application/octet-stream") {
+    return await uploadStorage(async () => await client.mutation(FN.workspacesGenerateUploadUrl, {
+        token: state.authoringToken,
+        sessionId: state.sessionId,
+    }), bytes, { contentType, label: "workspace artifact" });
+}
+async function mirrorChanges(client, state, changed, deleted) {
+    const missing = new Set(await client.query(FN.workspacesMissingBlobs, {
+        token: state.authoringToken,
+        sessionId: state.sessionId,
+        sha256: changed.map((file) => file.sha256),
+    }));
+    const storageByHash = new Map();
+    for (const file of changed) {
+        if (!missing.has(file.sha256) || storageByHash.has(file.sha256))
+            continue;
+        storageByHash.set(file.sha256, (await upload(client, state, file.bytes)).storageId);
+    }
+    await client.mutation(FN.workspacesMirror, {
+        token: state.authoringToken,
+        sessionId: state.sessionId,
+        files: changed.map((file) => ({
+            path: file.path,
+            sha256: file.sha256,
+            size: file.size,
+            ...(storageByHash.get(file.sha256) ? { storageId: storageByHash.get(file.sha256) } : {}),
+        })),
+        deletedPaths: deleted,
+    });
+}
+async function compileChild(entry, outDir) {
+    const script = join(dirname(fileURLToPath(import.meta.url)), "watcher-compile.js");
+    return await new Promise((resolveCompile) => {
+        const child = spawn(process.execPath, [script, entry, outDir], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+        }, COMPILE_TIMEOUT_MS);
+        child.stdout.on("data", (chunk) => (stdout += String(chunk)));
+        child.stderr.on("data", (chunk) => (stderr += String(chunk)));
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            resolveCompile({ ok: false, errors: [{ message: `compiler child crashed: ${error.message}` }] });
+        });
+        child.on("close", () => {
+            clearTimeout(timer);
+            if (timedOut) {
+                resolveCompile({ ok: false, errors: [{ message: `compiler exceeded ${COMPILE_TIMEOUT_MS}ms wall-clock limit` }] });
+                return;
+            }
+            try {
+                resolveCompile(JSON.parse(stdout.trim()));
+            }
+            catch {
+                resolveCompile({
+                    ok: false,
+                    errors: [{ message: `compiler child exited without a result${stderr ? `: ${stderr.trim()}` : ""}` }],
+                });
+            }
+        });
+    });
+}
+async function bundleParts(client, state, outDir, artifacts) {
+    const local = await Promise.all([
+        ["steps", artifacts.steps],
+        ...(artifacts.agents ? [["agents", artifacts.agents]] : []),
+    ].map(async ([label, name]) => {
+        const bytes = await readFile(join(outDir, name));
+        return {
+            label,
+            bytes,
+            sha256: createHash("sha256").update(bytes).digest("hex"),
+            size: bytes.byteLength,
+        };
+    }));
+    const available = await client.query(FN.workspacesAvailableBundles, {
+        token: state.authoringToken,
+        sessionId: state.sessionId,
+        sha256: local.map((item) => item.sha256),
+    });
+    const existing = new Map(available.map((item) => [item.sha256, item]));
+    const result = [];
+    for (const item of local) {
+        const retained = existing.get(item.sha256);
+        result.push({
+            label: item.label,
+            sha256: item.sha256,
+            storageId: retained?.storageId ?? (await upload(client, state, item.bytes, "application/javascript")).storageId,
+            size: retained?.size ?? item.size,
+        });
+    }
+    return result;
+}
+async function compileAndRecord(client, state, files, sdkVersion) {
+    const operationId = randomUUID();
+    const snapshotRoot = join(state.checkoutPath, ".rl", `snapshot-${operationId}`);
+    const outDir = join(state.checkoutPath, ".rl", `build-${operationId}`);
+    try {
+        await materializeWorkspaceSnapshot(files, snapshotRoot);
+        await symlink(join(state.checkoutPath, "node_modules"), join(snapshotRoot, "node_modules"), "dir");
+        const entry = join(snapshotRoot, "src", "workflow.ts");
+        const result = await compileChild(entry, outDir);
+        if (!result.ok) {
+            await client.mutation(FN.workspacesRecordCompileError, {
+                token: state.authoringToken,
+                sessionId: state.sessionId,
+                errors: result.errors,
+            });
+            return;
+        }
+        const irJson = await readFile(join(outDir, result.manifest.artifacts.ir), "utf8");
+        const bundle = await bundleParts(client, state, outDir, result.manifest.artifacts);
+        await client.mutation(FN.workspacesRecordCompile, {
+            token: state.authoringToken,
+            sessionId: state.sessionId,
+            manifest: workspaceManifest(files),
+            irJson,
+            bundle,
+            codeStepIds: result.manifest.codeStepIds,
+            sdkVersion,
+            ...(result.flueVersion !== undefined ? { flueVersion: result.flueVersion } : {}),
+        });
+    }
+    finally {
+        await Promise.all([
+            rm(snapshotRoot, { recursive: true, force: true }),
+            rm(outDir, { recursive: true, force: true }),
+        ]);
+    }
+}
+function watchesWorkspacePath(filename) {
+    if (filename === null)
+        return true;
+    const [root] = String(filename).split(/[\\/]/);
+    return root !== ".rl" && root !== "node_modules" && root !== "dist";
+}
+function workspaceChanges(root) {
+    let fullScan = true;
+    const paths = new Set();
+    let waiter;
+    let timer;
+    const release = () => {
+        if (!waiter)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            const resolveWait = waiter;
+            waiter = undefined;
+            const batch = fullScan ? null : new Set(paths);
+            fullScan = false;
+            paths.clear();
+            resolveWait?.(batch);
+        }, DEBOUNCE_MS);
+    };
+    const watcher = watch(root, { recursive: true }, (_event, filename) => {
+        if (!watchesWorkspacePath(filename))
+            return;
+        if (filename === null)
+            fullScan = true;
+        else
+            paths.add(String(filename));
+        release();
+    });
+    return {
+        async wait() {
+            return await new Promise((resolveWait) => {
+                waiter = resolveWait;
+                if (fullScan || paths.size > 0)
+                    release();
+            });
+        },
+        wake() {
+            fullScan = true;
+            release();
+        },
+        close() {
+            if (timer)
+                clearTimeout(timer);
+            watcher.close();
+            waiter?.(null);
+        },
+    };
+}
+async function main(sessionPath) {
+    const state = parseLocalWorkspaceSession(await readFile(sessionPath, "utf8"), sessionPath);
+    const sdkVersion = await checkoutSdkVersion(state.checkoutPath);
+    const client = new RlConvexClient({ convexUrl: state.convexUrl, token: state.authoringToken });
+    let stopped = false;
+    let drainRequested = false;
+    let lastError;
+    const changes = workspaceChanges(state.checkoutPath);
+    const stop = () => {
+        stopped = true;
+        changes.wake();
+    };
+    const drainAndStop = () => {
+        drainRequested = true;
+        changes.wake();
+    };
+    process.once("SIGTERM", drainAndStop);
+    process.once("SIGINT", drainAndStop);
+    let previous = new Map();
+    let lastActivityAt = Date.now();
+    const heartbeat = setInterval(() => {
+        if (Date.now() - lastActivityAt >= IDLE_TIMEOUT_MS) {
+            void client.mutation(FN.workspacesEndSession, {
+                token: state.authoringToken,
+                sessionId: state.sessionId,
+            }).finally(drainAndStop);
+            return;
+        }
+        void client.mutation(FN.workspacesHeartbeat, {
+            token: state.authoringToken,
+            sessionId: state.sessionId,
+            ...(lastError ? { error: lastError } : {}),
+        }).then((result) => {
+            if (result.ended)
+                drainAndStop();
+        }).catch((error) => {
+            lastError = error instanceof Error ? error.message : String(error);
+            if (lastError.includes("authoring session expired"))
+                drainAndStop();
+        });
+    }, HEARTBEAT_MS);
+    heartbeat.unref();
+    try {
+        while (!stopped && await exists(state.checkoutPath)) {
+            const changedPaths = await changes.wait();
+            if (stopped || !await exists(state.checkoutPath))
+                break;
+            try {
+                const current = changedPaths === null
+                    ? await scanWorkspace(state.checkoutPath)
+                    : await refreshWorkspacePaths(state.checkoutPath, previous, changedPaths);
+                const changed = changedWorkspaceFiles(current, previous);
+                const deleted = deletedWorkspacePaths(current, previous);
+                if (changed.length || deleted.length) {
+                    lastActivityAt = Date.now();
+                    await mirrorChanges(client, state, changed, deleted);
+                    await compileAndRecord(client, state, current, sdkVersion);
+                    previous = current;
+                }
+                lastError = undefined;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error.message : String(error);
+                process.stderr.write(`${new Date().toISOString()} ${lastError}\n`);
+                changes.wake();
+                continue;
+            }
+            if (drainRequested)
+                break;
+        }
+    }
+    finally {
+        clearInterval(heartbeat);
+        changes.close();
+    }
+}
+const sessionPath = process.argv[2];
+if (!sessionPath) {
+    process.stderr.write("watcher daemon requires a session path\n");
+    process.exitCode = 2;
+}
+else {
+    try {
+        await main(sessionPath);
+    }
+    catch (error) {
+        process.stderr.write(`watcher daemon: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    }
+}

package/dist/cli/worker-host.d.ts

@@ -0,0 +1,10 @@
+export interface WorkerHostOptions {
+    host: string;
+    port: number;
+    secret?: string;
+}
+export declare function startWorkerHost(options: WorkerHostOptions): Promise<{
+    url: string;
+    secret: string;
+    close: () => Promise<void>;
+}>;

package/dist/cli/worker-host.js

@@ -0,0 +1,120 @@
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+const SKEW_MS = 5 * 60 * 1000;
+function json(res, status, body) {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+function validSignature(body, headers, secret) {
+    const ts = headers["x-rl-timestamp"];
+    const sig = headers["x-rl-signature"];
+    if (typeof ts !== "string" || typeof sig !== "string")
+        return false;
+    const timestamp = Number(ts);
+    if (!Number.isFinite(timestamp) || Math.abs(Date.now() - timestamp) > SKEW_MS)
+        return false;
+    const expected = createHmac("sha256", secret).update(`${ts}.${body.toString("utf8")}`).digest("hex");
+    try {
+        const actualBytes = Buffer.from(sig, "hex");
+        const expectedBytes = Buffer.from(expected, "hex");
+        return actualBytes.length === expectedBytes.length && timingSafeEqual(actualBytes, expectedBytes);
+    }
+    catch {
+        return false;
+    }
+}
+export async function startWorkerHost(options) {
+    const secret = options.secret ?? process.env["RL_DISPATCH_SECRET"] ?? randomBytes(32).toString("hex");
+    const cache = new Map();
+    async function loadWorker(scriptUrl) {
+        let cached = cache.get(scriptUrl);
+        if (!cached) {
+            cached = (async () => {
+                const fetched = await fetch(scriptUrl);
+                if (!fetched.ok) {
+                    throw new Error(`cannot fetch worker bundle (HTTP ${fetched.status}): ${await fetched.text()}`);
+                }
+                const dir = await mkdtemp(join(tmpdir(), "rlx-worker-host-"));
+                const file = join(dir, "worker.mjs");
+                await writeFile(file, await fetched.text());
+                return (await import(pathToFileURL(file).href));
+            })().catch((err) => {
+                cache.delete(scriptUrl);
+                throw err;
+            });
+            cache.set(scriptUrl, cached);
+        }
+        return await cached;
+    }
+    const server = createServer(async (req, res) => {
+        try {
+            if (req.method === "GET" && req.url === "/health") {
+                json(res, 200, { ok: true });
+                return;
+            }
+            if (req.method !== "POST") {
+                json(res, 405, { error: "POST only" });
+                return;
+            }
+            const rawBody = await readBody(req);
+            if (!validSignature(rawBody, req.headers, secret)) {
+                json(res, 401, { error: "invalid Reasonlayer dispatch signature" });
+                return;
+            }
+            const body = JSON.parse(rawBody.toString("utf8"));
+            if (!body.scriptUrl || !body.stepId) {
+                json(res, 400, { error: "request must include scriptUrl and stepId" });
+                return;
+            }
+            const worker = await loadWorker(body.scriptUrl);
+            const workerRes = await worker.default.fetch(new Request("http://rlx-worker-host/invoke", {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    stepId: body.stepId,
+                    input: body.input,
+                    env: body.env ?? {},
+                }),
+            }));
+            const text = await workerRes.text();
+            res.writeHead(workerRes.status, {
+                "content-type": workerRes.headers.get("content-type") ?? "application/json",
+            });
+            res.end(text);
+        }
+        catch (err) {
+            const failed = {
+                status: "failed",
+                error: { message: err instanceof Error ? err.message : String(err) },
+            };
+            json(res, 500, failed);
+        }
+    });
+    await new Promise((resolveListen, rejectListen) => {
+        server.once("error", rejectListen);
+        server.listen(options.port, options.host, () => {
+            server.off("error", rejectListen);
+            resolveListen();
+        });
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : options.port;
+    return {
+        url: `http://${options.host}:${port}`,
+        secret,
+        close: () => new Promise((resolveClose, rejectClose) => {
+            server.close((err) => (err ? rejectClose(err) : resolveClose()));
+        }),
+    };
+}

package/dist/cli/workspace-files.d.ts

@@ -0,0 +1,12 @@
+export type WorkspaceFileState = {
+    path: string;
+    sha256: string;
+    size: number;
+    bytes: Buffer;
+};
+export declare function scanWorkspace(root: string): Promise<Map<string, WorkspaceFileState>>;
+export declare function refreshWorkspacePaths(root: string, previous: Map<string, WorkspaceFileState>, paths: Iterable<string>): Promise<Map<string, WorkspaceFileState>>;
+export declare function materializeWorkspaceSnapshot(files: Map<string, WorkspaceFileState>, target: string): Promise<void>;
+export declare function changedWorkspaceFiles(current: Map<string, WorkspaceFileState>, previous: Map<string, WorkspaceFileState>): WorkspaceFileState[];
+export declare function deletedWorkspacePaths(current: Map<string, WorkspaceFileState>, previous: Map<string, WorkspaceFileState>): string[];
+export declare function workspaceManifest(files: Map<string, WorkspaceFileState>): Record<string, string>;

package/dist/cli/workspace-files.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import { lstat, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+const IGNORED = new Set([".git", ".rl", "dist", "node_modules"]);
+function ignored(path) {
+    return IGNORED.has(path.split(/[\\/]/)[0]);
+}
+async function readWorkspaceFile(root, absolute) {
+    const bytes = await readFile(absolute);
+    const path = relative(root, absolute).split("\\").join("/");
+    return {
+        path,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        size: bytes.byteLength,
+        bytes,
+    };
+}
+async function scanDirectory(root, directory, files) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+        if (IGNORED.has(entry.name))
+            continue;
+        const absolute = join(directory, entry.name);
+        if (entry.isDirectory())
+            await scanDirectory(root, absolute, files);
+        else if (entry.isFile()) {
+            const file = await readWorkspaceFile(root, absolute);
+            files.set(file.path, file);
+        }
+    }
+}
+export async function scanWorkspace(root) {
+    const files = new Map();
+    await scanDirectory(root, root, files);
+    return files;
+}
+export async function refreshWorkspacePaths(root, previous, paths) {
+    const current = new Map(previous);
+    for (const rawPath of paths) {
+        const path = rawPath.split("\\").join("/");
+        if (!path || ignored(path))
+            continue;
+        const absolute = resolve(root, path);
+        const withinRoot = relative(resolve(root), absolute);
+        if (!withinRoot || withinRoot.startsWith("..") || isAbsolute(withinRoot))
+            continue;
+        const prefix = `${path.replace(/\/$/, "")}/`;
+        let stat;
+        try {
+            stat = await lstat(absolute);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            current.delete(path);
+            for (const existing of current.keys()) {
+                if (existing.startsWith(prefix))
+                    current.delete(existing);
+            }
+            continue;
+        }
+        if (stat.isDirectory()) {
+            for (const existing of current.keys()) {
+                if (existing.startsWith(prefix))
+                    current.delete(existing);
+            }
+            await scanDirectory(root, absolute, current);
+        }
+        else if (stat.isFile()) {
+            const file = await readWorkspaceFile(root, absolute);
+            current.set(file.path, file);
+        }
+    }
+    return current;
+}
+export async function materializeWorkspaceSnapshot(files, target) {
+    await Promise.all([...files.values()].map(async (file) => {
+        const path = join(target, file.path);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, file.bytes);
+    }));
+}
+export function changedWorkspaceFiles(current, previous) {
+    return [...current.values()].filter((file) => previous.get(file.path)?.sha256 !== file.sha256);
+}
+export function deletedWorkspacePaths(current, previous) {
+    return [...previous.keys()].filter((path) => !current.has(path));
+}
+export function workspaceManifest(files) {
+    return Object.fromEntries([...files.values()].map((file) => [file.path, file.sha256]));
+}

package/dist/cli/workspace-local.d.ts

@@ -0,0 +1,27 @@
+import type { OperationRuntime } from "./operations.js";
+import { type LocalWorkspaceSession } from "./workspace-session.js";
+export type { LocalWorkspaceSession } from "./workspace-session.js";
+export interface StartWorkspaceResult {
+    sessionId: string;
+    workflowId: string;
+    authoringToken: string;
+    expiresAt: number;
+}
+export declare function startDaemon(sessionPath: string): Promise<number>;
+export declare function createCheckout(runtime: OperationRuntime, options: {
+    workflowId: string;
+    mode: "init" | "pull";
+    targetDir?: string;
+}): Promise<{
+    checkoutPath: string;
+    sessionId: string;
+    daemonPid: number;
+    files: number;
+}>;
+export declare function findCheckoutRoot(cwd?: string): Promise<string>;
+export declare function readLocalSession(cwd?: string): Promise<LocalWorkspaceSession>;
+export declare function endLocalSession(runtime: OperationRuntime): Promise<{
+    workflowId: string;
+    sessionId: string;
+    checkoutPath: string;
+}>;