@workser/runtime 0.0.0-stage → 0.1.0

package/dist/cjs/internal/sse.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Server-Sent Events over `fetch`, for Node 18+ and browsers alike.
+ *
+ * Not `EventSource`: it can't send an `Authorization` header (a runner's token
+ * has to go somewhere), it doesn't exist in Node, and its reconnect can't be
+ * told to resume from a cursor we choose. This follows the HTML spec's parsing
+ * rules (line endings, `data` joining, comments, `id`, `retry`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SseHttpError = exports.SseParser = void 0;
+exports.connectSse = connectSse;
+exports.sleep = sleep;
+/** Incremental parser: feed it text chunks, get whole messages back. */
+class SseParser {
+    buffer = '';
+    data = [];
+    event = '';
+    lastId = '';
+    retry;
+    sawCr = false;
+    /** Parse one chunk. A message split across chunks is held until complete. */
+    push(chunk) {
+        const out = [];
+        let text = chunk;
+        // A `\r\n` split across two chunks: the `\n` belongs to the `\r` already
+        // treated as a line end.
+        if (this.sawCr && text.startsWith('\n'))
+            text = text.slice(1);
+        this.sawCr = false;
+        this.buffer += text;
+        for (;;) {
+            const match = /\r\n|\r|\n/.exec(this.buffer);
+            if (!match)
+                break;
+            const line = this.buffer.slice(0, match.index);
+            const endsWithLoneCr = match[0] === '\r' && match.index + 1 === this.buffer.length;
+            this.buffer = this.buffer.slice(match.index + match[0].length);
+            if (endsWithLoneCr)
+                this.sawCr = true;
+            const message = this.line(line);
+            if (message)
+                out.push(message);
+        }
+        return out;
+    }
+    line(line) {
+        if (line === '')
+            return this.dispatch();
+        if (line.startsWith(':'))
+            return null; // a comment (servers use them as pings)
+        const colon = line.indexOf(':');
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let value = colon === -1 ? '' : line.slice(colon + 1);
+        if (value.startsWith(' '))
+            value = value.slice(1);
+        switch (field) {
+            case 'data':
+                this.data.push(value);
+                break;
+            case 'event':
+                this.event = value;
+                break;
+            case 'id':
+                if (!value.includes('\u0000'))
+                    this.lastId = value;
+                break;
+            case 'retry':
+                if (/^\d+$/.test(value))
+                    this.retry = Number(value);
+                break;
+            default:
+                break; // unknown fields are ignored
+        }
+        return null;
+    }
+    dispatch() {
+        const retry = this.retry;
+        this.retry = undefined;
+        if (this.data.length === 0) {
+            this.event = '';
+            return null;
+        }
+        const message = {
+            event: this.event || 'message',
+            data: this.data.join('\n'),
+            id: this.lastId,
+        };
+        if (retry !== undefined)
+            message.retry = retry;
+        this.data = [];
+        this.event = '';
+        return message;
+    }
+}
+exports.SseParser = SseParser;
+/**
+ * Keep an SSE connection open until `signal` aborts: connect, parse, and on
+ * any drop reconnect with backoff. The caller's `url()` decides where to
+ * resume from, so reconnects continue rather than replay.
+ */
+async function connectSse(options) {
+    const base = options.baseDelayMs ?? 500;
+    const max = options.maxDelayMs ?? 15_000;
+    const fatal = new Set(options.fatalStatuses ?? [401, 403, 404]);
+    let delay = base;
+    let serverRetry;
+    while (!options.signal.aborted) {
+        let failure = null;
+        try {
+            const response = await options.fetch(options.url(), {
+                headers: { Accept: 'text/event-stream', ...options.headers() },
+                signal: options.signal,
+            });
+            if (!response.ok || !response.body) {
+                const error = new SseHttpError(response.status);
+                if (fatal.has(response.status)) {
+                    options.onError?.(error);
+                    return;
+                }
+                throw error;
+            }
+            delay = base;
+            const parser = new SseParser();
+            const decoder = new TextDecoder();
+            const reader = response.body.getReader();
+            for (;;) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                for (const message of parser.push(decoder.decode(value, { stream: true }))) {
+                    if (message.retry !== undefined)
+                        serverRetry = message.retry;
+                    options.onMessage(message);
+                }
+            }
+        }
+        catch (error) {
+            failure = error;
+        }
+        if (options.signal.aborted)
+            return;
+        if (failure && options.onError?.(failure) === false)
+            return;
+        await sleep(serverRetry ?? delay, options.signal);
+        delay = Math.min(delay * 2, max);
+    }
+}
+class SseHttpError extends Error {
+    status;
+    constructor(status) {
+        super(`The stream answered ${status}.`);
+        this.status = status;
+        this.name = 'SseHttpError';
+    }
+}
+exports.SseHttpError = SseHttpError;
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted)
+            return resolve();
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', done);
+            resolve();
+        }
+        signal?.addEventListener('abort', done, { once: true });
+    });
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/cjs/place/place.js

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

package/dist/cjs/runner/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerError = exports.RunnerClient = void 0;
+var runner_client_js_1 = require("./runner-client.js");
+Object.defineProperty(exports, "RunnerClient", { enumerable: true, get: function () { return runner_client_js_1.RunnerClient; } });
+Object.defineProperty(exports, "RunnerError", { enumerable: true, get: function () { return runner_client_js_1.RunnerError; } });

package/dist/cjs/runner/journal.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventJournal = void 0;
+class EventJournal {
+    fs;
+    path;
+    pathMod;
+    dirty = false;
+    constructor(fs, path, pathMod) {
+        this.fs = fs;
+        this.path = path;
+        this.pathMod = pathMod;
+    }
+    static async open(path) {
+        const fs = await Promise.resolve().then(() => require('node:fs'));
+        const pathMod = await Promise.resolve().then(() => require('node:path'));
+        fs.mkdirSync(pathMod.dirname(path), { recursive: true, mode: 0o700 });
+        if (!fs.existsSync(path))
+            fs.writeFileSync(path, '', { mode: 0o600 });
+        return new EventJournal(fs, path, pathMod);
+    }
+    /** Events saved by an earlier process, oldest first, one per event id. */
+    load() {
+        let raw = '';
+        try {
+            raw = this.fs.readFileSync(this.path, 'utf8');
+        }
+        catch {
+            return [];
+        }
+        const byId = new Map();
+        for (const line of raw.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (typeof event?.event_id === 'string' && Number.isInteger(event.seq) && typeof event.type === 'string') {
+                    // A later line for the same id is a renumbering: it wins.
+                    byId.set(event.event_id, { ...event, data: event.data ?? {} });
+                }
+            }
+            catch {
+                // A torn last line (killed mid-append) is skipped; its event was never
+                // acknowledged to the caller as sent, and every earlier line is whole.
+            }
+        }
+        return [...byId.values()].sort((a, b) => a.seq - b.seq);
+    }
+    append(event) {
+        this.fs.appendFileSync(this.path, `${JSON.stringify(event)}\n`, { mode: 0o600 });
+        this.dirty = true;
+    }
+    /** Make appended lines durable. Called before each send. */
+    sync() {
+        if (!this.dirty)
+            return;
+        const fd = this.fs.openSync(this.path, 'r+');
+        try {
+            this.fs.fsyncSync(fd);
+        }
+        finally {
+            this.fs.closeSync(fd);
+        }
+        this.dirty = false;
+    }
+    /** Replace the journal with what is still unsent. */
+    rewrite(events) {
+        const temp = this.pathMod.join(this.pathMod.dirname(this.path), `.journal-${process.pid}-${Date.now()}.tmp`);
+        const body = events.map((event) => JSON.stringify(event)).join('\n');
+        const fd = this.fs.openSync(temp, 'w', 0o600);
+        try {
+            this.fs.writeSync(fd, body ? `${body}\n` : '');
+            this.fs.fsyncSync(fd);
+        }
+        finally {
+            this.fs.closeSync(fd);
+        }
+        this.fs.renameSync(temp, this.path);
+        this.dirty = false;
+    }
+}
+exports.EventJournal = EventJournal;