nestjs-web-repl 0.0.0

package/dist/ring-buffer.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRingBuffer = void 0;
+class EventRingBuffer {
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.events = [];
+    }
+    push(event) {
+        this.events.push(event);
+        if (this.events.length > this.capacity) {
+            this.events.splice(0, this.events.length - this.capacity);
+        }
+    }
+    since(lastEventId) {
+        if (lastEventId === null)
+            return [...this.events];
+        return this.events.filter((e) => e.id > lastEventId);
+    }
+    clear() {
+        this.events.length = 0;
+    }
+    isEmpty() {
+        return this.events.length === 0;
+    }
+}
+exports.EventRingBuffer = EventRingBuffer;

package/dist/session/repl-session.d.ts

@@ -0,0 +1,72 @@
+export interface ReplSessionOptions {
+    context: Record<string, unknown>;
+    onOutput: (chunk: string) => void;
+    /**
+     * Safety-net timeout (ms) for a single eval(), in case some future input
+     * shape defeats both the sentinel-completion signal and the incomplete-
+     * input recovery below. Defaults to 30000. A legitimate async command
+     * that runs longer than this will be cut off with a timeout error.
+     */
+    evalTimeoutMs?: number;
+}
+export declare class ReplSession {
+    private readonly opts;
+    private readonly input;
+    private readonly server;
+    private readonly evalTimeoutMs;
+    private readonly sentinel;
+    private readonly bufferedCommandSymbol;
+    private queue;
+    private buffer;
+    private resolveCurrent;
+    private watchdog;
+    private closed;
+    constructor(opts: ReplSessionOptions);
+    /**
+     * Buffers incoming output text, strips every occurrence of the sentinel
+     * before it reaches onOutput, and resolves the in-flight eval() promise
+     * (if any) each time a sentinel is found. A trailing partial match of
+     * the sentinel is held back across writes so a sentinel split across two
+     * stream chunks is never mistakenly forwarded or missed.
+     *
+     * The bare continuation-prompt marker is filtered out (never forwarded
+     * as output) but, on its own, is NOT treated as a "this command is
+     * stuck" signal -- a legitimate multi-line command supplied as one
+     * eval() string transiently produces this marker for every line that
+     * doesn't yet close out a statement before the final line completes it.
+     * Reacting to the first occurrence would wrongly abort those valid
+     * commands. See checkForStuckIncompleteInput() for the real recovery
+     * path.
+     */
+    private handleOutput;
+    /** Length of the longest suffix of `text` that is also a prefix of the sentinel. */
+    private partialSentinelSuffixLength;
+    /**
+     * Called shortly after a command has been written to `input`, once
+     * node:repl has had a chance to drain and process every line of it
+     * (including every line of a multi-line command written as one
+     * string). If the eval already resolved via the sentinel, this is a
+     * no-op. Otherwise, reads node:repl's own buffered-command state: a
+     * non-empty buffer at this point means the submitted text left a
+     * trailing statement that is syntactically incomplete and will never
+     * complete on its own (there is no more input coming for it), so we
+     * recover instead of waiting forever. An empty buffer means parsing
+     * fully consumed the input -- whether it already finished evaluating
+     * (sync) or is still running (e.g. a pending top-level await) -- so we
+     * leave it alone and let the sentinel (or, failing that, the watchdog)
+     * resolve it whenever it's actually done.
+     */
+    private checkForStuckIncompleteInput;
+    /**
+     * Discards a syntactically-incomplete buffered command so the session
+     * doesn't wait forever for input that will never arrive as a
+     * continuation of it, reports the failure, and unblocks the eval queue.
+     */
+    private recoverFromIncompleteInput;
+    /** Resolves the in-flight eval() (if any) and clears its watchdog timer. */
+    private settle;
+    private format;
+    eval(command: string): Promise<void>;
+    private runLine;
+    close(): void;
+}

package/dist/session/repl-session.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplSession = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_repl_1 = require("node:repl");
+const node_stream_1 = require("node:stream");
+const node_util_1 = require("node:util");
+// The non-terminal node:repl writes this exact two-character string, as its
+// own standalone `output` write, for every line that leaves a command
+// syntactically incomplete so far (an unmatched brace/paren/template
+// literal), whether or not the command is eventually completed by a later
+// line in the same batch. It is therefore only ever a *transient* signal,
+// never by itself proof that a command is permanently stuck -- see
+// checkForStuckIncompleteInput() for how genuine incompleteness is
+// determined. Verified empirically on Node v26.
+const CONTINUATION_PROMPT = '| ';
+class ReplSession {
+    constructor(opts) {
+        this.opts = opts;
+        this.input = new node_stream_1.PassThrough();
+        // A prompt string unique to this instance (via crypto.randomUUID()) so
+        // that no two sessions ever share a sentinel, and collisions with
+        // arbitrary user-controlled output are effectively impossible. node:repl
+        // (with terminal: false) re-writes the prompt to `output` exactly once
+        // per completed top-level statement, and, critically, only after that
+        // statement has fully settled: after a synchronous result, after an
+        // awaited top-level promise resolves (however long that takes), and
+        // after the domain-based uncaught-exception handler finishes reporting a
+        // thrown error. That makes "the sentinel appeared in output" a
+        // deterministic, timing-independent "this statement is done" signal that
+        // works uniformly across all of those cases.
+        this.sentinel = `<<webrepl:done:${(0, node_crypto_1.randomUUID)()}>>`;
+        this.queue = Promise.resolve();
+        this.buffer = '';
+        this.resolveCurrent = null;
+        this.watchdog = null;
+        this.closed = false;
+        this.evalTimeoutMs = opts.evalTimeoutMs ?? 30000;
+        const output = new node_stream_1.Writable({
+            write: (chunk, _enc, cb) => {
+                this.handleOutput(chunk.toString());
+                cb();
+            },
+        });
+        this.server = (0, node_repl_1.start)({
+            input: this.input,
+            output,
+            terminal: false,
+            useColors: false,
+            prompt: this.sentinel,
+            ignoreUndefined: true,
+        });
+        this.bufferedCommandSymbol = Object.getOwnPropertySymbols(this.server).find((s) => s.description === 'bufferedCommand');
+        for (const key of Object.keys(opts.context)) {
+            this.server.context[key] = opts.context[key];
+        }
+        this.server.context.console = {
+            log: (...a) => {
+                opts.onOutput(this.format(a) + '\n');
+            },
+            info: (...a) => {
+                opts.onOutput(this.format(a) + '\n');
+            },
+            warn: (...a) => {
+                opts.onOutput(this.format(a) + '\n');
+            },
+            error: (...a) => {
+                opts.onOutput(this.format(a) + '\n');
+            },
+            debug: (...a) => {
+                opts.onOutput(this.format(a) + '\n');
+            },
+        };
+        // The initial prompt is written synchronously inside start(), before
+        // this constructor returns and therefore before any eval() call could
+        // possibly have registered a resolver yet. handleOutput() strips it
+        // (resolveCurrent is still null at this point) and forwards nothing,
+        // so it never leaks into onOutput and never spuriously resolves the
+        // first real eval().
+    }
+    /**
+     * Buffers incoming output text, strips every occurrence of the sentinel
+     * before it reaches onOutput, and resolves the in-flight eval() promise
+     * (if any) each time a sentinel is found. A trailing partial match of
+     * the sentinel is held back across writes so a sentinel split across two
+     * stream chunks is never mistakenly forwarded or missed.
+     *
+     * The bare continuation-prompt marker is filtered out (never forwarded
+     * as output) but, on its own, is NOT treated as a "this command is
+     * stuck" signal -- a legitimate multi-line command supplied as one
+     * eval() string transiently produces this marker for every line that
+     * doesn't yet close out a statement before the final line completes it.
+     * Reacting to the first occurrence would wrongly abort those valid
+     * commands. See checkForStuckIncompleteInput() for the real recovery
+     * path.
+     */
+    handleOutput(text) {
+        if (text === CONTINUATION_PROMPT) {
+            return;
+        }
+        this.buffer += text;
+        let idx;
+        while ((idx = this.buffer.indexOf(this.sentinel)) !== -1) {
+            const before = this.buffer.slice(0, idx);
+            if (before.length)
+                this.opts.onOutput(before);
+            this.buffer = this.buffer.slice(idx + this.sentinel.length);
+            this.settle();
+        }
+        const holdBack = this.partialSentinelSuffixLength(this.buffer);
+        if (this.buffer.length > holdBack) {
+            const flush = this.buffer.slice(0, this.buffer.length - holdBack);
+            this.opts.onOutput(flush);
+            this.buffer = this.buffer.slice(this.buffer.length - holdBack);
+        }
+    }
+    /** Length of the longest suffix of `text` that is also a prefix of the sentinel. */
+    partialSentinelSuffixLength(text) {
+        const max = Math.min(text.length, this.sentinel.length - 1);
+        for (let len = max; len > 0; len--) {
+            if (text.endsWith(this.sentinel.slice(0, len)))
+                return len;
+        }
+        return 0;
+    }
+    /**
+     * Called shortly after a command has been written to `input`, once
+     * node:repl has had a chance to drain and process every line of it
+     * (including every line of a multi-line command written as one
+     * string). If the eval already resolved via the sentinel, this is a
+     * no-op. Otherwise, reads node:repl's own buffered-command state: a
+     * non-empty buffer at this point means the submitted text left a
+     * trailing statement that is syntactically incomplete and will never
+     * complete on its own (there is no more input coming for it), so we
+     * recover instead of waiting forever. An empty buffer means parsing
+     * fully consumed the input -- whether it already finished evaluating
+     * (sync) or is still running (e.g. a pending top-level await) -- so we
+     * leave it alone and let the sentinel (or, failing that, the watchdog)
+     * resolve it whenever it's actually done.
+     */
+    checkForStuckIncompleteInput() {
+        if (!this.resolveCurrent)
+            return;
+        if (this.bufferedCommandSymbol === undefined)
+            return;
+        const buffered = this.server[this.bufferedCommandSymbol];
+        if (typeof buffered === 'string' && buffered.length > 0) {
+            this.recoverFromIncompleteInput();
+        }
+    }
+    /**
+     * Discards a syntactically-incomplete buffered command so the session
+     * doesn't wait forever for input that will never arrive as a
+     * continuation of it, reports the failure, and unblocks the eval queue.
+     */
+    recoverFromIncompleteInput() {
+        this.server.clearBufferedCommand?.();
+        this.opts.onOutput('SyntaxError: incomplete input\n');
+        this.settle();
+    }
+    /** Resolves the in-flight eval() (if any) and clears its watchdog timer. */
+    settle() {
+        if (this.watchdog) {
+            clearTimeout(this.watchdog);
+            this.watchdog = null;
+        }
+        const resolve = this.resolveCurrent;
+        this.resolveCurrent = null;
+        resolve?.();
+    }
+    format(args) {
+        return args
+            .map((a) => (typeof a === 'string' ? a : (0, node_util_1.inspect)(a)))
+            .join(' ');
+    }
+    eval(command) {
+        this.queue = this.queue.then(() => this.runLine(command));
+        return this.queue;
+    }
+    runLine(command) {
+        if (this.closed) {
+            // The session was closed before this queued eval() got its turn.
+            // Resolve immediately rather than writing to a destroyed input
+            // stream (which would hang or error).
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            // Registering the resolver before writing guarantees we never miss
+            // the sentinel that reports this command's completion, however long
+            // (or short) evaluation takes.
+            this.resolveCurrent = resolve;
+            // Defense-in-depth safety net: the drain-check below is the
+            // primary, deterministic mechanism for avoiding a permanent hang on
+            // incomplete input. This watchdog only matters if some other,
+            // unanticipated input shape defeats both the sentinel and the
+            // buffered-command check; it should not fire in normal use.
+            this.watchdog = setTimeout(() => {
+                this.server.clearBufferedCommand?.();
+                this.opts.onOutput('Error: eval timed out\n');
+                this.settle();
+            }, this.evalTimeoutMs);
+            this.watchdog.unref?.();
+            this.input.write(command + '\n');
+            // Give node:repl's readline two macrotask ticks to fully drain and
+            // process every line of the command just written (verified
+            // empirically sufficient on Node v26, including for multi-line
+            // commands where all of the processing actually happens
+            // synchronously within the input.write() call above), then check
+            // whether it's left holding an incomplete trailing statement.
+            setImmediate(() => setImmediate(() => this.checkForStuckIncompleteInput()));
+        });
+    }
+    close() {
+        this.closed = true;
+        // Resolve any eval() a caller might still be awaiting so shutdown
+        // never leaves it hanging.
+        this.settle();
+        this.input.end();
+        this.input.destroy();
+        this.server.close();
+    }
+}
+exports.ReplSession = ReplSession;

package/dist/ui/repl-ui.html.d.ts

@@ -0,0 +1 @@
+export declare function renderReplUi(channel: string): string;

package/dist/ui/repl-ui.html.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderReplUi = renderReplUi;
+function renderReplUi(channel) {
+    const safe = channel.replace(/[<>"'&]/g, '');
+    // Escapes the channel for safe embedding inside the inline <script> block
+    // below. JSON.stringify alone does NOT escape "</script>" or the U+2028/
+    // U+2029 line separators, so an attacker-controlled channel like
+    // "</script><script>alert(1)</script>" (a URL path segment) would close
+    // the script tag early and inject markup the HTML parser executes.
+    // Escaping "<" to "<" inside the JS string literal preserves the
+    // exact value ("<" IS "<" once JS parses the literal) while ensuring the
+    // HTML parser -- which tokenizes the raw bytes before any JS runs --
+    // never sees a literal "</script>" sequence.
+    const channelLiteral = JSON.stringify(channel)
+        .replace(/</g, '\\u003c')
+        .replace(/[\u2028\u2029]/g, (ch) => (ch === '\u2028' ? '\\u2028' : '\\u2029'));
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>REPL: ${safe}</title>
+<style>
+  html,body{height:100%;margin:0;font-family:ui-monospace,Menlo,Consolas,monospace;background:#1e1e1e;color:#ddd}
+  #app{display:flex;flex-direction:column;height:100vh}
+  #out{flex:1;overflow:auto;padding:10px;white-space:pre-wrap;font-size:13px;line-height:1.4}
+  #out .cmd{color:#4ec9b0}#out .sys{color:#888}#out .err{color:#f14c4c}
+  #editor{height:32%;border-top:1px solid #333}
+  #bar{display:flex;gap:12px;align-items:center;padding:6px 10px;background:#252526;font-size:12px;border-top:1px solid #333}
+  #bar .dot{width:8px;height:8px;border-radius:50%;background:#666;display:inline-block;margin-right:4px}
+  #bar .dot.on{background:#3fb950}
+  button{background:#0e639c;color:#fff;border:0;padding:4px 12px;border-radius:3px;cursor:pointer}
+</style>
+</head>
+<body>
+<div id="app">
+  <div id="out"></div>
+  <div id="editor"></div>
+  <div id="bar">
+    <span><span id="dot" class="dot"></span><span id="state">connecting…</span></span>
+    <span>channel: <b>${safe}</b></span>
+    <span id="owner"></span>
+    <span style="margin-left:auto"><button id="run">Run ▶ (Ctrl+Enter)</button></span>
+  </div>
+</div>
+<script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.52.0/min/vs/loader.js"></script>
+<script>
+  const channel = ${channelLiteral};
+  const channelPath = encodeURIComponent(channel);
+  const out = document.getElementById('out');
+  const stateEl = document.getElementById('state');
+  const dot = document.getElementById('dot');
+  const ownerEl = document.getElementById('owner');
+  function append(text, cls){ const d=document.createElement('div'); if(cls)d.className=cls; d.textContent=text; out.appendChild(d); out.scrollTop=out.scrollHeight; }
+  function appendInline(text, cls){
+    let last = out.lastElementChild;
+    if(!last || last.dataset.kind !== 'output' || cls){
+      last = document.createElement('div');
+      last.dataset.kind = 'output';
+      if(cls) last.className = cls;
+      out.appendChild(last);
+    }
+    last.textContent += text;
+    out.scrollTop = out.scrollHeight;
+  }
+
+  const es = new EventSource('../' + channelPath);
+  es.onopen = () => { dot.classList.add('on'); stateEl.textContent='connected'; };
+  es.onerror = () => { dot.classList.remove('on'); stateEl.textContent='reconnecting…'; };
+  es.onmessage = (m) => {
+    const ev = JSON.parse(m.data);
+    if(ev.type==='command'){
+      // data: { command, instanceId }
+      append('> ' + ev.data.command, 'cmd');
+      if(ev.data && ev.data.instanceId) ownerEl.textContent='owner: '+ev.data.instanceId;
+    }
+    else if(ev.type==='output'){
+      // data is a raw string chunk, not { chunk }
+      appendInline(String(ev.data));
+    }
+    else if(ev.type==='system'){
+      const data = ev.data || {};
+      if(data.ping){
+        // heartbeat, id:0 -- render nothing
+        return;
+      }
+      if(data.done){
+        // command finished -- not rendered as noise
+        return;
+      }
+      if(typeof data.error === 'string'){
+        append('! ' + data.error, 'err');
+        return;
+      }
+      // other system notices (e.g. ownership info) -- render dim
+      append('[' + JSON.stringify(data) + ']', 'sys');
+      if(data.instanceId) ownerEl.textContent='owner: '+data.instanceId;
+    }
+  };
+
+  let editor;
+  require.config({ paths: { vs: 'https://cdn.jsdelivr.net/npm/monaco-editor@0.52.0/min/vs' }});
+  require(['vs/editor/editor.main'], function(){
+    editor = monaco.editor.create(document.getElementById('editor'), {
+      value: '', language: 'typescript', theme: 'vs-dark', minimap:{enabled:false}, automaticLayout:true
+    });
+    editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter, run);
+  });
+  async function run(){
+    const command = editor.getValue().trim();
+    if(!command) return;
+    editor.setValue('');
+    await fetch('../' + channelPath, { method:'POST', headers:{'content-type':'application/json'}, body: JSON.stringify({ command }) });
+  }
+  document.getElementById('run').addEventListener('click', run);
+</script>
+</body>
+</html>`;
+}

package/dist/web-repl.controller.d.ts

@@ -0,0 +1,19 @@
+import { type MessageEvent } from '@nestjs/common';
+import { type Observable } from 'rxjs';
+import type { WebReplModuleOptions } from './interfaces/web-repl-options.interface';
+import type { WebReplEvent } from './interfaces/web-repl-messages.interface';
+import { WebReplService } from './web-repl.service';
+export declare function toSseFrame(event: WebReplEvent, lastRealId: number): MessageEvent;
+export declare class WebReplController {
+    protected readonly service: WebReplService;
+    private readonly options;
+    constructor(service: WebReplService, options: WebReplModuleOptions);
+    dispatch(channel: string, body: {
+        command?: unknown;
+    }): Promise<{
+        accepted: true;
+        commandId: string;
+    }>;
+    stream(channel: string, lastEventId?: string): Observable<MessageEvent>;
+    ui(channel: string): string;
+}

package/dist/web-repl.controller.js

@@ -0,0 +1,121 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebReplController = void 0;
+exports.toSseFrame = toSseFrame;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const constants_1 = require("./constants");
+const web_repl_service_1 = require("./web-repl.service");
+const repl_ui_html_1 = require("./ui/repl-ui.html");
+// IMPORTANT 2: the heartbeat is emitted as a real WebReplEvent with the
+// sentinel `id: 0`. Per the SSE spec, any non-null `id` field (including
+// "0") overwrites the browser EventSource's last-event-id -- so if every
+// heartbeat carried `id: "0"`, almost any reconnect after an idle period
+// would send `Last-Event-ID: 0`, and EventRingBuffer.since(0) returns the
+// entire buffer, defeating replay dedup.
+//
+// NOTE: this can't be fixed by simply *omitting* `id` from the MessageEvent
+// -- @nestjs/core's SseStream.writeMessage() auto-assigns its own
+// monotonically increasing id to any message whose `id` is undefined/null
+// (see node_modules/@nestjs/core/router/sse-stream.js), so an "omitted" id
+// still lands on the wire as a small, framework-generated counter value
+// that is just as disconnected from real event ids as the "0" sentinel
+// was -- reproducing the same "reconnect replays everything" bug through a
+// different number. Instead, stamp every heartbeat with the id of the
+// *last real event this connection has actually sent* (or the client's
+// original Last-Event-ID cursor if none has been sent yet on this
+// connection). Per the SSE spec, receiving an id equal to the one the
+// client already has is a no-op for its reconnection cursor, so heartbeats
+// stop perturbing Last-Event-ID once at least one real event has flowed.
+// Exported as a pure function so it's directly unit-testable without
+// asserting on raw SSE wire text.
+function toSseFrame(event, lastRealId) {
+    const id = event.id === 0 ? lastRealId : event.id;
+    return { id: String(id), type: 'message', data: JSON.stringify(event) };
+}
+let WebReplController = class WebReplController {
+    constructor(service, options) {
+        this.service = service;
+        this.options = options;
+    }
+    async dispatch(channel, body) {
+        // CRITICAL: forRootAsync always registers this controller regardless
+        // of the resolved `enabled` value (providers/controllers must be
+        // declared statically before useFactory ever runs). Re-check at
+        // request time so a disabled async module 404s on every route, just
+        // like the sync forRoot(enabled: false) path that registers nothing.
+        if (!this.options.enabled)
+            throw new common_1.NotFoundException();
+        if (typeof body?.command !== 'string' || body.command.trim().length === 0) {
+            throw new common_1.BadRequestException('command must be a non-empty string');
+        }
+        const { commandId } = await this.service.dispatch(channel, body.command);
+        return { accepted: true, commandId };
+    }
+    stream(channel, lastEventId) {
+        if (!this.options.enabled)
+            throw new common_1.NotFoundException();
+        const parsed = lastEventId ? Number(lastEventId) : null;
+        const cursor = Number.isNaN(parsed) ? null : parsed;
+        // Tracks the id of the last real (non-heartbeat) event sent on THIS
+        // connection, so heartbeats can be stamped with it instead of the "0"
+        // sentinel -- see toSseFrame() above. Seeded from the client's own
+        // reconnect cursor (or 0, meaning "nothing yet") so a heartbeat fired
+        // before any real event still reports a harmless/idempotent id.
+        let lastRealId = cursor ?? 0;
+        return this.service.stream(channel, cursor).pipe((0, rxjs_1.map)((event) => {
+            const frame = toSseFrame(event, lastRealId);
+            if (event.id !== 0)
+                lastRealId = event.id;
+            return frame;
+        }));
+    }
+    ui(channel) {
+        if (!this.options.enabled)
+            throw new common_1.NotFoundException();
+        return (0, repl_ui_html_1.renderReplUi)(channel);
+    }
+};
+exports.WebReplController = WebReplController;
+__decorate([
+    (0, common_1.Post)(':channel'),
+    (0, common_1.HttpCode)(202),
+    __param(0, (0, common_1.Param)('channel')),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], WebReplController.prototype, "dispatch", null);
+__decorate([
+    (0, common_1.Sse)(':channel'),
+    __param(0, (0, common_1.Param)('channel')),
+    __param(1, (0, common_1.Headers)('last-event-id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Function)
+], WebReplController.prototype, "stream", null);
+__decorate([
+    (0, common_1.Get)(':channel/ui'),
+    (0, common_1.Header)('content-type', 'text/html'),
+    __param(0, (0, common_1.Param)('channel')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], WebReplController.prototype, "ui", null);
+exports.WebReplController = WebReplController = __decorate([
+    (0, common_1.Controller)('repl'),
+    __param(1, (0, common_1.Inject)(constants_1.WEB_REPL_OPTIONS)),
+    __metadata("design:paramtypes", [web_repl_service_1.WebReplService, Object])
+], WebReplController);

package/dist/web-repl.module.d.ts

@@ -0,0 +1,8 @@
+import { type DynamicModule } from '@nestjs/common';
+import type { WebReplModuleOptions, WebReplModuleAsyncOptions } from './interfaces/web-repl-options.interface';
+export declare class WebReplModule {
+    static forRoot(options: WebReplModuleOptions): DynamicModule;
+    static forRootAsync(async: WebReplModuleAsyncOptions): DynamicModule;
+    private static assemble;
+    private static sharedProviders;
+}