tirtc-devtools-cli 0.0.13 → 0.0.15

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

@@ -1,727 +0,0 @@
-"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 HostCommandCoordinator_1 = require("./HostCommandCoordinator");
-const TokenTool_1 = require("./TokenTool");
-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;
-    commandCoordinator;
-    isInitialized = false;
-    eventCounter = 1;
-    commandSequence = 1;
-    tokenTool;
-    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.commandCoordinator = new HostCommandCoordinator_1.HostCommandCoordinator(this.state, this.runtimeAdapter, (family, kind, payload) => this.writeEvent(family, kind, payload), () => this.snapshotPendingConnectionSummary(), (payload) => this.noteIncomingConnection(payload));
-        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 === 'connection.accepted') {
-            this.noteIncomingConnection(payload);
-            this.activatePendingStreamsOnConnected();
-            return;
-        }
-        if (kind === 'connection.disconnected') {
-            this.handleIncomingConnectionDisconnected(payload);
-            return;
-        }
-        if (kind === 'command.remote.requested') {
-            this.commandCoordinator.handleInboundRemoteCommandRequest(payload);
-            return;
-        }
-        if (kind === 'transport.remote.request_audio' ||
-            kind === 'transport.remote.request_video' ||
-            kind === 'transport.remote.request_iframe') {
-            const streamId = Number(payload.streamId);
-            if (!Number.isFinite(streamId)) {
-                return;
-            }
-            const media = kind === 'transport.remote.request_audio' ? 'audio' : 'video';
-            this.noteIncomingConnection(payload);
-            this.maybeAutoStartStreamFromRemoteDemand(streamId, media, payload);
-        }
-    }
-    snapshotPendingConnectionSummary() {
-        return {
-            state: this.state.connection.state,
-            direction: this.state.connection.direction,
-            peerId: this.state.connection.peerId,
-        };
-    }
-    noteIncomingConnection(payload) {
-        if (this.state.connection.state === 'connected') {
-            return;
-        }
-        this.state.connection = {
-            state: 'connected',
-            direction: 'incoming',
-            peerId: typeof payload.peerId === 'string' && payload.peerId.length > 0 ? payload.peerId : undefined,
-            connectedAt: new Date().toISOString(),
-        };
-    }
-    handleIncomingConnectionDisconnected(payload) {
-        if (this.state.connection.state === 'idle' || this.state.connection.state === 'disconnected') {
-            return;
-        }
-        this.commandCoordinator.clearPendingRemoteCommands('connection_disconnect');
-        const disconnectedAt = new Date().toISOString();
-        this.state.connection = {
-            state: 'disconnected',
-            direction: 'incoming',
-            peerId: this.state.connection.peerId,
-            connectedAt: this.state.connection.connectedAt,
-            disconnectedAt,
-            reasonCode: typeof payload.reasonCode === 'string' && payload.reasonCode.length > 0
-                ? payload.reasonCode
-                : undefined,
-        };
-        for (const stream of this.state.streams.values()) {
-            if (stream.direction !== 'send') {
-                continue;
-            }
-            if (stream.state !== 'active') {
-                continue;
-            }
-            stream.state = 'pending_on_connection';
-            stream.updatedAt = disconnectedAt;
-            this.writeEvent('stream', 'state.pending_on_reconnect', {
-                streamId: stream.streamId,
-                media: stream.media,
-                direction: stream.direction,
-                at: disconnectedAt,
-            });
-        }
-    }
-    maybeAutoStartStreamFromRemoteDemand(streamId, media, payload) {
-        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/message/send':
-                return this.handleStreamMessageSend((0, HostProtocol_1.parseStreamMessageSendParams)(params));
-            case 'stream/receiveStart':
-                return this.handleStreamReceiveStart((0, HostProtocol_1.parseStreamReceiveStartParams)(params));
-            case 'stream/receiveStop':
-                return this.handleStreamReceiveStop((0, HostProtocol_1.parseStreamStopParams)(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/request':
-            case 'command/send':
-                return this.handleCommandSend((0, HostProtocol_1.parseCommandSendParams)(params));
-            case 'command/reply':
-                return this.handleCommandReply((0, HostProtocol_1.parseCommandReplyParams)(params));
-            case 'command/pending/list':
-                return this.handleCommandPendingList();
-            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: {},
-        };
-    }
-    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,
-            artifactPaths: this.artifactManager.getPaths(),
-        };
-    }
-    async handleHostShutdown() {
-        this.commandCoordinator.clearPendingRemoteCommands('host_shutdown');
-        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(),
-        };
-        if (params.bootstrapSendStreams && params.bootstrapSendStreams.length > 0) {
-            const bootstrapStreams = params.bootstrapSendStreams.map((streamParams) => ({
-                streamId: streamParams.streamId,
-                media: streamParams.media,
-                source: streamParams.source,
-            }));
-            const sendResults = this.runtimeAdapter.startSendStreams
-                ? await this.runtimeAdapter.startSendStreams(bootstrapStreams)
-                : await Promise.all(bootstrapStreams.map(async (streamParams) => await this.runtimeAdapter.startSendStream(streamParams.streamId, streamParams.media, streamParams.source)));
-            const updatedAt = new Date().toISOString();
-            bootstrapStreams.forEach((streamParams, index) => {
-                const stream = {
-                    streamId: streamParams.streamId,
-                    media: streamParams.media,
-                    direction: 'send',
-                    state: this.state.connection.state === 'connected' ? 'active' : 'pending_on_connection',
-                    source: streamParams.source,
-                    updatedAt,
-                };
-                this.state.streams.set(streamParams.streamId, stream);
-                this.state.streamSourceBindings.set(streamBindingKey(streamParams.streamId, streamParams.media), {
-                    streamId: streamParams.streamId,
-                    media: streamParams.media,
-                    source: streamParams.source,
-                    updatedAt,
-                });
-                this.writeEvent('stream', 'send.bootstrap.bound', {
-                    streamId: streamParams.streamId,
-                    media: streamParams.media,
-                    sourceMode: streamParams.source.mode,
-                    assetsDir: streamParams.source.local_assets.assets_dir,
-                    autoStarted: sendResults[index]?.autoStarted ?? false,
-                    workerPid: sendResults[index]?.workerPid,
-                    state: stream.state,
-                    at: updatedAt,
-                });
-            });
-        }
-        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.commandCoordinator.clearPendingRemoteCommands('service_stop');
-        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 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);
-        }
-        this.writeEvent("connection", "token.prepared", {
-            mode: 'manual',
-            peerId: params.peerId,
-            tokenLength: params.token.length,
-            at: new Date().toISOString(),
-        });
-        const resolvedServiceEntry = await this.runtimeAdapter.connect(params.serviceEntry, params.peerId, params.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.commandCoordinator.clearPendingRemoteCommands('connection_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 handleStreamMessageSend(params) {
-        const acceptedAt = new Date().toISOString();
-        this.writeEvent('stream', 'message.send.requested', {
-            streamId: params.streamId,
-            payloadPreview: params.payload.slice(0, 120),
-            payloadLength: params.payload.length,
-            at: acceptedAt,
-        });
-        try {
-            await this.runtimeAdapter.sendStreamMessage(params.streamId, params.payload);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.writeEvent('stream', 'message.send.failed', {
-                streamId: params.streamId,
-                payloadPreview: params.payload.slice(0, 120),
-                payloadLength: params.payload.length,
-                message,
-                at: new Date().toISOString(),
-            });
-            throw error;
-        }
-        this.writeEvent('stream', 'message.send.completed', {
-            streamId: params.streamId,
-            payloadPreview: params.payload.slice(0, 120),
-            payloadLength: params.payload.length,
-            at: new Date().toISOString(),
-        });
-        return {
-            streamId: params.streamId,
-            payloadLength: params.payload.length,
-            acceptedAt,
-        };
-    }
-    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 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 result = await this.commandCoordinator.handleCommandSend(params, this.commandSequence);
-        this.commandSequence += 1;
-        return result;
-    }
-    async handleCommandReply(params) {
-        return this.commandCoordinator.handleCommandReply(params);
-    }
-    async handleCommandPendingList() {
-        return this.commandCoordinator.handleCommandPendingList();
-    }
-    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()),
-            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;