@zhanguym/chatroom 1.1.0 → 1.2.0-beta.0

package/dist/plugins/cloud/v2/stream.js

@@ -0,0 +1,156 @@
+/** Tunnel V2 framing, independent of Node.js, WebSocket and WebRTC. */
+export const V2_PROTOCOL = "chatroom-tunnel-v2";
+export const DATA_SIZE = 16 * 1024;
+export const INITIAL_CREDIT = 256 * 1024;
+export const MAX_META = 64 * 1024;
+export const MAX_QUEUED = 512 * 1024;
+export function encodeFrame(op, id, payload = new Uint8Array()) {
+    if (!Number.isSafeInteger(id) || id < 0 || id > 0xffff_ffff)
+        throw new Error("Invalid stream ID");
+    const frame = new Uint8Array(5 + payload.byteLength);
+    const view = new DataView(frame.buffer);
+    view.setUint8(0, op);
+    view.setUint32(1, id);
+    frame.set(payload, 5);
+    return frame;
+}
+export function decodeFrame(raw) {
+    if (raw.byteLength < 5)
+        throw new Error("Truncated V2 frame");
+    const view = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const op = view.getUint8(0);
+    if (op < 1 /* Op.OPEN */ || op > 6 /* Op.CREDIT */)
+        throw new Error("Unknown V2 operation");
+    const id = view.getUint32(1);
+    const payload = raw.subarray(5);
+    if (op === 3 /* Op.DATA */ &&
+        (payload.byteLength === 0 || payload.byteLength > DATA_SIZE))
+        throw new Error("Invalid DATA frame size");
+    if ([1 /* Op.OPEN */, 2 /* Op.META */, 5 /* Op.RESET */].includes(op) &&
+        payload.byteLength > MAX_META)
+        throw new Error("Metadata too large");
+    if (op === 6 /* Op.CREDIT */ &&
+        (payload.byteLength !== 4 || readCredit(payload) === 0))
+        throw new Error("Invalid credit");
+    if (op === 4 /* Op.FIN */ && payload.byteLength !== 0)
+        throw new Error("FIN must be empty");
+    if (id === 0 && op !== 2 /* Op.META */)
+        throw new Error("Reserved control stream");
+    return { op, id, payload };
+}
+export function readCredit(payload) {
+    return new DataView(payload.buffer, payload.byteOffset, payload.byteLength).getUint32(0);
+}
+export function creditFrame(id, amount) {
+    if (!Number.isInteger(amount) || amount < 1 || amount > 0xffff_ffff)
+        throw new Error("Invalid credit amount");
+    const payload = new Uint8Array(4);
+    new DataView(payload.buffer).setUint32(0, amount);
+    return encodeFrame(6 /* Op.CREDIT */, id, payload);
+}
+export class CreditSender {
+    id;
+    send;
+    pause;
+    resume;
+    onFinished;
+    canSend;
+    credit = INITIAL_CREDIT;
+    chunks = [];
+    queued = 0;
+    ending = false;
+    finished = false;
+    cancelled = false;
+    wakeup = null;
+    constructor(id, send, pause, resume, onFinished = () => { }, canSend = () => true) {
+        this.id = id;
+        this.send = send;
+        this.pause = pause;
+        this.resume = resume;
+        this.onFinished = onFinished;
+        this.canSend = canSend;
+    }
+    enqueue(chunk) {
+        if (this.cancelled ||
+            this.finished ||
+            this.ending ||
+            this.queued + chunk.byteLength > MAX_QUEUED)
+            throw new Error("V2 stream write overflow");
+        this.chunks.push(chunk);
+        this.queued += chunk.byteLength;
+        this.flush();
+    }
+    addCredit(amount) {
+        if (this.finished || this.cancelled)
+            return;
+        if (this.credit + amount > INITIAL_CREDIT)
+            throw new Error("Invalid V2 flow credit");
+        this.credit += amount;
+        this.flush();
+    }
+    end() {
+        if (this.cancelled)
+            return;
+        this.ending = true;
+        this.flush();
+    }
+    cancel() {
+        this.cancelled = true;
+        if (this.wakeup)
+            clearTimeout(this.wakeup);
+        this.wakeup = null;
+        this.chunks.length = 0;
+        this.queued = 0;
+    }
+    /** Called when the physical transport signals that its send buffer drained. */
+    writable() {
+        if (this.wakeup) {
+            clearTimeout(this.wakeup);
+            this.wakeup = null;
+        }
+        this.flush();
+    }
+    flush() {
+        if (this.cancelled)
+            return;
+        while (this.credit > 0 && this.chunks.length && this.canSend()) {
+            const current = this.chunks[0];
+            const length = Math.min(DATA_SIZE, this.credit, current.byteLength);
+            this.send(encodeFrame(3 /* Op.DATA */, this.id, current.subarray(0, length)));
+            this.credit -= length;
+            this.queued -= length;
+            if (length === current.byteLength)
+                this.chunks.shift();
+            else
+                this.chunks[0] = current.subarray(length);
+        }
+        if (this.chunks.length) {
+            this.pause();
+            if (this.credit && !this.canSend() && !this.wakeup) {
+                this.wakeup = setTimeout(() => {
+                    this.wakeup = null;
+                    this.flush();
+                }, 10);
+            }
+        }
+        else {
+            this.resume();
+            if (this.ending && !this.finished) {
+                this.finished = true;
+                this.send(encodeFrame(4 /* Op.FIN */, this.id));
+                this.onFinished();
+            }
+        }
+    }
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export function parseMeta(payload) {
+    return JSON.parse(decoder.decode(payload));
+}
+export function metaFrame(op, id, value) {
+    const encoded = encoder.encode(JSON.stringify(value));
+    if (encoded.byteLength > MAX_META)
+        throw new Error("V2 metadata too large");
+    return encodeFrame(op, id, encoded);
+}

package/dist/plugins/cloud/v2/tunnel-client.d.ts

@@ -0,0 +1,45 @@
+import { type CloudLeaseState } from "../types.js";
+export declare class V2TunnelClient {
+    private lease;
+    private readonly identity;
+    private readonly local;
+    private readonly callbacks;
+    private socket;
+    private reconnectTimer;
+    private readyTimer;
+    private heartbeatTimer;
+    private awaitingPong;
+    private stopped;
+    private attempts;
+    private closeWhenIdle;
+    private acceptingServices;
+    private readonly streams;
+    constructor(lease: CloudLeaseState, identity: {
+        devicePrivateKey: string;
+    }, local: {
+        host: string;
+        port: number;
+    }, callbacks: {
+        onConnected(): void;
+        onDisconnected(): void;
+        onLeaseRejected(): void;
+        onError(error: Error): void;
+    });
+    start(): void;
+    stop(): void;
+    drainAndStop(): void;
+    updateLease(lease: CloudLeaseState): void;
+    private connect;
+    private handleFrame;
+    private refund;
+    private finishIfIdle;
+    private abort;
+    private send;
+    private checkDrain;
+    private destroyStreams;
+    private clearReadyTimer;
+    private clearTimers;
+    private startHeartbeat;
+    private fail;
+    private scheduleReconnect;
+}

package/dist/plugins/cloud/v2/tunnel-client.js

@@ -0,0 +1,426 @@
+import { createPrivateKey, sign } from "node:crypto";
+import http from "node:http";
+import WebSocket from "ws";
+import { z } from "zod";
+import { CreditSender, INITIAL_CREDIT, creditFrame, decodeFrame, metaFrame, parseMeta, readCredit, V2_PROTOCOL, } from "./stream.js";
+import { cloudServiceForPublicService, } from "../types.js";
+const openSchema = z
+    .object({
+    service: z.enum(["mcp", "web"]),
+    method: z.string().min(1),
+    path: z.string().startsWith("/"),
+    headers: z.record(z.string(), z.string()),
+})
+    .strict();
+const controlSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("challenge"), nonce: z.string().min(1) }).strict(),
+    z.object({ type: z.literal("ready") }).strict(),
+]);
+export class V2TunnelClient {
+    lease;
+    identity;
+    local;
+    callbacks;
+    socket = null;
+    reconnectTimer = null;
+    readyTimer = null;
+    heartbeatTimer = null;
+    awaitingPong = false;
+    stopped = true;
+    attempts = 0;
+    closeWhenIdle = null;
+    acceptingServices;
+    streams = new Map();
+    constructor(lease, identity, local, callbacks) {
+        this.lease = lease;
+        this.identity = identity;
+        this.local = local;
+        this.callbacks = callbacks;
+        this.acceptingServices = new Set(lease.services);
+    }
+    start() {
+        if (!this.stopped)
+            return;
+        this.stopped = false;
+        this.closeWhenIdle = null;
+        this.acceptingServices = new Set(this.lease.services);
+        this.connect();
+    }
+    stop() {
+        this.stopped = true;
+        this.closeWhenIdle = null;
+        this.acceptingServices.clear();
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        this.clearTimers();
+        this.socket?.close();
+        this.socket = null;
+        this.destroyStreams();
+    }
+    drainAndStop() {
+        this.stopped = true;
+        this.acceptingServices.clear();
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        this.clearTimers();
+        if (!this.streams.size)
+            this.socket?.close();
+        else
+            this.closeWhenIdle = "stop";
+    }
+    updateLease(lease) {
+        const changed = lease.tunnelUrl !== this.lease.tunnelUrl;
+        const removes = this.lease.services.some((service) => !lease.services.includes(service));
+        this.lease = lease;
+        this.acceptingServices = new Set(lease.services);
+        if (this.stopped)
+            return;
+        if (!changed) {
+            this.send(metaFrame(2 /* Op.META */, 0, { type: "update-lease", lease: lease.token }));
+            return;
+        }
+        if (!removes || !this.streams.size)
+            this.socket?.close();
+        else
+            this.closeWhenIdle = "reconnect";
+    }
+    connect() {
+        if (this.stopped || this.socket)
+            return;
+        const socket = new WebSocket(this.lease.tunnelUrl, V2_PROTOCOL);
+        this.socket = socket;
+        let ready = false;
+        this.readyTimer = setTimeout(() => this.fail(socket, new Error("V2 handshake timed out")), 10000);
+        this.readyTimer.unref();
+        socket.on("unexpected-response", (_request, response) => {
+            const error = response.statusCode === 426
+                ? new Error("Cloud Server does not support Tunnel V2; upgrade the server")
+                : new Error("Tunnel V2 handshake rejected: " + response.statusCode);
+            response.resume();
+            this.callbacks.onError(error);
+            this.stop();
+            socket.terminate();
+        });
+        socket.on("open", () => {
+            if (socket.protocol !== V2_PROTOCOL)
+                this.fail(socket, new Error("Unexpected V2 subprotocol"));
+        });
+        socket.on("message", (raw, binary) => {
+            try {
+                if (socket !== this.socket)
+                    return;
+                if (ready) {
+                    if (!binary)
+                        throw new Error("V2 requires binary frames");
+                    this.handleFrame(toBuffer(raw));
+                    return;
+                }
+                if (binary)
+                    throw new Error("Unexpected binary handshake");
+                const message = controlSchema.parse(JSON.parse(raw.toString()));
+                if (message.type === "challenge") {
+                    socket.send(JSON.stringify({
+                        type: "authenticate",
+                        lease: this.lease.token,
+                        signature: signChallenge(message.nonce, this.lease.token, this.identity.devicePrivateKey),
+                    }));
+                }
+                else {
+                    ready = true;
+                    this.attempts = 0;
+                    this.clearReadyTimer();
+                    this.startHeartbeat(socket);
+                    this.callbacks.onConnected();
+                }
+            }
+            catch (error) {
+                this.callbacks.onError(error instanceof Error ? error : new Error(String(error)));
+                socket.close(4002, "Invalid V2 message");
+            }
+        });
+        socket.on("pong", () => {
+            if (this.socket === socket)
+                this.awaitingPong = false;
+        });
+        socket.on("close", (code) => {
+            if (this.socket === socket) {
+                this.clearTimers();
+                this.socket = null;
+            }
+            this.closeWhenIdle = null;
+            this.destroyStreams();
+            this.callbacks.onDisconnected();
+            if (this.stopped)
+                return;
+            if (code === 4003) {
+                this.stopped = true;
+                this.callbacks.onLeaseRejected();
+                return;
+            }
+            this.scheduleReconnect();
+        });
+        socket.on("error", (error) => {
+            this.fail(socket, error);
+        });
+    }
+    handleFrame(raw) {
+        const frame = decodeFrame(raw);
+        if (!frame.id)
+            throw new Error("Invalid server control frame");
+        if (frame.op === 1 /* Op.OPEN */) {
+            const meta = openSchema.parse(parseMeta(frame.payload));
+            if (this.streams.has(frame.id))
+                throw new Error("Duplicate stream");
+            if (this.streams.size >= 256 ||
+                !this.acceptingServices.has(cloudServiceForPublicService(meta.service)) ||
+                !allowedPath(meta.service, meta.path)) {
+                this.send(metaFrame(5 /* Op.RESET */, frame.id, { reason: "not_allowed" }));
+                return;
+            }
+            const headers = {
+                ...meta.headers,
+                host: publicHost(this.lease, meta.service),
+            };
+            const request = http.request({
+                host: this.local.host,
+                port: this.local.port,
+                method: meta.method,
+                path: meta.path,
+                headers,
+            }, (response) => {
+                const state = this.streams.get(frame.id);
+                if (!state) {
+                    response.destroy();
+                    return;
+                }
+                state.response = response;
+                const sender = new CreditSender(frame.id, (buffer) => this.send(buffer), () => response.pause(), () => response.resume(), () => {
+                    state.responseEnded = true;
+                    this.finishIfIdle(frame.id);
+                });
+                state.sender = sender;
+                this.send(metaFrame(2 /* Op.META */, frame.id, {
+                    status: response.statusCode ?? 502,
+                    headers: responseHeaders(response.headers),
+                }));
+                response.on("data", (chunk) => {
+                    state.responseBytes += chunk.length;
+                    if (state.responseBytes > 128 * 1024 * 1024) {
+                        this.abort(frame.id);
+                        return;
+                    }
+                    try {
+                        sender.enqueue(chunk);
+                    }
+                    catch {
+                        this.abort(frame.id);
+                    }
+                });
+                response.on("end", () => {
+                    sender.end();
+                    this.finishIfIdle(frame.id);
+                });
+                response.on("error", () => this.abort(frame.id));
+            });
+            const state = {
+                request,
+                response: null,
+                sender: null,
+                receiveCredit: INITIAL_CREDIT,
+                pendingCredit: 0,
+                drainArmed: false,
+                requestBytes: 0,
+                responseBytes: 0,
+                requestEnded: false,
+                responseEnded: false,
+            };
+            this.streams.set(frame.id, state);
+            request.on("error", () => {
+                if (this.streams.has(frame.id))
+                    this.abort(frame.id);
+            });
+            return;
+        }
+        const state = this.streams.get(frame.id);
+        if (!state)
+            return;
+        switch (frame.op) {
+            case 3 /* Op.DATA */: {
+                state.receiveCredit -= frame.payload.length;
+                state.requestBytes += frame.payload.length;
+                if (state.receiveCredit < 0 || state.requestBytes > 32 * 1024 * 1024) {
+                    this.abort(frame.id);
+                    return;
+                }
+                if (state.request.write(frame.payload))
+                    this.refund(frame.id, state, frame.payload.length);
+                else {
+                    state.pendingCredit += frame.payload.length;
+                    if (!state.drainArmed) {
+                        state.drainArmed = true;
+                        state.request.once("drain", () => {
+                            state.drainArmed = false;
+                            if (!this.streams.has(frame.id))
+                                return;
+                            this.refund(frame.id, state, state.pendingCredit);
+                            state.pendingCredit = 0;
+                        });
+                    }
+                }
+                break;
+            }
+            case 4 /* Op.FIN */:
+                state.request.end();
+                state.requestEnded = true;
+                this.finishIfIdle(frame.id);
+                break;
+            case 5 /* Op.RESET */:
+                state.sender?.cancel();
+                state.request.destroy();
+                state.response?.destroy();
+                this.streams.delete(frame.id);
+                this.checkDrain();
+                break;
+            case 6 /* Op.CREDIT */:
+                state.sender?.addCredit(readCredit(frame.payload));
+                break;
+            default:
+                throw new Error("Unexpected V2 operation");
+        }
+    }
+    refund(id, state, amount) {
+        if (!amount)
+            return;
+        state.receiveCredit += amount;
+        this.send(creditFrame(id, amount));
+    }
+    finishIfIdle(id) {
+        const state = this.streams.get(id);
+        if (!state || !state.requestEnded || !state.responseEnded)
+            return;
+        this.streams.delete(id);
+        this.checkDrain();
+    }
+    abort(id) {
+        const state = this.streams.get(id);
+        if (!state)
+            return;
+        this.streams.delete(id);
+        state.sender?.cancel();
+        state.request.destroy();
+        state.response?.destroy();
+        this.send(metaFrame(5 /* Op.RESET */, id, { reason: "local_failure" }));
+        this.checkDrain();
+    }
+    send(buffer) {
+        if (this.socket?.readyState !== WebSocket.OPEN)
+            return;
+        if (this.socket.bufferedAmount > 8 * 1024 * 1024) {
+            this.socket.terminate();
+            return;
+        }
+        this.socket.send(buffer, { binary: true });
+    }
+    checkDrain() {
+        if (this.streams.size || !this.closeWhenIdle)
+            return;
+        this.socket?.close();
+    }
+    destroyStreams() {
+        for (const state of this.streams.values()) {
+            state.sender?.cancel();
+            state.request.destroy();
+            state.response?.destroy();
+        }
+        this.streams.clear();
+    }
+    clearReadyTimer() {
+        if (this.readyTimer)
+            clearTimeout(this.readyTimer);
+        this.readyTimer = null;
+    }
+    clearTimers() {
+        this.clearReadyTimer();
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+        this.awaitingPong = false;
+    }
+    startHeartbeat(socket) {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = setInterval(() => {
+            if (this.socket !== socket || socket.readyState !== WebSocket.OPEN)
+                return;
+            if (this.awaitingPong) {
+                this.fail(socket, new Error("V2 heartbeat timed out"));
+                return;
+            }
+            this.awaitingPong = true;
+            socket.ping();
+        }, 20000);
+        this.heartbeatTimer.unref();
+    }
+    fail(socket, error) {
+        if (this.socket !== socket)
+            return;
+        this.callbacks.onError(error);
+        this.clearTimers();
+        this.socket = null;
+        socket.terminate();
+    }
+    scheduleReconnect() {
+        if (this.stopped || this.reconnectTimer)
+            return;
+        const delay = Math.min(30000, 500 * 2 ** Math.min(this.attempts++, 6)) *
+            (0.8 + Math.random() * 0.4);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay);
+        this.reconnectTimer.unref();
+    }
+}
+function toBuffer(raw) {
+    return Buffer.isBuffer(raw)
+        ? raw
+        : Array.isArray(raw)
+            ? Buffer.concat(raw)
+            : Buffer.from(raw);
+}
+function signChallenge(nonce, lease, privateKey) {
+    const key = createPrivateKey({
+        key: Buffer.from(privateKey, "base64url"),
+        format: "der",
+        type: "pkcs8",
+    });
+    return sign(null, Buffer.from(`${V2_PROTOCOL}\n${nonce}\n${lease}`), key).toString("base64url");
+}
+function publicHost(lease, service) {
+    const base = service === "mcp" ? lease.mcpBaseUrl : lease.webBaseUrl;
+    if (!base)
+        throw new Error("Missing public URL");
+    return new URL(base).host;
+}
+function allowedPath(service, path) {
+    const p = new URL(path, "http://localhost").pathname.toLowerCase();
+    const mcp = p === "/mcp" || p.startsWith("/mcp/");
+    const oauth = p.startsWith("/oauth/") || p.startsWith("/.well-known/oauth-");
+    return service === "mcp" ? mcp || oauth : !mcp && !oauth;
+}
+function responseHeaders(headers) {
+    const blocked = new Set([
+        "connection",
+        "keep-alive",
+        "transfer-encoding",
+        "upgrade",
+    ]);
+    return Object.fromEntries(Object.entries(headers)
+        .filter(([key, value]) => value !== undefined && !blocked.has(key.toLowerCase()))
+        .map(([key, value]) => [
+        key,
+        Array.isArray(value) ? value.join(", ") : String(value),
+    ]));
+}

package/dist/plugins/process/backend.d.ts

@@ -1,6 +1,7 @@
 export interface BackendProcess {
     readonly pid: number | null;
     write(data: string): void;
+    resize?(cols: number, rows: number): void;
     kill(signal?: NodeJS.Signals): void;
     onStdout(listener: (chunk: Buffer) => void): void;
     onStderr(listener: (chunk: Buffer) => void): void;
@@ -14,5 +15,7 @@ export interface ProcessBackend {
     start(command: string, args: string[], options: {
         cwd: string;
         env: NodeJS.ProcessEnv;
+        cols?: number;
+        rows?: number;
     }): Promise<BackendProcess>;
 }

package/dist/plugins/process/infrastructure/pty-process-backend.d.ts

@@ -4,5 +4,7 @@ export declare class PtyProcessBackend implements ProcessBackend {
     start(command: string, args: string[], options: {
         cwd: string;
         env: NodeJS.ProcessEnv;
+        cols?: number;
+        rows?: number;
     }): Promise<BackendProcess>;
 }

package/dist/plugins/process/infrastructure/pty-process-backend.js

@@ -12,8 +12,8 @@ export class PtyProcessBackend {
         const env = Object.fromEntries(Object.entries(options.env).filter((entry) => typeof entry[1] === "string"));
         const processHandle = pty.spawn(command, args, {
             name: env.TERM ?? "xterm-256color",
-            cols: 120,
-            rows: 30,
+            cols: options.cols ?? 120,
+            rows: options.rows ?? 30,
             cwd: options.cwd,
             env,
         });
@@ -31,6 +31,9 @@ class PtyBackendProcess {
     write(data) {
         this.processHandle.write(data);
     }
+    resize(cols, rows) {
+        this.processHandle.resize(cols, rows);
+    }
     kill(signal = "SIGTERM") {
         if (process.platform === "win32") {
             this.processHandle.kill();

package/dist/plugins/process/infrastructure/terminal-shell.d.ts

@@ -0,0 +1,4 @@
+/** Select the OS default interactive shell for a local terminal session. */
+export declare function defaultTerminalShell(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
+/** macOS Terminal starts an interactive login shell; match its PATH initialization. */
+export declare function defaultTerminalArgs(platform?: NodeJS.Platform): string[];

package/dist/plugins/process/infrastructure/terminal-shell.js

@@ -0,0 +1,10 @@
+/** Select the OS default interactive shell for a local terminal session. */
+export function defaultTerminalShell(platform = process.platform, env = process.env) {
+    return platform === "win32"
+        ? env.ComSpec || env.COMSPEC || "cmd.exe"
+        : env.SHELL || "/bin/sh";
+}
+/** macOS Terminal starts an interactive login shell; match its PATH initialization. */
+export function defaultTerminalArgs(platform = process.platform) {
+    return platform === "darwin" ? ["-l"] : [];
+}