tirtc-devtools-cli 0.0.1

package/vendor/app-server/dist/host/HostServer.js

@@ -0,0 +1,635 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostServer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const TokenTool_1 = require("./TokenTool");
+const RuntimeCredentialTokenIssuer_1 = require("./native/RuntimeCredentialTokenIssuer");
+const HostState_1 = require("./HostState");
+const HostProtocol_1 = require("./HostProtocol");
+function streamBindingKey(streamId, media) {
+    return `${streamId}/${media}`;
+}
+function resolveLocalAssetsDir(source) {
+    if (source.mode !== 'local_assets') {
+        throw new HostProtocol_1.HostProtocolError('invalid_request', 'Unsupported source.mode', false);
+    }
+    const assetsDir = path.resolve(source.local_assets.assets_dir);
+    let stats;
+    try {
+        stats = fs.statSync(assetsDir);
+    }
+    catch {
+        throw new HostProtocol_1.HostProtocolError('invalid_request', 'source.local_assets.assets_dir does not exist', false);
+    }
+    if (!stats.isDirectory()) {
+        throw new HostProtocol_1.HostProtocolError('invalid_request', 'source.local_assets.assets_dir must be a directory', false);
+    }
+    const manifestPath = path.join(assetsDir, 'manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+        throw new HostProtocol_1.HostProtocolError('invalid_request', 'source.local_assets.assets_dir missing manifest.json', false);
+    }
+    return assetsDir;
+}
+class HostServer {
+    state;
+    artifactManager;
+    runtimeAdapter;
+    isInitialized = false;
+    eventCounter = 1;
+    commandSequence = 1;
+    tokenTool;
+    runtimeCredentialTokenIssuer;
+    eventSinks = new Set();
+    constructor(artifactManager, runtimeAdapter, hostEndpoint) {
+        this.state = new HostState_1.HostState();
+        this.artifactManager = artifactManager;
+        this.runtimeAdapter = runtimeAdapter;
+        this.state.runtimeTarget = runtimeAdapter.runtimeTarget;
+        this.state.hostEndpoint = hostEndpoint ?? runtimeAdapter.hostEndpoint;
+        this.tokenTool = new TokenTool_1.TokenTool(this.artifactManager.getPaths().rootPath);
+        this.runtimeCredentialTokenIssuer = new RuntimeCredentialTokenIssuer_1.RuntimeCredentialTokenIssuer({
+            repoRoot: runtimeAdapter.repoRoot,
+            platform: runtimeAdapter.platform,
+            runtimeBundleRoot: runtimeAdapter.runtimeBundleRoot,
+        });
+        this.runtimeAdapter.setEventHandler((family, kind, payload) => {
+            this.handleRuntimeEvent(family, kind, payload);
+        });
+    }
+    async handleMessage(message) {
+        let request;
+        try {
+            request = (0, HostProtocol_1.parseRequest)(message);
+        }
+        catch {
+            return JSON.stringify({
+                error: {
+                    code: -32700,
+                    message: 'Parse error',
+                },
+            });
+        }
+        if (request.method === 'initialized') {
+            this.isInitialized = true;
+            return undefined;
+        }
+        const params = (0, HostProtocol_1.toParamsRecord)(request.params);
+        try {
+            const result = await this.dispatch(request.method, params);
+            if (request.id === undefined) {
+                return undefined;
+            }
+            return JSON.stringify({ id: request.id, result });
+        }
+        catch (error) {
+            if (request.id === undefined) {
+                return undefined;
+            }
+            const normalized = (0, HostProtocol_1.normalizeError)(error);
+            const response = {
+                id: request.id,
+                error: {
+                    code: -32000,
+                    message: normalized.message,
+                    data: {
+                        reasonCode: normalized.reasonCode,
+                        message: normalized.message,
+                        retryable: normalized.retryable,
+                    },
+                },
+            };
+            return JSON.stringify(response);
+        }
+    }
+    writeEvent(family, kind, payload) {
+        const event = {
+            eventId: 'evt-' + String(this.eventCounter++),
+            timestamp: new Date().toISOString(),
+            family,
+            kind,
+            payload,
+        };
+        this.artifactManager.writeEvent(event);
+        if (this.state.subscriptions.has(family) || this.state.subscriptions.has('*')) {
+            this.pushEvent(event);
+        }
+    }
+    pushEvent(event) {
+        for (const sink of this.eventSinks) {
+            try {
+                sink(event);
+            }
+            catch {
+                // no-op
+            }
+        }
+    }
+    addEventSink(sink) {
+        this.eventSinks.add(sink);
+    }
+    removeEventSink(sink) {
+        this.eventSinks.delete(sink);
+    }
+    appendHostLog(line) {
+        const withNewline = line.endsWith('\n') ? line : line + '\n';
+        this.artifactManager.appendHostLog(withNewline);
+        const normalized = withNewline.endsWith('\n') ? withNewline.slice(0, -1) : withNewline;
+        this.writeEvent('logs', 'host.line', { line: normalized });
+    }
+    handleRuntimeEvent(family, kind, payload) {
+        this.writeEvent(family, kind, payload);
+        if (family !== 'runtime') {
+            return;
+        }
+        if (kind === 'transport.remote.request') {
+            const streamId = Number(payload.streamId);
+            const mediaRaw = String(payload.media ?? '');
+            if ((mediaRaw === 'audio' || mediaRaw === 'video') && Number.isFinite(streamId)) {
+                this.maybeAutoStartStreamFromRemoteDemand(streamId, mediaRaw, payload);
+            }
+        }
+    }
+    maybeAutoStartStreamFromRemoteDemand(streamId, media, payload) {
+        if (this.state.streamRequestPolicy.mode !== 'auto-if-bound') {
+            return;
+        }
+        const key = streamBindingKey(streamId, media);
+        const bound = this.state.streamSourceBindings.get(key);
+        if (!bound) {
+            this.writeEvent('stream', 'send.auto.skipped', {
+                reason: 'source_not_bound',
+                streamId,
+                media,
+                at: new Date().toISOString(),
+            });
+            return;
+        }
+        const existing = this.state.streams.get(streamId);
+        if (existing && existing.direction === 'send' && existing.state === 'active') {
+            return;
+        }
+        const stream = {
+            streamId,
+            media,
+            direction: 'send',
+            state: this.state.connection.state === 'connected' ? 'active' : 'pending_on_connection',
+            source: bound.source,
+            updatedAt: new Date().toISOString(),
+        };
+        this.state.streams.set(streamId, stream);
+        this.writeEvent('stream', 'send.auto.started', {
+            streamId,
+            media,
+            sourceMode: bound.source.mode,
+            assetsDir: bound.source.local_assets.assets_dir,
+            trigger: payload.kind ?? 'remote_request',
+            at: new Date().toISOString(),
+        });
+    }
+    async dispatch(method, params) {
+        if (method === 'initialize') {
+            return this.handleInitialize();
+        }
+        if (!this.isInitialized) {
+            throw new HostProtocol_1.HostProtocolError('not_initialized', 'Initialize has not been called', false);
+        }
+        switch (method) {
+            case 'host/status':
+                return this.handleHostStatus();
+            case 'host/shutdown':
+                return this.handleHostShutdown();
+            case 'service/start':
+                return this.handleServiceStart((0, HostProtocol_1.parseServiceStartParams)(params));
+            case 'service/stop':
+                return this.handleServiceStop();
+            case 'connection/get':
+                return this.handleConnectionGet();
+            case 'connection/connect':
+                return this.handleConnectionConnect((0, HostProtocol_1.parseConnectionConnectParams)(params));
+            case 'connection/disconnect':
+                return this.handleConnectionDisconnect();
+            case 'stream/list':
+                return this.handleStreamList();
+            case 'stream/sendStart':
+                return this.handleStreamSendStart((0, HostProtocol_1.parseStreamSendStartParams)(params));
+            case 'stream/sendStop':
+                return this.handleStreamSendStop((0, HostProtocol_1.parseStreamStopParams)(params));
+            case 'stream/receiveStart':
+                return this.handleStreamReceiveStart((0, HostProtocol_1.parseStreamReceiveStartParams)(params));
+            case 'stream/receiveStop':
+                return this.handleStreamReceiveStop((0, HostProtocol_1.parseStreamStopParams)(params));
+            case 'stream/requestPolicy/get':
+                return this.handleStreamRequestPolicyGet();
+            case 'stream/requestPolicy/set':
+                return this.handleStreamRequestPolicySet((0, HostProtocol_1.parseStreamRequestPolicySetParams)(params));
+            case 'output/attach':
+                return this.handleOutputAttach((0, HostProtocol_1.parseOutputAttachParams)(params));
+            case 'output/detach':
+                return this.handleOutputDetach((0, HostProtocol_1.parseOutputDetachParams)(params));
+            case 'command/send':
+                return this.handleCommandSend((0, HostProtocol_1.parseCommandSendParams)(params));
+            case 'events/subscribe':
+                return this.handleEventsSubscribe((0, HostProtocol_1.parseEventsSubscribeParams)(params));
+            case 'artifact/readReport':
+                return this.handleArtifactReadReport();
+            case 'artifact/exportLogs':
+                return this.handleArtifactExportLogs((0, HostProtocol_1.parseArtifactExportParams)(params));
+            case 'artifact/exportReport':
+                return this.handleArtifactExportReport((0, HostProtocol_1.parseArtifactExportParams)(params));
+            case 'debug/token/qrcode':
+                return this.handleDebugTokenQrcode((0, HostProtocol_1.parseDebugTokenQrcodeParams)(params));
+            default:
+                throw new HostProtocol_1.HostProtocolError('method_not_found', `Method ${method} not found`, false);
+        }
+    }
+    async handleInitialize() {
+        return {
+            serverInfo: {
+                name: 'TiRTC App Server Host',
+                version: this.state.serverVersion,
+            },
+            protocolVersion: this.state.protocolVersion,
+            runtimeTarget: this.state.runtimeTarget,
+            hostEndpoint: this.state.hostEndpoint,
+            capabilities: {
+                streamRequestPolicy: {
+                    mode: this.state.streamRequestPolicy.mode,
+                },
+            },
+        };
+    }
+    async handleHostStatus() {
+        return {
+            hostEndpoint: this.state.hostEndpoint,
+            serverVersion: this.state.serverVersion,
+            protocolVersion: this.state.protocolVersion,
+            runtimeTarget: this.state.runtimeTarget,
+            startedAt: this.state.startedAt,
+            service: this.state.service,
+            connection: this.state.connection,
+            streamRequestPolicy: this.state.streamRequestPolicy,
+            artifactPaths: this.artifactManager.getPaths(),
+        };
+    }
+    async handleHostShutdown() {
+        return {
+            acceptedAt: new Date().toISOString(),
+            service: this.state.service,
+            connection: this.state.connection,
+        };
+    }
+    async handleServiceStart(params) {
+        if (this.state.service.state !== 'stopped') {
+            throw new HostProtocol_1.HostProtocolError('busy', 'Service is not stopped', false);
+        }
+        if (this.state.connection.state !== 'idle' &&
+            this.state.connection.state !== 'disconnected' &&
+            this.state.connection.state !== 'failed') {
+            throw new HostProtocol_1.HostProtocolError('busy', 'Connection is not idle', false);
+        }
+        const resolvedServiceEntry = await this.runtimeAdapter.startService(params.serviceEntry, params.license, params.timeoutMs);
+        this.state.service = {
+            state: 'waiting_peer',
+            serviceEntry: resolvedServiceEntry,
+            startedAt: new Date().toISOString(),
+        };
+        return this.state.service;
+    }
+    async handleServiceStop() {
+        if (this.state.service.state === 'stopped') {
+            return {
+                acceptedAt: new Date().toISOString(),
+                service: this.state.service,
+                connection: this.state.connection,
+            };
+        }
+        await this.runtimeAdapter.stopService();
+        this.state.service.state = 'stopped';
+        this.state.service.stoppedAt = new Date().toISOString();
+        return {
+            acceptedAt: new Date().toISOString(),
+            service: this.state.service,
+            connection: this.state.connection,
+        };
+    }
+    async handleConnectionGet() {
+        return this.state.connection;
+    }
+    async resolveConnectionToken(params) {
+        const trimmedToken = params.token?.trim();
+        const wantsAuto = params.tokenMode === "auto" || (!trimmedToken && params.autoToken !== undefined);
+        if (!wantsAuto) {
+            if (!trimmedToken || trimmedToken.length === 0) {
+                throw new HostProtocol_1.HostProtocolError("invalid_request", "token is required when tokenMode is manual", false);
+            }
+            return { token: trimmedToken, mode: "manual" };
+        }
+        if (!params.autoToken) {
+            throw new HostProtocol_1.HostProtocolError("invalid_request", "auto token mode requires autoToken config", false);
+        }
+        const issued = await this.runtimeCredentialTokenIssuer.issueToken({
+            openapiEntry: params.autoToken.openapiEntry,
+            accessId: params.autoToken.accessId,
+            secretKey: params.autoToken.secretKey,
+            localId: params.autoToken.localId ?? params.peerId,
+            peerId: params.peerId,
+            userTtlSeconds: params.autoToken.userTtlSeconds,
+            channelTtlSeconds: params.autoToken.channelTtlSeconds,
+        });
+        return { token: issued, mode: "auto" };
+    }
+    async handleConnectionConnect(params) {
+        if (this.state.connection.state !== "idle" &&
+            this.state.connection.state !== "disconnected" &&
+            this.state.connection.state !== "failed") {
+            throw new HostProtocol_1.HostProtocolError("busy", "Connection is not idle", false);
+        }
+        if (this.state.service.state !== "stopped") {
+            throw new HostProtocol_1.HostProtocolError("busy", "Service is not stopped", false);
+        }
+        const tokenResolve = await this.resolveConnectionToken(params);
+        this.writeEvent("connection", "token.prepared", {
+            mode: tokenResolve.mode,
+            peerId: params.peerId,
+            tokenLength: tokenResolve.token.length,
+            at: new Date().toISOString(),
+        });
+        const resolvedServiceEntry = await this.runtimeAdapter.connect(params.serviceEntry, params.peerId, tokenResolve.token, params.timeoutMs);
+        this.state.connection = {
+            state: 'connecting',
+            direction: 'outgoing',
+            peerId: params.peerId,
+        };
+        if (this.state.service.state === 'stopped') {
+            this.state.service.serviceEntry = resolvedServiceEntry;
+        }
+        this.state.connection.state = 'connected';
+        this.state.connection.connectedAt = new Date().toISOString();
+        await this.startDeferredSendStreamsOnConnected();
+        this.activatePendingStreamsOnConnected();
+        return this.state.connection;
+    }
+    async startDeferredSendStreamsOnConnected() {
+        if (this.state.service.state === 'stopped') {
+            return;
+        }
+        const now = new Date().toISOString();
+        for (const stream of this.state.streams.values()) {
+            if (stream.direction !== 'send' || stream.state !== 'pending_on_connection' || !stream.source) {
+                continue;
+            }
+            try {
+                const sendResult = await this.runtimeAdapter.startSendStream(stream.streamId, stream.media, stream.source);
+                this.writeEvent('stream', 'send.deferred.started_on_connection', {
+                    streamId: stream.streamId,
+                    media: stream.media,
+                    sourceMode: stream.source.mode,
+                    assetsDir: stream.source.local_assets.assets_dir,
+                    autoStarted: sendResult.autoStarted,
+                    workerPid: sendResult.workerPid,
+                    at: now,
+                });
+            }
+            catch (error) {
+                stream.state = 'failed';
+                stream.updatedAt = now;
+                const message = error instanceof Error ? error.message : String(error);
+                this.writeEvent('stream', 'send.deferred.failed_on_connection', {
+                    streamId: stream.streamId,
+                    media: stream.media,
+                    sourceMode: stream.source.mode,
+                    assetsDir: stream.source.local_assets.assets_dir,
+                    message,
+                    at: now,
+                });
+            }
+        }
+    }
+    activatePendingStreamsOnConnected() {
+        const now = new Date().toISOString();
+        for (const stream of this.state.streams.values()) {
+            if (stream.state !== 'pending_on_connection') {
+                continue;
+            }
+            stream.state = 'active';
+            stream.updatedAt = now;
+            this.writeEvent('stream', 'state.activated_on_connection', {
+                streamId: stream.streamId,
+                media: stream.media,
+                direction: stream.direction,
+                at: now,
+            });
+        }
+    }
+    async handleConnectionDisconnect() {
+        if (this.state.connection.state === 'idle' || this.state.connection.state === 'disconnected') {
+            return {
+                acceptedAt: new Date().toISOString(),
+                service: this.state.service,
+                connection: this.state.connection,
+            };
+        }
+        await this.runtimeAdapter.disconnect();
+        this.state.connection.state = 'disconnected';
+        this.state.connection.disconnectedAt = new Date().toISOString();
+        return {
+            acceptedAt: new Date().toISOString(),
+            service: this.state.service,
+            connection: this.state.connection,
+        };
+    }
+    async handleStreamList() {
+        return {
+            streams: Array.from(this.state.streams.values()),
+        };
+    }
+    async handleStreamSendStart(params) {
+        resolveLocalAssetsDir(params.source);
+        const hasActiveService = this.state.service.state !== 'stopped';
+        if (hasActiveService) {
+            await this.runtimeAdapter.startSendStream(params.streamId, params.media, params.source);
+        }
+        const stream = {
+            streamId: params.streamId,
+            media: params.media,
+            direction: 'send',
+            state: this.state.connection.state === 'connected' ? 'active' : 'pending_on_connection',
+            source: params.source,
+            updatedAt: new Date().toISOString(),
+        };
+        this.state.streams.set(params.streamId, stream);
+        this.state.streamSourceBindings.set(streamBindingKey(params.streamId, params.media), {
+            streamId: params.streamId,
+            media: params.media,
+            source: params.source,
+            updatedAt: new Date().toISOString(),
+        });
+        return stream;
+    }
+    async handleStreamSendStop(params) {
+        const stream = this.state.streams.get(params.streamId);
+        if (!stream || stream.direction !== 'send') {
+            throw new HostProtocol_1.HostProtocolError('stream_not_found', `Stream ${params.streamId} not found or not a send stream`, false);
+        }
+        await this.runtimeAdapter.stopSendStream(params.streamId);
+        stream.state = 'stopped';
+        stream.updatedAt = new Date().toISOString();
+        return stream;
+    }
+    async handleStreamReceiveStart(params) {
+        await this.runtimeAdapter.startReceiveStream(params.streamId, params.media);
+        const stream = {
+            streamId: params.streamId,
+            media: params.media,
+            direction: 'receive',
+            state: this.state.connection.state === 'connected' ? 'active' : 'pending_on_connection',
+            updatedAt: new Date().toISOString(),
+        };
+        this.state.streams.set(params.streamId, stream);
+        return stream;
+    }
+    async handleStreamReceiveStop(params) {
+        const stream = this.state.streams.get(params.streamId);
+        if (!stream || stream.direction !== 'receive') {
+            throw new HostProtocol_1.HostProtocolError('stream_not_found', `Stream ${params.streamId} not found or not a receive stream`, false);
+        }
+        await this.runtimeAdapter.stopReceiveStream(params.streamId);
+        stream.state = 'stopped';
+        stream.updatedAt = new Date().toISOString();
+        return stream;
+    }
+    async handleStreamRequestPolicyGet() {
+        return {
+            mode: this.state.streamRequestPolicy.mode,
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    async handleStreamRequestPolicySet(params) {
+        this.state.streamRequestPolicy.mode = params.mode;
+        const updatedAt = new Date().toISOString();
+        this.writeEvent('stream', 'request_policy.updated', {
+            mode: params.mode,
+            at: updatedAt,
+        });
+        return {
+            mode: this.state.streamRequestPolicy.mode,
+            updatedAt,
+        };
+    }
+    async handleOutputAttach(params) {
+        const attachment = await this.runtimeAdapter.attachOutput(params.streamId, params.consumer, params.mediaView, params.format, params.delivery, params.targetPath, params.maxFiles);
+        return {
+            outputId: attachment.outputId,
+            streamId: params.streamId,
+            consumer: params.consumer,
+            mediaView: params.mediaView,
+            format: params.format,
+            delivery: params.delivery,
+            target: attachment.targetPath,
+            attachedAt: attachment.attachedAt,
+            preview: attachment.preview,
+        };
+    }
+    async handleOutputDetach(params) {
+        await this.runtimeAdapter.detachOutput(params.outputId);
+        return {
+            outputId: params.outputId,
+            detachedAt: new Date().toISOString(),
+        };
+    }
+    async handleCommandSend(params) {
+        const response = await this.runtimeAdapter.sendCommand(params.commandId, params.kind, params.payloadEncoding, params.payload, params.replyToSequenceNumber, params.awaitResponse, params.timeoutMs);
+        return {
+            sequenceNumber: this.commandSequence++,
+            commandId: params.commandId,
+            kind: params.kind,
+            acceptedAt: new Date().toISOString(),
+            response,
+        };
+    }
+    async handleEventsSubscribe(params) {
+        const families = params.families ?? [];
+        for (const family of families) {
+            this.state.subscriptions.add(family);
+        }
+        this.appendHostLog('events subscribed: ' + (families.length > 0 ? families.join(',') : '(none)'));
+        return {
+            families,
+            subscribedAt: new Date().toISOString(),
+        };
+    }
+    async handleArtifactReadReport() {
+        const report = {
+            status: 'completed',
+            reasonCode: 'success',
+            summary: 'Report summary runtime-backed contract',
+            service: this.state.service,
+            connection: this.state.connection,
+            streams: Array.from(this.state.streams.values()),
+            streamRequestPolicy: this.state.streamRequestPolicy,
+            artifacts: this.artifactManager.getPaths(),
+            lastError: this.state.lastError,
+        };
+        this.artifactManager.writeReport(report);
+        return report;
+    }
+    async handleArtifactExportLogs(params) {
+        return {
+            outputPath: params.outputPath,
+            exportedAt: new Date().toISOString(),
+        };
+    }
+    async handleArtifactExportReport(params) {
+        return {
+            outputPath: params.outputPath,
+            exportedAt: new Date().toISOString(),
+        };
+    }
+    async handleDebugTokenQrcode(params) {
+        const qr = await this.tokenTool.generateQrcode({
+            payload: params.payload,
+            outputStem: params.outputStem,
+        });
+        return {
+            payload: qr.payload,
+            qrAsciiPath: qr.asciiPath,
+            qrPngPath: qr.pngPath,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+}
+exports.HostServer = HostServer;

package/vendor/app-server/dist/host/HostState.d.ts

@@ -0,0 +1,60 @@
+export interface ServiceSnapshot {
+    state: 'stopped' | 'starting' | 'waiting_peer' | 'stopping' | 'failed';
+    serviceEntry?: string;
+    localEndpoint?: string;
+    startedAt?: string;
+    stoppedAt?: string;
+    reasonCode?: string;
+}
+export interface ConnectionSnapshot {
+    state: 'idle' | 'connecting' | 'accepting' | 'connected' | 'disconnecting' | 'disconnected' | 'failed' | 'missed';
+    direction?: 'incoming' | 'outgoing';
+    peerId?: string;
+    connectedAt?: string;
+    disconnectedAt?: string;
+    reasonCode?: string;
+}
+export interface StreamSnapshot {
+    streamId: number;
+    media: 'audio' | 'video';
+    direction: 'send' | 'receive';
+    state: 'idle' | 'pending_on_connection' | 'starting' | 'active' | 'stopping' | 'stopped' | 'failed';
+    source?: StreamSource;
+    updatedAt: string;
+}
+export interface StreamLocalAssetsSource {
+    mode: 'local_assets';
+    local_assets: {
+        assets_dir: string;
+    };
+}
+export type StreamSource = StreamLocalAssetsSource;
+export type StreamRequestPolicyMode = 'manual' | 'auto-if-bound';
+export interface StreamRequestPolicy {
+    mode: StreamRequestPolicyMode;
+}
+export interface StreamSourceBinding {
+    streamId: number;
+    media: 'audio' | 'video';
+    source: StreamSource;
+    updatedAt: string;
+}
+export declare class HostState {
+    service: ServiceSnapshot;
+    connection: ConnectionSnapshot;
+    streams: Map<number, StreamSnapshot>;
+    subscriptions: Set<string>;
+    internalConnections: Set<string>;
+    streamRequestPolicy: StreamRequestPolicy;
+    streamSourceBindings: Map<string, StreamSourceBinding>;
+    protocolVersion: string;
+    serverVersion: string;
+    runtimeTarget: string;
+    hostEndpoint: string;
+    startedAt: string;
+    lastError?: {
+        reasonCode: string;
+        message: string;
+        retryable: boolean;
+    };
+}