@cjhyy/code-shell-server 0.9.7 → 0.9.9

package/dist/hub/mcp-probe.js

@@ -0,0 +1,392 @@
+import { spawn } from "node:child_process";
+import { pathToFileURL } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { JSONRPCMessageSchema, ListRootsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { buildStdioEnv, createMcpAuthenticatedFetch, localCredentialAccess, } from "@cjhyy/code-shell-core";
+const MAX_FRAME_BYTES = 512 * 1024;
+const MAX_TOTAL_BYTES = 2 * 1024 * 1024;
+const MAX_PREVIEW_TOOLS = 100;
+const MAX_TOOL_PAGES = 8;
+class ProbeFailure extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+/** A short-lived probe owns its process group, so a failed launcher cannot leave children behind. */
+class BoundedStdioTransport {
+    config;
+    cwd;
+    onclose;
+    onerror;
+    onmessage;
+    child;
+    pending = Buffer.alloc(0);
+    totalBytes = 0;
+    closed = false;
+    closePromise;
+    closeNotified = false;
+    constructor(config, cwd) {
+        this.config = config;
+        this.cwd = cwd;
+    }
+    async start() {
+        if (this.closed || this.child)
+            throw new ProbeFailure("cancelled", "测试已取消。");
+        const child = spawn(this.config.command, this.config.args ?? [], {
+            cwd: this.cwd,
+            env: { ...getDefaultEnvironment(), ...buildStdioEnv(this.config.name, this.config) },
+            detached: process.platform !== "win32",
+            shell: false,
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child = child;
+        // Server stderr can contain access tokens. Drain it without logging or retaining it.
+        child.stderr.resume();
+        child.stdout.on("data", (chunk) => this.read(chunk));
+        child.stdout.on("error", (error) => this.onerror?.(error));
+        child.stdin.on("error", (error) => this.onerror?.(error));
+        child.once("close", () => this.notifyClose());
+        await new Promise((resolve, reject) => {
+            child.once("spawn", resolve);
+            child.once("error", (error) => {
+                reject(error);
+                this.onerror?.(error);
+            });
+        });
+    }
+    read(chunk) {
+        if (this.closed)
+            return;
+        this.totalBytes += chunk.byteLength;
+        if (this.totalBytes > MAX_TOTAL_BYTES || this.pending.length + chunk.length > MAX_FRAME_BYTES) {
+            this.onerror?.(new ProbeFailure("response_too_large", "服务返回的数据过大，测试已停止。"));
+            void this.close();
+            return;
+        }
+        this.pending = Buffer.concat([this.pending, chunk]);
+        for (let index = this.pending.indexOf(10); index !== -1; index = this.pending.indexOf(10)) {
+            const line = this.pending.subarray(0, index).toString("utf8").trim();
+            this.pending = this.pending.subarray(index + 1);
+            if (!line)
+                continue;
+            try {
+                this.onmessage?.(JSONRPCMessageSchema.parse(JSON.parse(line)));
+            }
+            catch {
+                this.onerror?.(new ProbeFailure("invalid_protocol", "命令的输出不是有效的 MCP 协议消息，请检查启动方式。"));
+                void this.close();
+                return;
+            }
+        }
+    }
+    async send(message) {
+        if (this.closed || !this.child?.stdin.writable)
+            throw new ProbeFailure("closed", "服务连接已关闭。");
+        await new Promise((resolve, reject) => {
+            this.child.stdin.write(`${JSON.stringify(message)}\n`, (error) => error ? reject(error) : resolve());
+        });
+    }
+    notifyClose() {
+        if (this.closeNotified)
+            return;
+        this.closeNotified = true;
+        this.onclose?.();
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closed = true;
+        this.pending = Buffer.alloc(0);
+        this.closePromise = (async () => {
+            const child = this.child;
+            if (child) {
+                const exited = child.exitCode !== null || child.signalCode !== null;
+                const exit = exited
+                    ? Promise.resolve()
+                    : new Promise((resolve) => child.once("close", () => resolve()));
+                const kill = (signal) => {
+                    try {
+                        if (process.platform !== "win32" && child.pid)
+                            process.kill(-child.pid, signal);
+                        else
+                            child.kill(signal);
+                    }
+                    catch {
+                        /* already exited */
+                    }
+                };
+                child.stdin.destroy();
+                kill("SIGTERM");
+                await Promise.race([exit, delay(250)]);
+                // The direct process can exit before one of its descendants. The group remains ours.
+                kill("SIGKILL");
+                await Promise.race([exit, delay(500)]);
+                child.stdout.destroy();
+                child.stderr.destroy();
+            }
+            this.notifyClose();
+        })();
+        return this.closePromise;
+    }
+}
+function rememberSecret(secrets, value) {
+    if (!value)
+        return;
+    secrets.add(value);
+    if (/^Bearer\s+/i.test(value))
+        secrets.add(value.replace(/^Bearer\s+/i, ""));
+    const match = /(?:token|secret|password|api[-_]?key)=([^\s]+)/i.exec(value);
+    if (match?.[1])
+        secrets.add(match[1]);
+}
+function redact(text, secrets, maximum) {
+    let safe = text;
+    for (const secret of [...secrets].sort((left, right) => right.length - left.length)) {
+        safe = safe.split(secret).join("[已隐藏]");
+    }
+    return safe.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/g, "").slice(0, maximum);
+}
+function classify(error) {
+    if (error instanceof ProbeFailure)
+        return { code: error.code, message: error.message };
+    const status = error?.code;
+    const messages = [];
+    let current = error;
+    for (let depth = 0; current && depth < 4; depth++) {
+        messages.push(current instanceof Error ? current.message : String(current));
+        const item = current;
+        if (typeof item.code === "string")
+            messages.push(item.code);
+        current = item.cause;
+    }
+    const raw = messages.join(" ");
+    if (/ENOENT/.test(raw))
+        return {
+            code: "command_missing",
+            message: "服务器上找不到这个命令，请确认已安装并填写正确路径。",
+        };
+    if (/EACCES/.test(raw))
+        return { code: "permission_denied", message: "服务器没有执行这个命令的权限。" };
+    if (/ECONNREFUSED/.test(raw))
+        return {
+            code: "connection_refused",
+            message: "目标服务拒绝连接，请检查地址、端口和服务状态。",
+        };
+    if (/ENOTFOUND|EAI_AGAIN/.test(raw))
+        return { code: "dns", message: "无法解析服务域名，请检查地址和服务器的网络。" };
+    if (/env var .* is not set/.test(raw))
+        return {
+            code: "environment_missing",
+            message: "配置引用的服务器环境变量未设置，请检查环境变量名称和服务启动环境。",
+        };
+    if (/credential .*not found|credential .*empty|metadata is unavailable/.test(raw))
+        return {
+            code: "credential_missing",
+            message: "引用的凭据不存在或不可用，请检查服务器上的凭据配置。",
+        };
+    if (/expired|oauth.*requires/i.test(raw))
+        return {
+            code: "credential_expired",
+            message: "认证凭据已过期或需要重新授权，请在服务器上更新凭据。",
+        };
+    if (status === 401 ||
+        /\b401\b|unauthori[sz]ed|-32001|no auth provider/i.test(raw) ||
+        (error instanceof Error && error.name === "UnauthorizedError"))
+        return { code: "unauthorized", message: "服务拒绝了认证信息，请检查 API Key、请求头或凭据。" };
+    if (status === 403 || /\b403\b|forbidden/i.test(raw))
+        return { code: "forbidden", message: "当前凭据没有使用此服务的权限。" };
+    if (status === 404 || /\b404\b/.test(raw))
+        return { code: "not_found", message: "这个地址没有提供 MCP 服务，请确认完整的 MCP 接口地址。" };
+    if (status === 405 || /\b405\b|Unexpected content type|protocol|JSON/i.test(raw))
+        return { code: "protocol", message: "服务没有返回预期的 MCP 协议，请检查连接类型与接口地址。" };
+    if (/timed out|timeout|ETIMEDOUT/i.test(raw))
+        return {
+            code: "timeout",
+            message: "连接测试超时。首次运行包管理器可能需要下载依赖，可以稍后重试。",
+        };
+    if (/certificate|TLS|SSL/i.test(raw))
+        return { code: "tls", message: "服务的 HTTPS 证书验证失败，请检查证书和服务器信任配置。" };
+    return {
+        code: "connection_failed",
+        message: "连接测试失败。请确认服务支持 MCP、命令可以启动，并检查服务器上的服务日志。",
+    };
+}
+/** Explicit, bounded sibling connection; configuration reads never invoke this function. */
+export async function probeHubMcp(config, options) {
+    const started = Date.now();
+    const secrets = new Set();
+    for (const value of [
+        ...Object.values(config.env ?? {}),
+        ...Object.values(config.headers ?? {}),
+        ...(config.args ?? []),
+    ])
+        rememberSecret(secrets, value);
+    for (const name of [
+        ...(config.envVars ?? []),
+        ...Object.values(config.envHeaders ?? {}),
+        config.bearerTokenEnvVar,
+    ]) {
+        if (name)
+            rememberSecret(secrets, process.env[name]);
+    }
+    if (config.url) {
+        try {
+            const url = new URL(config.url);
+            for (const value of [url.username, url.password, ...url.searchParams.values()]) {
+                rememberSecret(secrets, value);
+                try {
+                    rememberSecret(secrets, decodeURIComponent(value));
+                }
+                catch {
+                    /* The raw URL component is already hidden. */
+                }
+            }
+        }
+        catch {
+            /* Invalid URLs are classified below without returning the original value. */
+        }
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(new ProbeFailure("timeout", "连接测试超时。首次运行包管理器可能需要下载依赖，可以稍后重试。")), options.timeoutMs ?? 10_000);
+    const cancel = () => controller.abort(new ProbeFailure("cancelled", "测试已取消。"));
+    options.signal.addEventListener("abort", cancel, { once: true });
+    if (options.signal.aborted)
+        cancel();
+    const client = new Client({ name: "code-shell-hub-probe", version: "1.0.0" }, { capabilities: { roots: {} } });
+    client.setRequestHandler(ListRootsRequestSchema, async () => ({
+        roots: [{ uri: pathToFileURL(options.cwd).href }],
+    }));
+    let transport;
+    let transportError;
+    client.onerror = (error) => {
+        transportError = error;
+    };
+    let rejectAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        rejectAbort = reject;
+    });
+    const onAbort = () => {
+        rejectAbort?.(controller.signal.reason);
+        if (transport)
+            void transport.close().catch(() => { });
+    };
+    controller.signal.addEventListener("abort", onAbort, { once: true });
+    try {
+        if (controller.signal.aborted)
+            throw controller.signal.reason;
+        const mode = config.transport ?? (config.url ? "streamable-http" : "stdio");
+        if (mode === "stdio") {
+            if (!config.command)
+                throw new ProbeFailure("invalid_config", "请先填写启动命令。");
+            transport = new BoundedStdioTransport(config, options.cwd);
+        }
+        else if (mode === "streamable-http" || mode === "sse") {
+            if (!config.url)
+                throw new ProbeFailure("invalid_config", "请先填写 MCP 接口地址。");
+            const boundedFetch = (async (input, init) => {
+                const request = new Request(input, init);
+                for (const [, value] of request.headers)
+                    rememberSecret(secrets, value);
+                const signal = AbortSignal.any([request.signal, controller.signal]);
+                const response = await fetch(new Request(request, { signal, redirect: "error" }));
+                if (!response.body)
+                    return response;
+                let bytes = 0;
+                const body = response.body.pipeThrough(new TransformStream({
+                    transform(chunk, stream) {
+                        bytes += chunk.byteLength;
+                        if (bytes > MAX_TOTAL_BYTES) {
+                            const error = new ProbeFailure("response_too_large", "服务返回的数据过大，测试已停止。");
+                            controller.abort(error);
+                            stream.error(error);
+                        }
+                        else
+                            stream.enqueue(chunk);
+                    },
+                }));
+                return new Response(body, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: response.headers,
+                });
+            });
+            transport = new StreamableHTTPClientTransport(new URL(config.url), {
+                fetch: createMcpAuthenticatedFetch(config.name, config, localCredentialAccess, boundedFetch),
+                reconnectionOptions: {
+                    maxRetries: 0,
+                    initialReconnectionDelay: 100,
+                    maxReconnectionDelay: 100,
+                    reconnectionDelayGrowFactor: 1,
+                },
+            });
+        }
+        else
+            throw new ProbeFailure("unsupported_transport", "此内置服务由任务进程管理，不能创建独立测试连接。");
+        const run = (async () => {
+            await client.connect(transport);
+            let cursor;
+            let toolCount = 0;
+            const tools = [];
+            const seen = new Set();
+            for (let page = 0; page < MAX_TOOL_PAGES; page++) {
+                const result = await client.listTools(cursor ? { cursor } : {});
+                toolCount += result.tools.length;
+                for (const tool of result.tools) {
+                    if (tools.length >= MAX_PREVIEW_TOOLS)
+                        break;
+                    tools.push({
+                        name: redact(tool.name, secrets, 160),
+                        ...(tool.description ? { description: redact(tool.description, secrets, 600) } : {}),
+                        allowed: (config.allowedTools === undefined || config.allowedTools.includes(tool.name)) &&
+                            !(config.disabledTools ?? []).includes(tool.name),
+                    });
+                }
+                cursor = result.nextCursor;
+                if (!cursor)
+                    break;
+                if (seen.has(cursor))
+                    throw new ProbeFailure("invalid_protocol", "服务返回了重复的工具分页游标，测试已停止。");
+                seen.add(cursor);
+            }
+            return { toolCount, tools, truncated: !!cursor || tools.length < toolCount };
+        })();
+        const result = await Promise.race([run, aborted]);
+        return {
+            name: config.name,
+            status: "ok",
+            checkedAt: new Date().toISOString(),
+            durationMs: Date.now() - started,
+            ...result,
+        };
+    }
+    catch (cause) {
+        const error = classify(controller.signal.aborted
+            ? controller.signal.reason
+            : transportError instanceof ProbeFailure
+                ? transportError
+                : cause);
+        return {
+            name: config.name,
+            status: error.code === "cancelled" ? "cancelled" : "error",
+            checkedAt: new Date().toISOString(),
+            durationMs: Date.now() - started,
+            error,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+        options.signal.removeEventListener("abort", cancel);
+        controller.signal.removeEventListener("abort", onAbort);
+        controller.abort();
+        await transport?.close().catch(() => { });
+        await client.close().catch(() => { });
+    }
+}

package/dist/hub/model-probe.d.ts

@@ -0,0 +1,20 @@
+/** A bounded, tool-free connectivity check through the same Core clients as real tasks. */
+import { type SettingsManager } from "@cjhyy/code-shell-core";
+type Settings = ReturnType<SettingsManager["get"]>;
+export type ModelProbeCode = "connected" | "missing_key" | "invalid_configuration" | "unauthorized" | "model_unavailable" | "rate_limited" | "provider_error" | "network_error" | "invalid_response" | "timeout" | "cancelled";
+export interface ModelProbeResult {
+    ok: boolean;
+    connectionId: string;
+    model: string;
+    latencyMs: number;
+    checkedAt: string;
+    code: ModelProbeCode;
+    message: string;
+    status?: number;
+}
+export declare function probeConfiguredModel(settings: Settings, id: string, options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    transport?: typeof fetch;
+}): Promise<ModelProbeResult>;
+export {};

package/dist/hub/model-probe.js

@@ -0,0 +1,193 @@
+/** A bounded, tool-free connectivity check through the same Core clients as real tasks. */
+import { createLLMClient, resolveLLMConfigForTag, } from "@cjhyy/code-shell-core";
+import { getMergedCatalog } from "@cjhyy/code-shell-core/internal";
+const messages = {
+    connected: "连接成功，模型已正常返回响应。",
+    missing_key: "缺少有效的 API Key，请编辑连接并填写密钥。",
+    invalid_configuration: "连接配置不完整或不支持，请检查服务商、模型和服务地址。",
+    unauthorized: "服务商拒绝了凭据，请检查 API Key 与账号的模型访问权限。",
+    model_unavailable: "模型或接口不可用，请检查模型名称与服务地址。",
+    rate_limited: "服务商限制了请求，请检查账户额度或稍后重试。",
+    provider_error: "服务商暂时无法处理请求，请稍后重试。",
+    network_error: "无法连接服务，请检查服务器网络、服务地址与本地模型是否启动。",
+    invalid_response: "服务有响应，但没有返回有效的模型内容，请检查接口类型和模型。",
+    timeout: "连接测试超时，请检查服务地址与网络，或稍后重试。",
+    cancelled: "已取消连接测试。",
+};
+export async function probeConfiguredModel(settings, id, options = {}) {
+    const started = Date.now();
+    const connection = settings.modelConnections.find((item) => item.id === id && item.tag === "text");
+    const result = (code, status) => ({
+        ok: code === "connected",
+        connectionId: id,
+        model: connection?.model ?? "",
+        latencyMs: Math.max(0, Date.now() - started),
+        checkedAt: new Date().toISOString(),
+        code,
+        message: messages[code],
+        ...(status ? { status } : {}),
+    });
+    if (!connection)
+        return result("invalid_configuration");
+    const template = getMergedCatalog().find((entry) => entry.id === connection.catalogId);
+    // Core treats an omitted text protocol as OpenAI-compatible.
+    if (!template)
+        return result("invalid_configuration");
+    const credential = settings.credentials.find((item) => item.id === connection.credentialId);
+    if (template.needsKey !== false && !credential?.apiKey)
+        return result("missing_key");
+    // Narrowing prevents the resolver's fallback from testing a different connection.
+    const resolved = resolveLLMConfigForTag({ ...settings, modelConnections: [connection] }, "text", id);
+    if (!resolved)
+        return result("invalid_configuration");
+    try {
+        const endpoint = new URL(resolved.baseUrl ?? "");
+        if (!["https:", "http:"].includes(endpoint.protocol) ||
+            endpoint.username ||
+            endpoint.password ||
+            endpoint.search ||
+            endpoint.hash)
+            return result("invalid_configuration");
+    }
+    catch {
+        return result("invalid_configuration");
+    }
+    const controller = new AbortController();
+    const timeoutMs = Math.min(18_000, Math.max(1, options.timeoutMs ?? 18_000));
+    let timedOut = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, timeoutMs);
+    timer.unref();
+    const cancel = () => controller.abort();
+    options.signal?.addEventListener("abort", cancel, { once: true });
+    if (options.signal?.aborted)
+        controller.abort();
+    let status;
+    let transportFailed = false;
+    let invalidResponse = false;
+    let requests = 0;
+    const transport = options.transport ?? globalThis.fetch;
+    const safeFetch = (async (input, init) => {
+        // SDK retries must never turn a connectivity check into multiple paid requests.
+        if (++requests > 1)
+            return failureResponse(503);
+        try {
+            const response = await transport(input, {
+                ...init,
+                redirect: "error",
+                signal: init?.signal
+                    ? AbortSignal.any([controller.signal, init.signal])
+                    : controller.signal,
+            });
+            status = response.status;
+            if (!response.ok) {
+                await response.body?.cancel();
+                // Provider error bodies can echo credentials. Never let them reach SDK logs.
+                return failureResponse(response.status);
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                invalidResponse = true;
+                return failureResponse(502);
+            }
+            const chunks = [];
+            let bytes = 0;
+            try {
+                while (true) {
+                    const next = await reader.read();
+                    if (next.done)
+                        break;
+                    bytes += next.value.byteLength;
+                    if (bytes > 1024 * 1024) {
+                        invalidResponse = true;
+                        await reader.cancel();
+                        return failureResponse(502);
+                    }
+                    chunks.push(next.value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            const data = Buffer.concat(chunks);
+            // Invalid JSON must not cause an SDK exception containing the response body.
+            let safeBody;
+            try {
+                const payload = JSON.parse(data.toString("utf8"));
+                safeBody = JSON.stringify(payload, (_key, value) => typeof value === "string" && resolved.apiKey
+                    ? value.replaceAll(resolved.apiKey, "[redacted]")
+                    : value);
+            }
+            catch {
+                invalidResponse = true;
+                return failureResponse(502);
+            }
+            return new Response(safeBody, {
+                status: response.status,
+                headers: { "content-type": "application/json", "x-should-retry": "false" },
+            });
+        }
+        catch {
+            transportFailed = true;
+            return failureResponse(503);
+        }
+    });
+    let rejectAbort;
+    try {
+        const aborted = new Promise((_resolve, reject) => {
+            rejectAbort = () => reject(new Error("model probe aborted"));
+            controller.signal.addEventListener("abort", rejectAbort, { once: true });
+            if (controller.signal.aborted)
+                rejectAbort();
+        });
+        const request = async () => {
+            const client = await createLLMClient({ ...resolved, apiKey: resolved.apiKey ?? "codeshell-no-key", maxTokens: 32 }, { timeout: timeoutMs, retryMaxAttempts: 1, fetch: safeFetch });
+            return client.createMessage({
+                systemPrompt: "This is a connection test. Reply with OK.",
+                messages: [{ role: "user", content: "Reply OK." }],
+                tools: [],
+                reasoning: { mode: "off" },
+                maxTokens: 32,
+                requestVisible: false,
+                billingEnabled: false,
+                signal: controller.signal,
+            });
+        };
+        const response = await Promise.race([request(), aborted]);
+        return response.text?.trim() ? result("connected") : result("invalid_response");
+    }
+    catch {
+        if (timedOut)
+            return result("timeout");
+        if (controller.signal.aborted)
+            return result("cancelled");
+        if (invalidResponse)
+            return result("invalid_response");
+        if (transportFailed)
+            return result("network_error");
+        if (status === 401 || status === 403)
+            return result("unauthorized", status);
+        if (status === 400 || status === 404 || status === 422)
+            return result("model_unavailable", status);
+        if (status === 429)
+            return result("rate_limited", status);
+        if (status && status >= 500)
+            return result("provider_error", status);
+        return result("invalid_response", status);
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", cancel);
+        if (rejectAbort)
+            controller.signal.removeEventListener("abort", rejectAbort);
+        controller.abort();
+    }
+}
+function failureResponse(status) {
+    return Response.json({ error: { message: "Model connection check failed", type: "model_probe_error" } }, {
+        status,
+        headers: { "x-should-retry": "false" },
+    });
+}

package/dist/hub/outbound-transport.d.ts

@@ -0,0 +1,36 @@
+import type { WebSocket } from "ws";
+export interface HubOutboundLimits {
+    /** A history response can contain a 32 MiB transcript plus state and live overlay. */
+    maxFrameBytes: number;
+    /** A single large history frame is allowed; additional queued frames are bounded. */
+    maxSocketBacklogBytes: number;
+    maxTotalBacklogBytes: number;
+}
+export type HubOutboundDropReason = "frame-too-large" | "socket-backlog" | "total-backlog" | "send-error";
+export interface HubOutboundDrop {
+    reason: HubOutboundDropReason;
+    frameBytes: number;
+    socketBacklogBytes: number;
+    totalBacklogBytes: number;
+}
+/**
+ * Bound the WS write queue separately from the replay buffer. A disconnected
+ * browser can recover through the existing authenticated snapshot protocol;
+ * keeping an unread socket alive would retain every subsequent stream frame.
+ */
+export declare class HubOutboundTransport {
+    private readonly options;
+    private readonly limits;
+    private readonly dropped;
+    private readonly largeFrames;
+    constructor(options: {
+        tabs: () => Iterable<WebSocket>;
+        limits?: Partial<HubOutboundLimits>;
+        /** Diagnostic metadata only: never includes conversation contents. */
+        onDrop?: (drop: HubOutboundDrop) => void;
+    });
+    send(tab: WebSocket, line: string): boolean;
+    private backlog;
+    private totalBacklog;
+    private drop;
+}