@chatroomcp/chatroom 0.1.3

package/dist/core/runtime/command-runner.js

@@ -0,0 +1,39 @@
+import { spawn } from "node:child_process";
+import { ChatRoomError } from "../errors/chatroom-error.js";
+import { childEnvironment } from "./child-environment.js";
+export class CommandRunner {
+    run(request) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(request.command, request.args ?? [], {
+                cwd: request.cwd,
+                env: childEnvironment(request.env),
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            const timeout = request.timeoutMs
+                ? setTimeout(() => child.kill("SIGKILL"), request.timeoutMs)
+                : null;
+            timeout?.unref();
+            child.stdout.setEncoding("utf8");
+            child.stderr.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk;
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk;
+            });
+            child.once("error", reject);
+            child.once("close", (code) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                const exitCode = code ?? -1;
+                if (exitCode !== 0) {
+                    reject(new ChatRoomError("PROCESS_FAILED", `${request.command} exited with code ${exitCode}`, { stdout, stderr, exitCode }));
+                    return;
+                }
+                resolve({ stdout, stderr, exitCode });
+            });
+        });
+    }
+}

package/dist/core/runtime/identity.d.ts

@@ -0,0 +1,2 @@
+export declare const CHATROOM_NAME = "ChatRoom";
+export declare const CHATROOM_VERSION: string;

package/dist/core/runtime/identity.js

@@ -0,0 +1,9 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+export const CHATROOM_NAME = "ChatRoom";
+const packageJsonPath = fileURLToPath(new URL("../../../package.json", import.meta.url));
+const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+if (typeof packageJson.version !== "string" || !packageJson.version) {
+    throw new Error("ChatRoom package version is missing");
+}
+export const CHATROOM_VERSION = packageJson.version;

package/dist/infrastructure/database/app-database.d.ts

@@ -0,0 +1,6 @@
+import { DatabaseSync } from "node:sqlite";
+export declare class AppDatabase {
+    readonly raw: DatabaseSync;
+    constructor(databasePath: string);
+    close(): void;
+}

package/dist/infrastructure/database/app-database.js

@@ -0,0 +1,104 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS workspaces (
+    id TEXT PRIMARY KEY,
+    root TEXT NOT NULL UNIQUE,
+    source_root TEXT NOT NULL,
+    mode TEXT NOT NULL CHECK(mode IN ('checkout','worktree')),
+    created_at TEXT NOT NULL,
+    last_used_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS workspaces_last_used_idx ON workspaces(last_used_at DESC);
+
+  CREATE TABLE IF NOT EXISTS operations (
+    operation_id TEXT PRIMARY KEY,
+    plugin_id TEXT NOT NULL,
+    source TEXT NOT NULL,
+    action TEXT NOT NULL,
+    status TEXT NOT NULL,
+    workspace_id TEXT,
+    process_id TEXT,
+    input_json TEXT NOT NULL,
+    output_json TEXT NOT NULL,
+    error_json TEXT NOT NULL,
+    input_truncated INTEGER NOT NULL DEFAULT 0,
+    output_truncated INTEGER NOT NULL DEFAULT 0,
+    started_at TEXT NOT NULL,
+    finished_at TEXT,
+    duration_ms INTEGER
+  );
+  CREATE INDEX IF NOT EXISTS operations_started_idx ON operations(started_at DESC);
+  CREATE INDEX IF NOT EXISTS operations_plugin_idx ON operations(plugin_id, started_at DESC);
+  CREATE INDEX IF NOT EXISTS operations_workspace_idx ON operations(workspace_id, started_at DESC);
+  CREATE INDEX IF NOT EXISTS operations_status_idx ON operations(status, started_at DESC);
+
+  CREATE TABLE IF NOT EXISTS oauth_clients (
+    client_id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    redirect_uris_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS oauth_codes (
+    code_hash TEXT PRIMARY KEY,
+    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,
+    redirect_uri TEXT NOT NULL,
+    code_challenge TEXT NOT NULL,
+    scope TEXT NOT NULL,
+    expires_at TEXT NOT NULL,
+    used_at TEXT
+  );
+  CREATE INDEX IF NOT EXISTS oauth_code_expiry_idx ON oauth_codes(expires_at);
+  CREATE TABLE IF NOT EXISTS oauth_tokens (
+    token_hash TEXT PRIMARY KEY,
+    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,
+    scope TEXT NOT NULL,
+    expires_at TEXT NOT NULL,
+    revoked_at TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS oauth_token_expiry_idx ON oauth_tokens(expires_at);
+  CREATE TABLE IF NOT EXISTS oauth_refresh_tokens (
+    token_hash TEXT PRIMARY KEY,
+    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,
+    scope TEXT NOT NULL,
+    expires_at TEXT NOT NULL,
+    revoked_at TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS oauth_refresh_expiry_idx ON oauth_refresh_tokens(expires_at);
+
+  CREATE TABLE IF NOT EXISTS web_sessions (
+    token_hash TEXT PRIMARY KEY,
+    expires_at TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS web_session_expiry_idx ON web_sessions(expires_at);
+
+  CREATE TABLE IF NOT EXISTS passkeys (
+    credential_id TEXT PRIMARY KEY,
+    public_key BLOB NOT NULL,
+    counter INTEGER NOT NULL,
+    transports_json TEXT NOT NULL,
+    device_type TEXT NOT NULL CHECK(device_type IN ('singleDevice','multiDevice')),
+    backed_up INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    last_used_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS passkeys_last_used_idx ON passkeys(last_used_at DESC);
+
+`;
+export class AppDatabase {
+    raw;
+    constructor(databasePath) {
+        mkdirSync(path.dirname(databasePath), { recursive: true, mode: 0o700 });
+        this.raw = new DatabaseSync(databasePath);
+        this.raw.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;");
+        this.raw.exec(SCHEMA);
+    }
+    close() {
+        this.raw.close();
+    }
+}

package/dist/infrastructure/database/oauth-repository.d.ts

@@ -0,0 +1,20 @@
+import type { OAuthClientRecord, OAuthCodeRecord, OAuthStateRepository, OAuthTokenRecord } from "../../core/auth/repository.js";
+import type { AppDatabase } from "./app-database.js";
+export declare class OAuthRepository implements OAuthStateRepository {
+    private readonly database;
+    constructor(database: AppDatabase);
+    createClient(client: OAuthClientRecord): void;
+    getClient(clientId: string): OAuthClientRecord | null;
+    createCode(code: OAuthCodeRecord): void;
+    getCode(codeHash: string): OAuthCodeRecord | null;
+    consumeCode(codeHash: string, now: string): OAuthCodeRecord | null;
+    createToken(tokenHash: string, clientId: string, scope: string, expiresAt: string): void;
+    createRefreshToken(tokenHash: string, clientId: string, scope: string, expiresAt: string): void;
+    consumeRefreshToken(tokenHash: string, clientId?: string): {
+        clientId: string;
+        scope: string;
+    } | null;
+    tokenInfo(tokenHash: string): OAuthTokenRecord | null;
+    revokeToken(tokenHash: string): void;
+    prune(now: string): number;
+}

package/dist/infrastructure/database/oauth-repository.js

@@ -0,0 +1,140 @@
+export class OAuthRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    createClient(client) {
+        this.database.raw
+            .prepare("INSERT INTO oauth_clients(client_id,name,redirect_uris_json,created_at) VALUES(?,?,?,?)")
+            .run(client.clientId, client.name, JSON.stringify(client.redirectUris), client.createdAt);
+    }
+    getClient(clientId) {
+        const row = this.database.raw
+            .prepare("SELECT * FROM oauth_clients WHERE client_id=?")
+            .get(clientId);
+        return row ? clientFromRow(row) : null;
+    }
+    createCode(code) {
+        this.database.raw
+            .prepare("INSERT INTO oauth_codes(code_hash,client_id,redirect_uri,code_challenge,scope,expires_at,used_at) VALUES(?,?,?,?,?,?,NULL)")
+            .run(code.codeHash, code.clientId, code.redirectUri, code.codeChallenge, code.scope, code.expiresAt);
+    }
+    getCode(codeHash) {
+        const row = this.database.raw
+            .prepare("SELECT * FROM oauth_codes WHERE code_hash=? AND used_at IS NULL")
+            .get(codeHash);
+        return row ? codeFromRow(row) : null;
+    }
+    consumeCode(codeHash, now) {
+        this.database.raw.exec("BEGIN IMMEDIATE");
+        try {
+            const row = this.database.raw
+                .prepare("SELECT * FROM oauth_codes WHERE code_hash=? AND used_at IS NULL AND expires_at > ?")
+                .get(codeHash, now);
+            if (!row) {
+                this.database.raw.exec("COMMIT");
+                return null;
+            }
+            const update = this.database.raw
+                .prepare("UPDATE oauth_codes SET used_at=? WHERE code_hash=? AND used_at IS NULL AND expires_at > ?")
+                .run(now, codeHash, now);
+            if (Number(update.changes) !== 1) {
+                this.database.raw.exec("ROLLBACK");
+                return null;
+            }
+            this.database.raw.exec("COMMIT");
+            return codeFromRow({ ...row, used_at: now });
+        }
+        catch (error) {
+            this.database.raw.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    createToken(tokenHash, clientId, scope, expiresAt) {
+        this.database.raw
+            .prepare("INSERT INTO oauth_tokens(token_hash,client_id,scope,expires_at,revoked_at,created_at) VALUES(?,?,?,?,NULL,?)")
+            .run(tokenHash, clientId, scope, expiresAt, new Date().toISOString());
+    }
+    createRefreshToken(tokenHash, clientId, scope, expiresAt) {
+        this.database.raw
+            .prepare("INSERT INTO oauth_refresh_tokens(token_hash,client_id,scope,expires_at,revoked_at,created_at) VALUES(?,?,?,?,NULL,?)")
+            .run(tokenHash, clientId, scope, expiresAt, new Date().toISOString());
+    }
+    consumeRefreshToken(tokenHash, clientId) {
+        this.database.raw.exec("BEGIN IMMEDIATE");
+        try {
+            const now = new Date().toISOString();
+            const row = this.database.raw
+                .prepare(clientId
+                ? "SELECT client_id,scope FROM oauth_refresh_tokens WHERE token_hash=? AND client_id=? AND revoked_at IS NULL AND expires_at > ?"
+                : "SELECT client_id,scope FROM oauth_refresh_tokens WHERE token_hash=? AND revoked_at IS NULL AND expires_at > ?")
+                .get(...(clientId ? [tokenHash, clientId, now] : [tokenHash, now]));
+            if (!row) {
+                this.database.raw.exec("COMMIT");
+                return null;
+            }
+            const update = this.database.raw
+                .prepare("UPDATE oauth_refresh_tokens SET revoked_at=? WHERE token_hash=? AND revoked_at IS NULL")
+                .run(now, tokenHash);
+            if (Number(update.changes) !== 1) {
+                this.database.raw.exec("ROLLBACK");
+                return null;
+            }
+            this.database.raw.exec("COMMIT");
+            return { clientId: row.client_id, scope: row.scope };
+        }
+        catch (error) {
+            this.database.raw.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    tokenInfo(tokenHash) {
+        const row = this.database.raw
+            .prepare("SELECT client_id,scope,expires_at FROM oauth_tokens WHERE token_hash=? AND revoked_at IS NULL AND expires_at > ?")
+            .get(tokenHash, new Date().toISOString());
+        return row
+            ? { clientId: row.client_id, scope: row.scope, expiresAt: row.expires_at }
+            : null;
+    }
+    revokeToken(tokenHash) {
+        const now = new Date().toISOString();
+        this.database.raw
+            .prepare("UPDATE oauth_tokens SET revoked_at=? WHERE token_hash=?")
+            .run(now, tokenHash);
+        this.database.raw
+            .prepare("UPDATE oauth_refresh_tokens SET revoked_at=? WHERE token_hash=?")
+            .run(now, tokenHash);
+    }
+    prune(now) {
+        let deleted = 0;
+        deleted += Number(this.database.raw
+            .prepare("DELETE FROM oauth_codes WHERE expires_at <= ? OR used_at IS NOT NULL")
+            .run(now).changes);
+        deleted += Number(this.database.raw
+            .prepare("DELETE FROM oauth_tokens WHERE expires_at <= ? OR revoked_at IS NOT NULL")
+            .run(now).changes);
+        deleted += Number(this.database.raw
+            .prepare("DELETE FROM oauth_refresh_tokens WHERE expires_at <= ? OR revoked_at IS NOT NULL")
+            .run(now).changes);
+        return deleted;
+    }
+}
+function clientFromRow(row) {
+    return {
+        clientId: row.client_id,
+        name: row.name,
+        redirectUris: JSON.parse(row.redirect_uris_json),
+        createdAt: row.created_at,
+    };
+}
+function codeFromRow(row) {
+    return {
+        codeHash: row.code_hash,
+        clientId: row.client_id,
+        redirectUri: row.redirect_uri,
+        codeChallenge: row.code_challenge,
+        scope: row.scope,
+        expiresAt: row.expires_at,
+        usedAt: row.used_at,
+    };
+}

package/dist/infrastructure/database/operation-repository.d.ts

@@ -0,0 +1,16 @@
+import type { Operation } from "../../core/operations/types.js";
+import type { OperationQuery, OperationRepository as OperationRepositoryPort } from "../../core/operations/repository.js";
+import type { AppDatabase } from "./app-database.js";
+export declare class OperationRepository implements OperationRepositoryPort {
+    private readonly database;
+    constructor(database: AppDatabase);
+    insert(operation: Operation): void;
+    update(operation: Operation): void;
+    get(operationId: string): Operation | null;
+    list(query?: OperationQuery): Operation[];
+    reconcileRunning(finishedAt: string): number;
+    clearHistory(): {
+        deleted: number;
+        preserved: number;
+    };
+}

package/dist/infrastructure/database/operation-repository.js

@@ -0,0 +1,129 @@
+export class OperationRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    insert(operation) {
+        this.database.raw
+            .prepare(`
+        INSERT INTO operations(
+          operation_id, plugin_id, source, action, status, workspace_id, process_id,
+          input_json, output_json, error_json, input_truncated, output_truncated,
+          started_at, finished_at, duration_ms
+        ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+      `)
+            .run(...toRowValues(operation));
+    }
+    update(operation) {
+        this.database.raw
+            .prepare(`
+        UPDATE operations SET
+          plugin_id=?, source=?, action=?, status=?, workspace_id=?, process_id=?,
+          input_json=?, output_json=?, error_json=?, input_truncated=?, output_truncated=?,
+          started_at=?, finished_at=?, duration_ms=?
+        WHERE operation_id=?
+      `)
+            .run(...toRowValues(operation).slice(1), operation.operationId);
+    }
+    get(operationId) {
+        const row = this.database.raw
+            .prepare("SELECT * FROM operations WHERE operation_id=?")
+            .get(operationId);
+        return row ? fromRow(row) : null;
+    }
+    list(query = {}) {
+        const where = [];
+        const args = [];
+        if (query.pluginId) {
+            where.push("plugin_id=?");
+            args.push(query.pluginId);
+        }
+        if (query.status) {
+            where.push("status=?");
+            args.push(query.status);
+        }
+        if (query.workspaceId) {
+            where.push("workspace_id=?");
+            args.push(query.workspaceId);
+        }
+        const limit = Math.min(Math.max(query.limit ?? 100, 1), 500);
+        const offset = Math.max(query.offset ?? 0, 0);
+        const filter = where.length ? `WHERE ${where.join(" AND ")}` : "";
+        return this.database.raw
+            .prepare(`SELECT * FROM operations ${filter} ORDER BY started_at DESC LIMIT ? OFFSET ?`)
+            .all(...args, limit, offset).map(fromRow);
+    }
+    reconcileRunning(finishedAt) {
+        const result = this.database.raw
+            .prepare(`
+        UPDATE operations
+        SET status='cancelled', finished_at=?,
+            duration_ms=MAX(0, CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)),
+            error_json=?
+        WHERE status='running'
+      `)
+            .run(finishedAt, finishedAt, JSON.stringify({
+            code: "INTERRUPTED",
+            message: "Runtime stopped before this operation completed",
+        }));
+        return Number(result.changes);
+    }
+    clearHistory() {
+        const before = this.database.raw
+            .prepare("SELECT COUNT(*) AS count FROM operations")
+            .get().count;
+        this.database.raw
+            .prepare("DELETE FROM operations WHERE status != 'running'")
+            .run();
+        const preserved = this.database.raw
+            .prepare("SELECT COUNT(*) AS count FROM operations")
+            .get().count;
+        return { deleted: before - preserved, preserved };
+    }
+}
+function toRowValues(operation) {
+    return [
+        operation.operationId,
+        operation.pluginId,
+        operation.source,
+        operation.action,
+        operation.status,
+        operation.workspaceId,
+        operation.processId,
+        JSON.stringify(operation.input),
+        JSON.stringify(operation.output),
+        JSON.stringify(operation.error),
+        operation.inputTruncated ? 1 : 0,
+        operation.outputTruncated ? 1 : 0,
+        operation.startedAt,
+        operation.finishedAt,
+        operation.durationMs,
+    ];
+}
+function fromRow(row) {
+    return {
+        operationId: row.operation_id,
+        pluginId: row.plugin_id,
+        source: row.source,
+        action: row.action,
+        status: row.status,
+        workspaceId: row.workspace_id,
+        processId: row.process_id,
+        input: parse(row.input_json),
+        output: parse(row.output_json),
+        error: parse(row.error_json),
+        inputTruncated: Boolean(row.input_truncated),
+        outputTruncated: Boolean(row.output_truncated),
+        startedAt: row.started_at,
+        finishedAt: row.finished_at,
+        durationMs: row.duration_ms,
+    };
+}
+function parse(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/infrastructure/database/passkey-repository.d.ts

@@ -0,0 +1,11 @@
+import type { PasskeyRecord, PasskeyRepository as PasskeyRepositoryPort } from "../../core/auth/passkey-repository.js";
+import type { AppDatabase } from "./app-database.js";
+export declare class PasskeyRepository implements PasskeyRepositoryPort {
+    private readonly database;
+    constructor(database: AppDatabase);
+    list(): PasskeyRecord[];
+    get(credentialId: string): PasskeyRecord | null;
+    upsert(record: PasskeyRecord): void;
+    remove(credentialId: string): void;
+    updateCounter(credentialId: string, counter: number): void;
+}

package/dist/infrastructure/database/passkey-repository.js

@@ -0,0 +1,57 @@
+export class PasskeyRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    list() {
+        return this.database.raw
+            .prepare("SELECT * FROM passkeys ORDER BY last_used_at DESC, created_at DESC")
+            .all()
+            .map((row) => mapPasskey(row));
+    }
+    get(credentialId) {
+        const row = this.database.raw
+            .prepare("SELECT * FROM passkeys WHERE credential_id=?")
+            .get(credentialId);
+        return row ? mapPasskey(row) : null;
+    }
+    upsert(record) {
+        this.database.raw
+            .prepare(`INSERT INTO passkeys(
+          credential_id, public_key, counter, transports_json, device_type, backed_up,
+          name, created_at, last_used_at
+        ) VALUES(?,?,?,?,?,?,?,?,?)
+        ON CONFLICT(credential_id) DO UPDATE SET
+          public_key=excluded.public_key,
+          counter=excluded.counter,
+          transports_json=excluded.transports_json,
+          device_type=excluded.device_type,
+          backed_up=excluded.backed_up,
+          name=excluded.name,
+          last_used_at=excluded.last_used_at`)
+            .run(record.credentialId, Buffer.from(record.publicKey), record.counter, JSON.stringify(record.transports), record.deviceType, record.backedUp ? 1 : 0, record.name, record.createdAt, record.lastUsedAt);
+    }
+    remove(credentialId) {
+        this.database.raw
+            .prepare("DELETE FROM passkeys WHERE credential_id=?")
+            .run(credentialId);
+    }
+    updateCounter(credentialId, counter) {
+        this.database.raw
+            .prepare("UPDATE passkeys SET counter=?, last_used_at=? WHERE credential_id=?")
+            .run(counter, new Date().toISOString(), credentialId);
+    }
+}
+function mapPasskey(row) {
+    return {
+        credentialId: row.credential_id,
+        publicKey: new Uint8Array(row.public_key),
+        counter: row.counter,
+        transports: JSON.parse(row.transports_json),
+        deviceType: row.device_type,
+        backedUp: Boolean(row.backed_up),
+        name: row.name,
+        createdAt: row.created_at,
+        lastUsedAt: row.last_used_at,
+    };
+}

package/dist/infrastructure/database/web-session-repository.d.ts

@@ -0,0 +1,10 @@
+import type { WebSessionRepository as WebSessionRepositoryPort } from "../../core/auth/session-repository.js";
+import type { AppDatabase } from "./app-database.js";
+export declare class WebSessionRepository implements WebSessionRepositoryPort {
+    private readonly database;
+    constructor(database: AppDatabase);
+    create(tokenHash: string, expiresAt: string): void;
+    valid(tokenHash: string, now: string): boolean;
+    revoke(tokenHash: string): void;
+    prune(now: string): number;
+}

package/dist/infrastructure/database/web-session-repository.js

@@ -0,0 +1,26 @@
+export class WebSessionRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    create(tokenHash, expiresAt) {
+        this.database.raw
+            .prepare("INSERT INTO web_sessions(token_hash,expires_at,created_at) VALUES(?,?,?)")
+            .run(tokenHash, expiresAt, new Date().toISOString());
+    }
+    valid(tokenHash, now) {
+        return Boolean(this.database.raw
+            .prepare("SELECT 1 AS ok FROM web_sessions WHERE token_hash=? AND expires_at > ?")
+            .get(tokenHash, now));
+    }
+    revoke(tokenHash) {
+        this.database.raw
+            .prepare("DELETE FROM web_sessions WHERE token_hash=?")
+            .run(tokenHash);
+    }
+    prune(now) {
+        return Number(this.database.raw
+            .prepare("DELETE FROM web_sessions WHERE expires_at <= ?")
+            .run(now).changes);
+    }
+}

package/dist/infrastructure/http/http-server.d.ts

@@ -0,0 +1,26 @@
+import type { AddressInfo } from "node:net";
+import type { McpHttpHandler } from "@modelcontextprotocol/server";
+import type { ChatRoomConfig } from "../../config/types.js";
+import type { WebRuntime } from "../../plugins/web/runtime.js";
+import type { RuntimeEventBus } from "../../app/event-bus.js";
+import type { ExternalAccessRegistry } from "../../app/external-access-registry.js";
+import type { AuthService } from "../../auth/auth-service.js";
+import type { PasskeyService } from "../../auth/passkey-service.js";
+import type { CloudController } from "../../plugins/cloud/controller.js";
+export declare class HttpServer {
+    private readonly config;
+    private readonly application;
+    private readonly eventBus;
+    private readonly auth;
+    private readonly passkeys;
+    private readonly mcp;
+    private readonly cloud;
+    private server;
+    private readonly ingress;
+    private readonly startedAt;
+    private mcpRequestCount;
+    constructor(config: ChatRoomConfig, application: WebRuntime, eventBus: RuntimeEventBus, auth: AuthService, passkeys: PasskeyService, mcp: McpHttpHandler, externalAccess: ExternalAccessRegistry, cloud: CloudController);
+    start(): Promise<void>;
+    address(): AddressInfo | null;
+    close(): Promise<void>;
+}