tirtc-devtools-cli 0.0.1

package/vendor/app-server/dist/protocol/contract.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugTokenQrcodeResultSchema = exports.DebugTokenQrcodeRequestSchema = exports.StreamRequestPolicySetRequestSchema = exports.StreamRequestPolicySchema = exports.EventsSubscribeRequestSchema = exports.CommandSendRequestSchema = exports.OutputAttachRequestSchema = exports.StreamSendStartRequestSchema = exports.ConnectionConnectRequestSchema = exports.ServiceStartRequestSchema = exports.ArtifactExportResultSchema = exports.ReportDocumentSchema = exports.ErrorSummarySchema = exports.CommandSendResultSchema = exports.CommandResponseSchema = exports.OutputAttachmentSchema = exports.HostStatusSchema = exports.ArtifactPathsSchema = exports.StreamSnapshotSchema = exports.StreamSourceSchema = exports.StreamLocalAssetsSchema = exports.ConnectionSnapshotSchema = exports.ServiceSnapshotSchema = exports.EventEnvelopeSchema = exports.ErrorResponseSchema = exports.InitializedNotificationSchema = exports.InitializeResultSchema = exports.InitializeRequestSchema = void 0;
+const zod_1 = require("zod");
+exports.InitializeRequestSchema = zod_1.z.object({
+    protocolVersion: zod_1.z.string(),
+    clientInfo: zod_1.z.object({
+        name: zod_1.z.string(),
+        version: zod_1.z.string(),
+        title: zod_1.z.string().optional()
+    }),
+    capabilities: zod_1.z.object({
+        experimentalApi: zod_1.z.boolean().optional(),
+        optOutNotificationMethods: zod_1.z.array(zod_1.z.string()).optional()
+    }).optional()
+});
+exports.InitializeResultSchema = zod_1.z.object({
+    serverInfo: zod_1.z.object({
+        name: zod_1.z.string(),
+        version: zod_1.z.string()
+    }),
+    protocolVersion: zod_1.z.string(),
+    runtimeTarget: zod_1.z.string(),
+    hostEndpoint: zod_1.z.string(),
+    capabilities: zod_1.z.record(zod_1.z.any())
+});
+exports.InitializedNotificationSchema = zod_1.z.object({});
+exports.ErrorResponseSchema = zod_1.z.object({
+    reasonCode: zod_1.z.string(),
+    message: zod_1.z.string(),
+    retryable: zod_1.z.boolean()
+});
+exports.EventEnvelopeSchema = zod_1.z.object({
+    eventId: zod_1.z.string(),
+    timestamp: zod_1.z.string(),
+    family: zod_1.z.string(),
+    kind: zod_1.z.string(),
+    payload: zod_1.z.record(zod_1.z.any())
+});
+exports.ServiceSnapshotSchema = zod_1.z.object({
+    state: zod_1.z.string(),
+    serviceEntry: zod_1.z.string().optional(),
+    localEndpoint: zod_1.z.string().optional(),
+    startedAt: zod_1.z.string().optional(),
+    stoppedAt: zod_1.z.string().optional(),
+    reasonCode: zod_1.z.string().optional()
+});
+exports.ConnectionSnapshotSchema = zod_1.z.object({
+    state: zod_1.z.string(),
+    direction: zod_1.z.string().optional(),
+    peerId: zod_1.z.string().optional(),
+    connectedAt: zod_1.z.string().optional(),
+    disconnectedAt: zod_1.z.string().optional(),
+    reasonCode: zod_1.z.string().optional()
+});
+exports.StreamLocalAssetsSchema = zod_1.z.object({
+    assets_dir: zod_1.z.string(),
+});
+exports.StreamSourceSchema = zod_1.z.object({
+    mode: zod_1.z.literal('local_assets'),
+    local_assets: exports.StreamLocalAssetsSchema,
+});
+exports.StreamSnapshotSchema = zod_1.z.object({
+    streamId: zod_1.z.number().int(),
+    media: zod_1.z.string(),
+    direction: zod_1.z.string(),
+    state: zod_1.z.string(),
+    source: exports.StreamSourceSchema.optional(),
+    updatedAt: zod_1.z.string()
+});
+exports.ArtifactPathsSchema = zod_1.z.object({
+    rootPath: zod_1.z.string(),
+    reportPath: zod_1.z.string(),
+    logsPath: zod_1.z.string(),
+    eventsPath: zod_1.z.string(),
+    receivedMediaPath: zod_1.z.string(),
+    prepareCachePath: zod_1.z.string()
+});
+exports.HostStatusSchema = zod_1.z.object({
+    hostEndpoint: zod_1.z.string(),
+    serverVersion: zod_1.z.string(),
+    protocolVersion: zod_1.z.string(),
+    runtimeTarget: zod_1.z.string(),
+    startedAt: zod_1.z.string(),
+    service: exports.ServiceSnapshotSchema,
+    connection: exports.ConnectionSnapshotSchema,
+    artifactPaths: exports.ArtifactPathsSchema
+});
+exports.OutputAttachmentSchema = zod_1.z.object({
+    outputId: zod_1.z.string(),
+    streamId: zod_1.z.number().int(),
+    consumer: zod_1.z.string(),
+    mediaView: zod_1.z.string(),
+    format: zod_1.z.string(),
+    delivery: zod_1.z.string(),
+    target: zod_1.z.string(),
+    attachedAt: zod_1.z.string(),
+    preview: zod_1.z.object({
+        url: zod_1.z.string(),
+        token: zod_1.z.string(),
+        endpoint: zod_1.z.string(),
+    }).optional(),
+});
+exports.CommandResponseSchema = zod_1.z.object({
+    sequenceNumber: zod_1.z.number().int(),
+    payloadEncoding: zod_1.z.string(),
+    payload: zod_1.z.string()
+});
+exports.CommandSendResultSchema = zod_1.z.object({
+    sequenceNumber: zod_1.z.number().int(),
+    commandId: zod_1.z.number().int(),
+    kind: zod_1.z.string(),
+    acceptedAt: zod_1.z.string(),
+    response: exports.CommandResponseSchema.optional()
+});
+exports.ErrorSummarySchema = zod_1.z.object({
+    reasonCode: zod_1.z.string(),
+    message: zod_1.z.string(),
+    retryable: zod_1.z.boolean()
+});
+exports.ReportDocumentSchema = zod_1.z.object({
+    status: zod_1.z.string(),
+    reasonCode: zod_1.z.string(),
+    summary: zod_1.z.string(),
+    service: exports.ServiceSnapshotSchema,
+    connection: exports.ConnectionSnapshotSchema,
+    streams: zod_1.z.array(exports.StreamSnapshotSchema),
+    artifacts: exports.ArtifactPathsSchema,
+    lastError: exports.ErrorSummarySchema.optional()
+});
+exports.ArtifactExportResultSchema = zod_1.z.object({
+    outputPath: zod_1.z.string(),
+    exportedAt: zod_1.z.string()
+});
+exports.ServiceStartRequestSchema = zod_1.z.object({
+    serviceEntry: zod_1.z.string().optional(),
+    license: zod_1.z.string(),
+    timeoutMs: zod_1.z.number().int()
+});
+exports.ConnectionConnectRequestSchema = zod_1.z.object({
+    serviceEntry: zod_1.z.string().optional(),
+    peerId: zod_1.z.string(),
+    token: zod_1.z.string().optional(),
+    tokenMode: zod_1.z.enum(["manual", "auto"]).optional(),
+    autoToken: zod_1.z.object({
+        openapiEntry: zod_1.z.string().optional(),
+        accessId: zod_1.z.string(),
+        secretKey: zod_1.z.string(),
+        localId: zod_1.z.string().optional(),
+        userTtlSeconds: zod_1.z.number().int().optional(),
+        channelTtlSeconds: zod_1.z.number().int().optional(),
+    }).optional(),
+    timeoutMs: zod_1.z.number().int()
+}).refine((value) => Boolean(value.token) || Boolean(value.autoToken), {
+    message: "token or autoToken is required",
+});
+exports.StreamSendStartRequestSchema = zod_1.z.object({
+    streamId: zod_1.z.number().int(),
+    media: zod_1.z.string(),
+    source: exports.StreamSourceSchema,
+});
+exports.OutputAttachRequestSchema = zod_1.z.object({
+    streamId: zod_1.z.number().int(),
+    consumer: zod_1.z.string(),
+    mediaView: zod_1.z.string(),
+    format: zod_1.z.string(),
+    delivery: zod_1.z.string(),
+    targetPath: zod_1.z.string().optional(),
+    maxFiles: zod_1.z.number().int().optional()
+});
+exports.CommandSendRequestSchema = zod_1.z.object({
+    commandId: zod_1.z.number().int(),
+    kind: zod_1.z.string(),
+    payloadEncoding: zod_1.z.string(),
+    payload: zod_1.z.string(),
+    replyToSequenceNumber: zod_1.z.number().int().optional(),
+    awaitResponse: zod_1.z.boolean().optional(),
+    timeoutMs: zod_1.z.number().int().optional()
+});
+exports.EventsSubscribeRequestSchema = zod_1.z.object({
+    families: zod_1.z.array(zod_1.z.string())
+});
+exports.StreamRequestPolicySchema = zod_1.z.object({
+    mode: zod_1.z.enum(['manual', 'auto-if-bound'])
+});
+exports.StreamRequestPolicySetRequestSchema = zod_1.z.object({
+    mode: zod_1.z.enum(['manual', 'auto-if-bound'])
+});
+exports.DebugTokenQrcodeRequestSchema = zod_1.z.object({
+    payload: zod_1.z.string(),
+    outputStem: zod_1.z.string().optional()
+});
+exports.DebugTokenQrcodeResultSchema = zod_1.z.object({
+    payload: zod_1.z.string(),
+    qrAsciiPath: zod_1.z.string(),
+    qrPngPath: zod_1.z.string(),
+    generatedAt: zod_1.z.string()
+});

package/vendor/app-server/dist/protocol-client/index.d.ts

@@ -0,0 +1,25 @@
+import { EventEmitter } from 'events';
+export interface Transport {
+    send(data: string): void;
+    onMessage(handler: (data: string) => void): void;
+    onClose(handler: () => void): void;
+    onError(handler: (error: Error) => void): void;
+}
+export declare class AppServerClient extends EventEmitter {
+    private transport;
+    private pendingRequests;
+    initialized: boolean;
+    private buffer;
+    constructor(transport: Transport);
+    private rejectAllPending;
+    private handleData;
+    private handleMessage;
+    sendRequest(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+    sendNotification(method: string, params?: unknown): void;
+    initialize(clientInfo: {
+        name: string;
+        version: string;
+        title?: string;
+    }, capabilities?: unknown): Promise<unknown>;
+    subscribeEvents(families: string[]): Promise<unknown>;
+}

package/vendor/app-server/dist/protocol-client/index.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppServerClient = void 0;
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+class AppServerClient extends events_1.EventEmitter {
+    transport;
+    pendingRequests;
+    initialized = false;
+    buffer = '';
+    constructor(transport) {
+        super();
+        this.transport = transport;
+        this.pendingRequests = new Map();
+        this.transport.onMessage((data) => this.handleData(data));
+        this.transport.onError((error) => {
+            this.emit('error', error);
+            this.rejectAllPending(error);
+        });
+        this.transport.onClose(() => {
+            const error = new Error('transport closed');
+            this.emit('close');
+            this.rejectAllPending(error);
+        });
+    }
+    rejectAllPending(error) {
+        for (const [id, req] of this.pendingRequests.entries()) {
+            this.pendingRequests.delete(id);
+            if (req.timeoutTimer) {
+                clearTimeout(req.timeoutTimer);
+            }
+            req.reject(error);
+        }
+    }
+    handleData(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                const msg = JSON.parse(line);
+                this.handleMessage(msg);
+            }
+            catch {
+                this.emit('error', new Error(`Failed to parse message: ${line}`));
+            }
+        }
+    }
+    handleMessage(msg) {
+        if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
+            const req = this.pendingRequests.get(msg.id);
+            if (req) {
+                this.pendingRequests.delete(msg.id);
+                if (req.timeoutTimer) {
+                    clearTimeout(req.timeoutTimer);
+                }
+                if (msg.error !== undefined) {
+                    req.reject(msg.error);
+                }
+                else {
+                    req.resolve(msg.result);
+                }
+            }
+            return;
+        }
+        if (msg.method !== undefined && msg.id === undefined) {
+            this.emit('notification', msg.method, msg.params);
+            if (msg.method === 'events/event') {
+                this.emit('event', msg.params);
+            }
+        }
+    }
+    async sendRequest(method, params, timeoutMs = 30_000) {
+        const id = (0, crypto_1.randomUUID)();
+        return await new Promise((resolve, reject) => {
+            const pending = { resolve, reject };
+            pending.timeoutTimer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`request timeout after ${timeoutMs}ms: ${method}`));
+            }, timeoutMs);
+            this.pendingRequests.set(id, pending);
+            const payload = JSON.stringify({
+                id,
+                method,
+                params,
+            });
+            this.transport.send(`${payload}\n`);
+        });
+    }
+    sendNotification(method, params) {
+        const payload = JSON.stringify({
+            method,
+            params
+        });
+        this.transport.send(`${payload}\n`);
+    }
+    async initialize(clientInfo, capabilities) {
+        const result = await this.sendRequest('initialize', {
+            protocolVersion: '1.0.0',
+            clientInfo,
+            capabilities
+        });
+        this.sendNotification('initialized');
+        this.initialized = true;
+        return result;
+    }
+    async subscribeEvents(families) {
+        return await this.sendRequest('events/subscribe', { families });
+    }
+}
+exports.AppServerClient = AppServerClient;

package/vendor/app-server/dist/src/index.d.ts

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

package/vendor/app-server/dist/src/index.js

@@ -0,0 +1,294 @@
+"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 });
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const ArtifactManager_1 = require("../host/ArtifactManager");
+const HostServer_1 = require("../host/HostServer");
+const RuntimeAdapter_1 = require("../host/RuntimeAdapter");
+const HOST_VERSION = '1.0.0';
+const PROTOCOL_VERSION = '1.0.0';
+const args = process.argv.slice(2);
+const kSessionLoggingEventIntervalMs = 500;
+if (args.includes('--version') || args.includes('-v')) {
+    console.log('Host Version: ' + HOST_VERSION);
+    console.log('Protocol Version: ' + PROTOCOL_VERSION);
+    process.exit(0);
+}
+function readFlagValue(flag) {
+    const idx = args.indexOf(flag);
+    if (idx < 0) {
+        return undefined;
+    }
+    const value = args[idx + 1];
+    if (!value || value.startsWith('-')) {
+        throw new Error(`Missing value for ${flag}`);
+    }
+    return value;
+}
+function resolveRuntimePlatform() {
+    const raw = process.env.TIRTC_RUNTIME_PLATFORM;
+    if (raw && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (os.platform() === 'darwin' && os.arch() === 'arm64') {
+        return 'macos-arm64';
+    }
+    return 'linux-x64';
+}
+function resolveRuntimeBundleRoot(platform) {
+    const explicit = process.env.TIRTC_RUNTIME_BUNDLE_ROOT;
+    if (explicit && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    const appServerRoot = process.env.TIRTC_APP_SERVER_ROOT;
+    const candidates = [
+        appServerRoot ? path.resolve(appServerRoot, 'bin/runtime', platform) : '',
+        path.resolve(__dirname, '../bin/runtime', platform),
+        path.resolve(__dirname, '../../bin/runtime', platform),
+        path.resolve(process.cwd(), 'bin/runtime', platform),
+        path.resolve(process.cwd(), '../bin/runtime', platform),
+    ].filter((entry) => entry.length > 0);
+    for (const candidate of candidates) {
+        const manifest = path.join(candidate, 'manifest.txt');
+        if (fs.existsSync(manifest)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function resolveArtifactRoot() {
+    const explicit = process.env.TIRTC_HOST_ARTIFACT_DIR;
+    if (explicit && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    return path.join(os.tmpdir(), 'tirtc-artifacts');
+}
+function resolveHostLogDir() {
+    const explicit = process.env.TIRTC_HOST_LOG_DIR;
+    if (explicit && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    return path.join(resolveArtifactRoot(), 'logs');
+}
+function resolveConsoleMirrorEnabled() {
+    const raw = process.env.TIRTC_HOST_LOG_STDOUT_MIRROR;
+    if (!raw || raw.trim().length === 0) {
+        return true;
+    }
+    const normalized = raw.trim().toLowerCase();
+    return normalized !== '0' && normalized !== 'false' && normalized !== 'off' && normalized !== 'no';
+}
+function ensureArtifactRoot(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function createRuntimeAdapter() {
+    const platform = resolveRuntimePlatform();
+    const runtimeBundleRoot = resolveRuntimeBundleRoot(platform);
+    return new RuntimeAdapter_1.RuntimeBackedAdapter({
+        platform,
+        runtimeBundleRoot,
+    });
+}
+function resolveHostEndpoint(socketPath) {
+    const explicit = process.env.TIRTC_HOST_ENDPOINT;
+    if (explicit && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    if (socketPath && socketPath.trim().length > 0) {
+        return `ipc://${socketPath}`;
+    }
+    return 'stdio://runtime-backed';
+}
+function createSessionLogger(hostServer, logDir, mirrorToConsole) {
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    const runtimeLogPath = path.join(logDir, 'runtime.host.log');
+    let pending = [];
+    const flushTimer = setInterval(() => {
+        if (pending.length === 0) {
+            return;
+        }
+        const chunk = pending.join('');
+        pending = [];
+        try {
+            fs.appendFileSync(runtimeLogPath, chunk);
+        }
+        catch {
+            // no-op
+        }
+    }, kSessionLoggingEventIntervalMs);
+    const append = (level, message) => {
+        const line = `[${new Date().toISOString()}][${level}] ${message}`;
+        pending.push(line.endsWith('\n') ? line : line + '\n');
+        hostServer.appendHostLog(line);
+        if (mirrorToConsole) {
+            if (level === 'error') {
+                console.error(message);
+            }
+            else {
+                console.log(message);
+            }
+        }
+    };
+    return {
+        info: (message) => append('info', message),
+        error: (message) => append('error', message),
+        stop: () => {
+            clearInterval(flushTimer);
+            if (pending.length > 0) {
+                try {
+                    fs.appendFileSync(runtimeLogPath, pending.join(''));
+                }
+                catch {
+                    // no-op
+                }
+            }
+            pending = [];
+        },
+    };
+}
+function bindLineProtocol(input, output, hostServer, onClose) {
+    const rl = readline.createInterface({
+        input,
+        terminal: false,
+    });
+    rl.on('line', async (line) => {
+        if (!line.trim()) {
+            return;
+        }
+        const response = await hostServer.handleMessage(line);
+        if (response) {
+            output.write(response + '\n');
+        }
+    });
+    rl.on('close', () => {
+        if (onClose) {
+            onClose();
+        }
+    });
+}
+function startStdio(hostServer, runtimeTarget) {
+    bindLineProtocol(process.stdin, process.stdout, hostServer);
+    console.error('TiRTC App Server Host v' +
+        HOST_VERSION +
+        ' (Protocol v' +
+        PROTOCOL_VERSION +
+        ') started on stdio [runtimeTarget=' +
+        runtimeTarget +
+        ']');
+}
+function startSocket(socketPath, hostServer, runtimeTarget) {
+    if (fs.existsSync(socketPath)) {
+        fs.unlinkSync(socketPath);
+    }
+    const server = net.createServer((socket) => {
+        const sink = (event) => {
+            if (socket.destroyed) {
+                return;
+            }
+            socket.write(JSON.stringify({ method: 'events/event', params: event }) + '\n');
+        };
+        hostServer.addEventSink(sink);
+        bindLineProtocol(socket, socket, hostServer, () => {
+            hostServer.removeEventSink(sink);
+        });
+        socket.on('close', () => {
+            hostServer.removeEventSink(sink);
+        });
+        socket.on('error', () => {
+            hostServer.removeEventSink(sink);
+        });
+    });
+    server.listen(socketPath, () => {
+        console.error('TiRTC App Server Host v' +
+            HOST_VERSION +
+            ' (Protocol v' +
+            PROTOCOL_VERSION +
+            ') started on ipc://' +
+            socketPath +
+            ' [runtimeTarget=' +
+            runtimeTarget +
+            ']');
+    });
+    const cleanup = () => {
+        server.close();
+        if (fs.existsSync(socketPath)) {
+            fs.unlinkSync(socketPath);
+        }
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}
+const socketPath = readFlagValue('--socket');
+const artifactRoot = resolveArtifactRoot();
+ensureArtifactRoot(artifactRoot);
+const runtimeAdapter = createRuntimeAdapter();
+const artifactManager = new ArtifactManager_1.ArtifactManager(artifactRoot);
+artifactManager.setupLayout();
+const hostEndpoint = resolveHostEndpoint(socketPath);
+const hostServer = new HostServer_1.HostServer(artifactManager, runtimeAdapter, hostEndpoint);
+const hostLogDir = resolveHostLogDir();
+const sessionLogger = createSessionLogger(hostServer, hostLogDir, resolveConsoleMirrorEnabled());
+sessionLogger.info('TiRTC App Server Host v' +
+    HOST_VERSION +
+    ' (Protocol v' +
+    PROTOCOL_VERSION +
+    ') booting [runtimeTarget=' +
+    runtimeAdapter.runtimeTarget +
+    ']');
+process.on('uncaughtException', (error) => {
+    sessionLogger.error('uncaughtException: ' + (error instanceof Error ? error.stack ?? error.message : String(error)));
+});
+process.on('unhandledRejection', (reason) => {
+    sessionLogger.error('unhandledRejection: ' + (reason instanceof Error ? reason.stack ?? reason.message : String(reason)));
+});
+process.on('exit', () => {
+    sessionLogger.stop();
+});
+if (socketPath) {
+    startSocket(socketPath, hostServer, runtimeAdapter.runtimeTarget);
+    sessionLogger.info('listening on ipc://' + socketPath);
+}
+else {
+    startStdio(hostServer, runtimeAdapter.runtimeTarget);
+    sessionLogger.info('listening on stdio');
+}