@chatroomcp/chatroom 0.1.3

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

@@ -0,0 +1,293 @@
+import { createPrivateKey, sign } from "node:crypto";
+import http from "node:http";
+import WebSocket from "ws";
+import { cloudServiceForPublicService, } from "./types.js";
+const PROTOCOL = "chatroom-tunnel-v1";
+const HIGH_WATER = 8 * 1024 * 1024;
+const LOW_WATER = 2 * 1024 * 1024;
+export class CloudTunnelClient {
+    lease;
+    identity;
+    local;
+    callbacks;
+    socket = null;
+    reconnectTimer = null;
+    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.socket?.close();
+        this.socket = null;
+        for (const stream of this.streams.values())
+            stream.request.destroy();
+        this.streams.clear();
+    }
+    drainAndStop() {
+        this.stopped = true;
+        this.acceptingServices.clear();
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        if (this.streams.size === 0) {
+            this.closeWhenIdle = null;
+            this.socket?.close();
+            return;
+        }
+        this.closeWhenIdle = "stop";
+    }
+    updateLease(lease) {
+        const previousServices = this.lease.services;
+        const reconnect = lease.token !== this.lease.token ||
+            lease.tunnelUrl !== this.lease.tunnelUrl;
+        const removesService = previousServices.some((service) => !lease.services.includes(service));
+        this.lease = lease;
+        this.acceptingServices = new Set(lease.services);
+        if (!reconnect || this.stopped)
+            return;
+        if (!removesService || this.streams.size === 0) {
+            this.socket?.close();
+            return;
+        }
+        this.closeWhenIdle = "reconnect";
+    }
+    connect() {
+        if (this.stopped || this.socket)
+            return;
+        const socket = new WebSocket(this.lease.tunnelUrl, PROTOCOL);
+        this.socket = socket;
+        socket.binaryType = "nodebuffer";
+        socket.on("message", (data, isBinary) => {
+            try {
+                if (isBinary)
+                    this.handleBinary(Buffer.from(data));
+                else
+                    this.handleControl(JSON.parse(data.toString()));
+            }
+            catch (error) {
+                this.callbacks.onError(error instanceof Error ? error : new Error(String(error)));
+                socket.close();
+            }
+        });
+        socket.on("close", () => {
+            if (this.socket === socket)
+                this.socket = null;
+            this.closeWhenIdle = null;
+            for (const stream of this.streams.values())
+                stream.request.destroy();
+            this.streams.clear();
+            this.callbacks.onDisconnected();
+            if (!this.stopped)
+                this.scheduleReconnect();
+        });
+        socket.on("error", (error) => this.callbacks.onError(error));
+    }
+    handleControl(message) {
+        if (message.type === "challenge") {
+            this.send({
+                type: "authenticate",
+                lease: this.lease.token,
+                signature: signChallenge(message.nonce, this.lease.token, this.identity.devicePrivateKey),
+            });
+            return;
+        }
+        if (message.type === "ready") {
+            this.attempts = 0;
+            this.callbacks.onConnected();
+            return;
+        }
+        if (message.type === "open") {
+            this.openStream(message);
+            return;
+        }
+        const stream = this.streams.get(message.streamId);
+        if (!stream)
+            return;
+        if (message.type === "end")
+            stream.request.end();
+        else if (message.type === "abort") {
+            stream.request.destroy();
+            stream.response?.destroy();
+            this.finishStream(message.streamId);
+        }
+        else if (message.type === "pause")
+            stream.response?.pause();
+        else if (message.type === "resume")
+            stream.response?.resume();
+    }
+    openStream(message) {
+        const service = cloudServiceForPublicService(message.service);
+        if (!this.acceptingServices.has(service) ||
+            !allowedPath(message.service, message.path)) {
+            this.send({
+                type: "response",
+                streamId: message.streamId,
+                status: 404,
+                headers: { "content-type": "text/plain" },
+            });
+            this.send({ type: "response-end", streamId: message.streamId });
+            return;
+        }
+        const headers = sanitizeHeaders(message.headers);
+        const request = http.request({
+            host: this.local.host,
+            port: this.local.port,
+            method: message.method,
+            path: message.path,
+            headers,
+        }, (response) => {
+            const stream = this.streams.get(message.streamId);
+            if (stream)
+                stream.response = response;
+            this.send({
+                type: "response",
+                streamId: message.streamId,
+                status: response.statusCode ?? 502,
+                headers: responseHeaders(response.headers),
+            });
+            response.on("data", (chunk) => {
+                if (!this.sendBinary(message.streamId, Buffer.from(chunk))) {
+                    response.pause();
+                    const timer = setInterval(() => {
+                        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+                            clearInterval(timer);
+                            return;
+                        }
+                        if (this.socket.bufferedAmount <= LOW_WATER) {
+                            clearInterval(timer);
+                            response.resume();
+                        }
+                    }, 10);
+                    timer.unref();
+                }
+            });
+            response.on("end", () => {
+                this.send({ type: "response-end", streamId: message.streamId });
+                this.finishStream(message.streamId);
+            });
+            response.on("error", () => {
+                this.send({ type: "abort", streamId: message.streamId });
+                this.finishStream(message.streamId);
+            });
+        });
+        request.on("drain", () => this.send({ type: "resume", streamId: message.streamId }));
+        request.on("error", () => {
+            this.send({
+                type: "response",
+                streamId: message.streamId,
+                status: 502,
+                headers: {},
+            });
+            this.send({ type: "response-end", streamId: message.streamId });
+            this.finishStream(message.streamId);
+        });
+        this.streams.set(message.streamId, { request, response: null });
+    }
+    finishStream(streamId) {
+        this.streams.delete(streamId);
+        if (this.streams.size !== 0 || !this.closeWhenIdle)
+            return;
+        const action = this.closeWhenIdle;
+        this.closeWhenIdle = null;
+        if (action === "stop") {
+            this.socket?.close();
+            return;
+        }
+        this.socket?.close();
+    }
+    handleBinary(frame) {
+        if (frame.length < 4)
+            throw new Error("Invalid tunnel data frame");
+        const streamId = frame.readUInt32BE(0);
+        const stream = this.streams.get(streamId);
+        if (!stream)
+            return;
+        if (!stream.request.write(frame.subarray(4)))
+            this.send({ type: "pause", streamId });
+    }
+    send(message) {
+        if (this.socket?.readyState === WebSocket.OPEN)
+            this.socket.send(JSON.stringify(message));
+    }
+    sendBinary(streamId, chunk) {
+        const socket = this.socket;
+        if (!socket || socket.readyState !== WebSocket.OPEN)
+            return false;
+        const frame = Buffer.allocUnsafe(4 + chunk.length);
+        frame.writeUInt32BE(streamId, 0);
+        chunk.copy(frame, 4);
+        socket.send(frame, { binary: true });
+        return socket.bufferedAmount < HIGH_WATER;
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer || this.stopped)
+            return;
+        const delay = Math.min(30_000, 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 signChallenge(nonce, lease, privateKey) {
+    const key = createPrivateKey({
+        key: Buffer.from(privateKey, "base64url"),
+        format: "der",
+        type: "pkcs8",
+    });
+    return sign(null, Buffer.from(`chatroom-tunnel-v1\n${nonce}\n${lease}`), key).toString("base64url");
+}
+function allowedPath(service, value) {
+    const pathname = new URL(value, "http://localhost").pathname;
+    if (service === "mcp")
+        return (pathname === "/mcp" ||
+            pathname.startsWith("/.well-known/oauth-") ||
+            pathname.startsWith("/oauth/"));
+    return (pathname !== "/mcp" &&
+        !pathname.startsWith("/oauth/") &&
+        !pathname.startsWith("/.well-known/oauth-"));
+}
+function sanitizeHeaders(headers) {
+    const blocked = new Set([
+        "connection",
+        "proxy-connection",
+        "keep-alive",
+        "transfer-encoding",
+        "upgrade",
+    ]);
+    return Object.fromEntries(Object.entries(headers).filter(([key]) => !blocked.has(key.toLowerCase())));
+}
+function responseHeaders(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined ||
+            ["connection", "keep-alive", "transfer-encoding", "upgrade"].includes(key.toLowerCase()))
+            continue;
+        result[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    return result;
+}

package/dist/plugins/cloud/types.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export declare const CLOUD_SERVICES: readonly ["remote_mcp", "remote_web"];
+export declare const CLOUD_SERVICE_SCHEMA: z.ZodEnum<{
+    remote_mcp: "remote_mcp";
+    remote_web: "remote_web";
+}>;
+export type CloudServiceId = (typeof CLOUD_SERVICES)[number];
+declare const PUBLIC_SERVICE_TO_CLOUD_SERVICE: {
+    readonly mcp: "remote_mcp";
+    readonly web: "remote_web";
+};
+export type PublicService = keyof typeof PUBLIC_SERVICE_TO_CLOUD_SERVICE;
+export declare const CLOUD_DESIRED_SERVICES_SCHEMA: z.ZodObject<{
+    remote_mcp: z.ZodBoolean;
+    remote_web: z.ZodBoolean;
+}, z.core.$strict>;
+export declare function cloudServiceForPublicService(service: PublicService): CloudServiceId;
+export declare const CLOUD_ENTITLEMENT_SCHEMA: z.ZodObject<{
+    service: z.ZodEnum<{
+        remote_mcp: "remote_mcp";
+        remote_web: "remote_web";
+    }>;
+    status: z.ZodLiteral<"active">;
+    sourceProvider: z.ZodString;
+    sourceId: z.ZodString;
+    validUntil: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type CloudEntitlement = z.infer<typeof CLOUD_ENTITLEMENT_SCHEMA>;
+export declare const CLOUD_LEASE_SCHEMA: z.ZodObject<{
+    token: z.ZodString;
+    expiresAt: z.ZodString;
+    tunnelUrl: z.ZodString;
+    mcpBaseUrl: z.ZodNullable<z.ZodString>;
+    webBaseUrl: z.ZodNullable<z.ZodString>;
+    services: z.ZodArray<z.ZodEnum<{
+        remote_mcp: "remote_mcp";
+        remote_web: "remote_web";
+    }>>;
+}, z.core.$strict>;
+export type CloudLeaseState = z.infer<typeof CLOUD_LEASE_SCHEMA>;
+interface ManagementSessionState {
+    purchaseToken: string;
+    managementUrl: string;
+    expiresAt: string;
+}
+export interface CloudPersistedState {
+    schemaVersion: 1;
+    installationId: string;
+    devicePublicKey: string;
+    devicePrivateKey: string;
+    customerId: string | null;
+    publicPrefix: string | null;
+    desiredServices: Record<CloudServiceId, boolean>;
+    entitlements: CloudEntitlement[];
+    managementSession: ManagementSessionState | null;
+    lease: CloudLeaseState | null;
+}
+export interface CloudStatus {
+    installationId: string;
+    customerId: string | null;
+    publicPrefix: string | null;
+    desiredServices: Record<CloudServiceId, boolean>;
+    entitlements: CloudEntitlement[];
+    managementSessionActive: boolean;
+    connection: "inactive" | "connecting" | "connected" | "disconnected" | "error";
+    mcpUrl: string | null;
+    webUrl: string | null;
+    lastError: string | null;
+}
+export {};

package/dist/plugins/cloud/types.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export const CLOUD_SERVICES = ["remote_mcp", "remote_web"];
+export const CLOUD_SERVICE_SCHEMA = z.enum(CLOUD_SERVICES);
+const PUBLIC_SERVICE_TO_CLOUD_SERVICE = {
+    mcp: "remote_mcp",
+    web: "remote_web",
+};
+export const CLOUD_DESIRED_SERVICES_SCHEMA = z
+    .object({ remote_mcp: z.boolean(), remote_web: z.boolean() })
+    .strict();
+export function cloudServiceForPublicService(service) {
+    return PUBLIC_SERVICE_TO_CLOUD_SERVICE[service];
+}
+export const CLOUD_ENTITLEMENT_SCHEMA = z
+    .object({
+    service: CLOUD_SERVICE_SCHEMA,
+    status: z.literal("active"),
+    sourceProvider: z.string().min(1),
+    sourceId: z.string().min(1),
+    validUntil: z.string().datetime().nullable(),
+})
+    .strict();
+export const CLOUD_LEASE_SCHEMA = z
+    .object({
+    token: z.string().min(1),
+    expiresAt: z.string().datetime(),
+    tunnelUrl: z.string().url(),
+    mcpBaseUrl: z.string().url().nullable(),
+    webBaseUrl: z.string().url().nullable(),
+    services: z.array(CLOUD_SERVICE_SCHEMA),
+})
+    .strict();

package/dist/plugins/plugin-manager.d.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { InternalPlugin, PluginContext } from "./types.js";
+export declare class PluginManager {
+    private readonly context;
+    private readonly plugins;
+    private readonly active;
+    constructor(context: PluginContext, plugins: InternalPlugin[]);
+    start(): Promise<void>;
+    registerMcp(server: McpServer): void;
+    stop(): Promise<void>;
+}

package/dist/plugins/plugin-manager.js

@@ -0,0 +1,24 @@
+export class PluginManager {
+    context;
+    plugins;
+    active = [];
+    constructor(context, plugins) {
+        this.context = context;
+        this.plugins = plugins;
+    }
+    async start() {
+        for (const plugin of this.plugins) {
+            await plugin.activate(this.context);
+            this.active.push(plugin);
+        }
+    }
+    registerMcp(server) {
+        for (const plugin of this.active)
+            plugin.registerMcp?.(server);
+    }
+    async stop() {
+        for (const plugin of [...this.active].reverse())
+            await plugin.deactivate?.();
+        this.active.length = 0;
+    }
+}

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

@@ -0,0 +1,19 @@
+/** OS/process-backend port consumed by ProcessSupervisor. */
+export interface BackendProcess {
+    readonly pid: number | null;
+    write(data: string): void;
+    kill(signal?: NodeJS.Signals): void;
+    onStdout(listener: (chunk: Buffer) => void): void;
+    onStderr(listener: (chunk: Buffer) => void): void;
+    onExit(listener: (exit: {
+        exitCode: number | null;
+        signal: string | null;
+    }) => void): void;
+}
+export interface ProcessBackend {
+    readonly kind: "pipe" | "pty";
+    start(command: string, args: string[], options: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+    }): Promise<BackendProcess>;
+}

package/dist/plugins/process/backend.js

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

package/dist/plugins/process/head-tail-buffer.d.ts

@@ -0,0 +1,18 @@
+/** Bounded process-output buffer that preserves useful context from both ends of a stream. */
+interface BufferSnapshot {
+    text: string;
+    bytesSeen: number;
+    outputTruncated: boolean;
+}
+export declare class HeadTailBuffer {
+    private readonly headLimit;
+    private readonly tailLimit;
+    private head;
+    private tail;
+    private bytesSeen;
+    constructor(totalLimitBytes?: number);
+    append(chunk: Buffer | string): void;
+    snapshot(): BufferSnapshot;
+    private pushTail;
+}
+export {};

package/dist/plugins/process/head-tail-buffer.js

@@ -0,0 +1,49 @@
+export class HeadTailBuffer {
+    headLimit;
+    tailLimit;
+    head = Buffer.alloc(0);
+    tail = Buffer.alloc(0);
+    bytesSeen = 0;
+    constructor(totalLimitBytes = 256 * 1024) {
+        if (totalLimitBytes < 128)
+            throw new RangeError("Buffer limit must be at least 128 bytes");
+        this.headLimit = Math.floor(totalLimitBytes / 2);
+        this.tailLimit = totalLimitBytes - this.headLimit;
+    }
+    append(chunk) {
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        this.bytesSeen += data.length;
+        if (this.head.length < this.headLimit) {
+            const needed = this.headLimit - this.head.length;
+            this.head = Buffer.concat([this.head, data.subarray(0, needed)]);
+            if (data.length <= needed)
+                return;
+            this.pushTail(data.subarray(needed));
+            return;
+        }
+        this.pushTail(data);
+    }
+    snapshot() {
+        const stored = this.head.length + this.tail.length;
+        const truncated = this.bytesSeen > stored;
+        if (!truncated) {
+            return {
+                text: Buffer.concat([this.head, this.tail]).toString("utf8"),
+                bytesSeen: this.bytesSeen,
+                outputTruncated: false,
+            };
+        }
+        return {
+            text: `${this.head.toString("utf8")}\n…[${this.bytesSeen - stored} bytes truncated]…\n${this.tail.toString("utf8")}`,
+            bytesSeen: this.bytesSeen,
+            outputTruncated: true,
+        };
+    }
+    pushTail(data) {
+        const combined = Buffer.concat([this.tail, data]);
+        this.tail =
+            combined.length > this.tailLimit
+                ? combined.subarray(combined.length - this.tailLimit)
+                : combined;
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { BackendProcess, ProcessBackend } from "../backend.js";
+export declare class PipeProcessBackend implements ProcessBackend {
+    readonly kind: "pipe";
+    start(command: string, args: string[], options: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+    }): Promise<BackendProcess>;
+}

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

@@ -0,0 +1,61 @@
+/** Pipe-based ProcessBackend implemented with Node child_process.spawn. */
+import { spawn } from "node:child_process";
+export class PipeProcessBackend {
+    kind = "pipe";
+    async start(command, args, options) {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: process.platform !== "win32",
+            windowsHide: true,
+        });
+        await new Promise((resolve, reject) => {
+            child.once("spawn", resolve);
+            child.once("error", reject);
+        });
+        return new PipeBackendProcess(child);
+    }
+}
+class PipeBackendProcess {
+    child;
+    constructor(child) {
+        this.child = child;
+    }
+    get pid() {
+        return this.child.pid ?? null;
+    }
+    write(data) {
+        this.child.stdin.write(data);
+    }
+    kill(signal = "SIGTERM") {
+        if (!this.child.pid)
+            return;
+        if (process.platform === "win32") {
+            const args = ["/PID", String(this.child.pid), "/T"];
+            if (signal === "SIGKILL")
+                args.push("/F");
+            const killer = spawn("taskkill.exe", args, {
+                stdio: "ignore",
+                windowsHide: true,
+            });
+            killer.once("error", () => this.child.kill(signal));
+            return;
+        }
+        try {
+            process.kill(-this.child.pid, signal);
+        }
+        catch {
+            this.child.kill(signal);
+        }
+    }
+    onStdout(listener) {
+        this.child.stdout.on("data", listener);
+    }
+    onStderr(listener) {
+        this.child.stderr.on("data", listener);
+    }
+    onExit(listener) {
+        this.child.once("close", (code, signal) => listener({ exitCode: code, signal }));
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { BackendProcess, ProcessBackend } from "../backend.js";
+export declare class PtyProcessBackend implements ProcessBackend {
+    readonly kind: "pty";
+    start(command: string, args: string[], options: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+    }): Promise<BackendProcess>;
+}

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

@@ -0,0 +1,50 @@
+/** Optional PTY ProcessBackend backed by node-pty when native PTY support is installed. */
+import { ChatRoomError } from "../../../core/errors/chatroom-error.js";
+export class PtyProcessBackend {
+    kind = "pty";
+    async start(command, args, options) {
+        let pty;
+        try {
+            pty = (await import("node-pty"));
+        }
+        catch (error) {
+            throw new ChatRoomError("UNSUPPORTED", "PTY support is unavailable; install optional dependency node-pty", undefined, { cause: error });
+        }
+        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,
+            cwd: options.cwd,
+            env,
+        });
+        return new PtyBackendProcess(processHandle);
+    }
+}
+class PtyBackendProcess {
+    processHandle;
+    constructor(processHandle) {
+        this.processHandle = processHandle;
+    }
+    get pid() {
+        return this.processHandle.pid;
+    }
+    write(data) {
+        this.processHandle.write(data);
+    }
+    kill(signal = "SIGTERM") {
+        this.processHandle.kill(signal);
+    }
+    onStdout(listener) {
+        this.processHandle.onData((data) => listener(Buffer.from(data)));
+    }
+    onStderr(_listener) {
+        /* PTYs expose a merged stream. */
+    }
+    onExit(listener) {
+        this.processHandle.onExit((event) => listener({
+            exitCode: event.exitCode,
+            signal: event.signal ? String(event.signal) : null,
+        }));
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { OperationLog } from "../../operations/operation-log.js";
+import type { ProcessSupervisor } from "./process-supervisor.js";
+export declare function registerProcessTools(server: McpServer, processes: ProcessSupervisor, operations: OperationLog): void;