tirtc-devtools-cli 0.0.13 → 0.0.15

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

@@ -1,636 +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.RuntimeBackedAdapter = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const RuntimeSendWorker_1 = require("./RuntimeSendWorker");
-const RuntimeReceiveWorker_1 = require("./RuntimeReceiveWorker");
-const WebPreviewGateway_1 = require("./WebPreviewGateway");
-function nowIsoString() {
-    return new Date().toISOString();
-}
-function pathExists(p) {
-    return fs.existsSync(p);
-}
-function ensureDir(dirPath) {
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-    }
-}
-function tryGetNumber(value) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value === 'string' && value.trim().length > 0) {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed)) {
-            return parsed;
-        }
-    }
-    return undefined;
-}
-function resolveRepoRoot() {
-    const explicit = process.env.TIRTC_REPO_ROOT;
-    const appServerRoot = process.env.TIRTC_APP_SERVER_ROOT;
-    const candidates = [
-        appServerRoot,
-        explicit,
-        process.cwd(),
-        path.resolve(process.cwd(), '..'),
-        path.resolve(__dirname, '../..'),
-        path.resolve(__dirname, '../../..'),
-        path.resolve(__dirname, '../../../..'),
-    ].filter((v) => typeof v === 'string' && v.trim().length > 0);
-    for (const candidate of candidates) {
-        const normalized = path.resolve(candidate);
-        if (pathExists(path.join(normalized, 'bin/runtime')) ||
-            pathExists(path.join(normalized, 'bin/native')) ||
-            pathExists(path.join(normalized, 'products/app-server/bin/runtime')) ||
-            pathExists(path.join(normalized, 'products/app-server'))) {
-            return normalized;
-        }
-    }
-    return appServerRoot && appServerRoot.trim().length > 0 ? path.resolve(appServerRoot) : path.resolve(process.cwd());
-}
-function resolveDefaultServiceEntry() {
-    const explicit = process.env.TIRTC_RUNTIME_SERVICE_ENTRY;
-    if (explicit && explicit.trim().length > 0) {
-        return explicit.trim();
-    }
-    return undefined;
-}
-function resolveOutputRoot() {
-    const explicitArtifactRoot = process.env.TIRTC_HOST_ARTIFACT_DIR;
-    if (explicitArtifactRoot && explicitArtifactRoot.trim().length > 0) {
-        return path.join(path.resolve(explicitArtifactRoot.trim()), 'received-media');
-    }
-    const explicit = process.env.TIRTC_HOST_OUTPUT_DIR;
-    if (explicit && explicit.trim().length > 0) {
-        return path.resolve(explicit.trim());
-    }
-    return path.join(path.resolve(process.cwd()), '.tmp', 'tirtc-devtools-cli', 'output');
-}
-function normalizeMedia(media) {
-    if (media === 'audio') {
-        return 'audio';
-    }
-    if (media === 'video') {
-        return 'video';
-    }
-    return undefined;
-}
-function resolveStreamAssetsDir(source) {
-    if (source.mode !== 'local_assets') {
-        throw new Error('unsupported stream source mode: ' + String(source.mode ?? '<unknown>'));
-    }
-    const assetsDir = path.resolve(source.local_assets.assets_dir);
-    let stats;
-    try {
-        stats = fs.statSync(assetsDir);
-    }
-    catch {
-        throw new Error('stream local assets directory does not exist: ' + assetsDir);
-    }
-    if (!stats.isDirectory()) {
-        throw new Error('stream local assets path is not a directory: ' + assetsDir);
-    }
-    const manifestPath = path.join(assetsDir, 'manifest.json');
-    if (!pathExists(manifestPath)) {
-        throw new Error('stream local assets manifest not found: ' + manifestPath);
-    }
-    return assetsDir;
-}
-function decodePayload(payloadEncoding, payload) {
-    if (payloadEncoding === 'base64') {
-        return Uint8Array.from(Buffer.from(payload, 'base64'));
-    }
-    return Uint8Array.from(Buffer.from(payload, 'utf8'));
-}
-function encodePayload(payload) {
-    const buffer = Buffer.from(payload);
-    const utf8Text = buffer.toString('utf8');
-    if (Buffer.from(utf8Text, 'utf8').equals(buffer)) {
-        return {
-            payloadEncoding: 'utf8',
-            payload: utf8Text,
-        };
-    }
-    return {
-        payloadEncoding: 'base64',
-        payload: buffer.toString('base64'),
-    };
-}
-class RuntimeBackedAdapter {
-    runtimeTarget;
-    hostEndpoint = 'stdio://runtime-backed';
-    runtimeBundleRoot;
-    repoRoot;
-    platform;
-    sendWorker;
-    receiveWorker;
-    eventHandler;
-    outputCounter = 1;
-    commandSequence = 1;
-    connected = false;
-    defaultServiceEntry;
-    activeService;
-    connectionContext;
-    outputs = new Map();
-    receiveStreams = new Map();
-    previewGateway = new WebPreviewGateway_1.WebPreviewGateway();
-    receiveRefreshTimer;
-    constructor(options) {
-        this.runtimeBundleRoot = options.runtimeBundleRoot;
-        this.platform = options.platform;
-        this.runtimeTarget = 'runtime-backed/' + options.platform;
-        this.repoRoot = resolveRepoRoot();
-        this.sendWorker = new RuntimeSendWorker_1.RuntimeSendWorkerManager({
-            repoRoot: this.repoRoot,
-            platform: this.platform,
-            onLogLine: (payload) => {
-                this.emit('logs', 'runtime.line', payload);
-            },
-            onRuntimeEvent: (kind, payload) => {
-                if (kind === 'connection.accepted') {
-                    this.connected = true;
-                }
-                else if (kind === 'connection.disconnected') {
-                    this.connected = false;
-                }
-                this.emit('runtime', kind, payload);
-            },
-        });
-        this.receiveWorker = new RuntimeReceiveWorker_1.RuntimeReceiveWorkerManager({
-            repoRoot: this.repoRoot,
-            platform: this.platform,
-            onLogLine: (payload) => {
-                this.emit('logs', 'runtime.line', payload);
-            },
-        });
-    }
-    setEventHandler(handler) {
-        this.eventHandler = handler;
-    }
-    emit(family, kind, payload) {
-        this.recordOutputEvent(family, kind, payload);
-        if (!this.eventHandler) {
-            return;
-        }
-        this.eventHandler(family, kind, payload);
-    }
-    recordOutputEvent(family, kind, payload) {
-        if (this.outputs.size === 0) {
-            return;
-        }
-        const payloadStreamId = tryGetNumber(payload.streamId);
-        const timestamp = nowIsoString();
-        for (const output of this.outputs.values()) {
-            if (output.receiveBoundEver) {
-                continue;
-            }
-            if (payloadStreamId !== undefined && payloadStreamId !== output.streamId) {
-                continue;
-            }
-            const line = JSON.stringify({
-                at: timestamp,
-                family,
-                kind,
-                streamId: output.streamId,
-                payload,
-            }) + '\n';
-            try {
-                fs.appendFileSync(output.targetPath, line, 'utf8');
-            }
-            catch {
-                // no-op
-            }
-        }
-    }
-    assertRuntimeBundleReady() {
-        const includePath = path.join(this.runtimeBundleRoot, 'include');
-        const libPath = path.join(this.runtimeBundleRoot, 'lib');
-        const manifestPath = path.join(this.runtimeBundleRoot, 'manifest.txt');
-        if (!pathExists(includePath) || !pathExists(libPath) || !pathExists(manifestPath)) {
-            throw new Error('runtime bundle is not ready at ' + this.runtimeBundleRoot);
-        }
-    }
-    resolveServiceEntry(serviceEntry) {
-        if (serviceEntry && serviceEntry.trim().length > 0) {
-            return serviceEntry;
-        }
-        if (!this.defaultServiceEntry) {
-            this.defaultServiceEntry = resolveDefaultServiceEntry();
-        }
-        return this.defaultServiceEntry ?? '';
-    }
-    scheduleReceiveRefresh() {
-        if (this.receiveRefreshTimer) {
-            clearTimeout(this.receiveRefreshTimer);
-        }
-        this.receiveRefreshTimer = setTimeout(() => {
-            this.receiveRefreshTimer = undefined;
-            void this.refreshReceiveWorker();
-        }, 80);
-    }
-    async refreshReceiveWorker() {
-        if (!this.connected || !this.connectionContext) {
-            await this.receiveWorker.stopAll();
-            return;
-        }
-        const bindings = [];
-        for (const attachment of this.outputs.values()) {
-            if (!attachment.media) {
-                continue;
-            }
-            bindings.push({
-                key: attachment.outputId + "/" + String(attachment.streamId) + "/" + attachment.media,
-                serviceEntry: this.connectionContext.serviceEntry,
-                peerId: this.connectionContext.peerId,
-                token: this.connectionContext.token,
-                streamId: attachment.streamId,
-                media: attachment.media,
-                targetPath: attachment.targetPath,
-                framed: attachment.consumer === 'web_preview',
-            });
-        }
-        await this.receiveWorker.syncBindings(bindings);
-    }
-    async startService(serviceEntry, license, timeoutMs) {
-        this.assertRuntimeBundleReady();
-        const resolvedServiceEntry = this.resolveServiceEntry(serviceEntry);
-        const keepaliveSession = await this.sendWorker.ensureServiceSession(resolvedServiceEntry, license);
-        this.activeService = {
-            serviceEntry: resolvedServiceEntry,
-            license,
-            startedAt: nowIsoString(),
-        };
-        this.emit('service', 'start.requested', {
-            serviceEntry: resolvedServiceEntry,
-            licensePresent: license.length > 0,
-            timeoutMs,
-            senderBootstrapStarted: keepaliveSession.started,
-            workerPid: keepaliveSession.pid,
-            at: nowIsoString(),
-        });
-        return resolvedServiceEntry;
-    }
-    async stopService() {
-        this.activeService = undefined;
-        await this.sendWorker.stopAll();
-        await this.receiveWorker.stopAll();
-        if (this.receiveRefreshTimer) {
-            clearTimeout(this.receiveRefreshTimer);
-            this.receiveRefreshTimer = undefined;
-        }
-        this.previewGateway.dispose();
-        this.emit('service', 'stop.requested', { at: nowIsoString() });
-    }
-    async connect(serviceEntry, peerId, token, timeoutMs) {
-        this.assertRuntimeBundleReady();
-        const resolvedServiceEntry = this.resolveServiceEntry(serviceEntry);
-        this.emit('connection', 'connect.requested', {
-            serviceEntry: resolvedServiceEntry,
-            peerId,
-            tokenPresent: token.length > 0,
-            timeoutMs,
-            at: nowIsoString(),
-        });
-        this.connected = true;
-        this.connectionContext = {
-            serviceEntry: resolvedServiceEntry,
-            peerId,
-            token,
-        };
-        this.emit('connection', 'connect.validated', {
-            serviceEntry: resolvedServiceEntry,
-            peerId,
-            at: nowIsoString(),
-        });
-        const activeService = this.activeService;
-        if (activeService) {
-            this.emit('stream', 'send.auto.resume.requested', {
-                serviceEntry: activeService.serviceEntry,
-                startedAt: activeService.startedAt,
-                at: nowIsoString(),
-            });
-        }
-        await this.refreshReceiveWorker();
-        return resolvedServiceEntry;
-    }
-    async disconnect() {
-        this.connected = false;
-        this.connectionContext = undefined;
-        this.receiveStreams.clear();
-        await this.sendWorker.stopAll();
-        await this.receiveWorker.stopAll();
-        if (this.receiveRefreshTimer) {
-            clearTimeout(this.receiveRefreshTimer);
-            this.receiveRefreshTimer = undefined;
-        }
-        this.previewGateway.dispose();
-        this.emit('connection', 'disconnect.requested', { at: nowIsoString() });
-    }
-    async startSendStream(streamId, media, source) {
-        const assetsDir = resolveStreamAssetsDir(source);
-        const activeService = this.activeService;
-        let autoStarted = false;
-        let workerPid;
-        if (activeService) {
-            const key = String(streamId) + '/' + media;
-            const startResult = await this.sendWorker.startDeviceStream({
-                key,
-                serviceEntry: activeService.serviceEntry,
-                license: activeService.license,
-                assetsDir,
-                streamId,
-                media: media === 'audio' ? 'audio' : 'video',
-            });
-            autoStarted = startResult.started;
-            workerPid = startResult.pid;
-        }
-        this.emit('stream', 'send.start.requested', {
-            streamId,
-            media,
-            sourceMode: source.mode,
-            assetsDir,
-            connected: this.connected,
-            workerPid,
-            autoStarted,
-            deferred: !activeService,
-            at: nowIsoString(),
-        });
-        return { autoStarted, workerPid };
-    }
-    async startSendStreams(streams) {
-        const activeService = this.activeService;
-        if (!activeService || streams.length === 0) {
-            return streams.map(() => ({ autoStarted: false }));
-        }
-        const bindings = streams.map((stream) => ({
-            key: String(stream.streamId) + '/' + stream.media,
-            serviceEntry: activeService.serviceEntry,
-            license: activeService.license,
-            assetsDir: resolveStreamAssetsDir(stream.source),
-            streamId: stream.streamId,
-            media: stream.media === 'audio' ? 'audio' : 'video',
-        }));
-        const startResult = await this.sendWorker.startDeviceStreams(bindings);
-        const startedAt = nowIsoString();
-        for (const binding of bindings) {
-            this.emit('stream', 'send.start.requested', {
-                streamId: binding.streamId,
-                media: binding.media,
-                sourceMode: 'local_assets',
-                assetsDir: binding.assetsDir,
-                connected: this.connected,
-                workerPid: startResult.pid,
-                autoStarted: startResult.started,
-                deferred: false,
-                at: startedAt,
-            });
-        }
-        return bindings.map(() => ({ autoStarted: startResult.started, workerPid: startResult.pid }));
-    }
-    async stopSendStream(streamId) {
-        const keys = [String(streamId) + '/audio', String(streamId) + '/video'];
-        for (const key of keys) {
-            await this.sendWorker.stopStream(key);
-        }
-        this.emit('stream', 'send.stop.requested', { streamId, at: nowIsoString() });
-    }
-    async sendStreamMessage(streamId, payload) {
-        if (!this.connected) {
-            throw new Error('connection is not established');
-        }
-        await this.sendWorker.sendStreamMessage(streamId, decodePayload('utf8', payload));
-        this.emit('stream', 'message.runtime.send', {
-            streamId,
-            payloadPreview: payload.slice(0, 120),
-            payloadLength: payload.length,
-            at: nowIsoString(),
-        });
-    }
-    async startReceiveStream(streamId, media) {
-        if (!this.connected) {
-            throw new Error('connection is not established');
-        }
-        const normalized = normalizeMedia(media);
-        if (!normalized) {
-            throw new Error('unsupported receive media: ' + media);
-        }
-        this.receiveStreams.set(streamId, normalized);
-        this.emit('stream', 'receive.start.requested', { streamId, media, at: nowIsoString() });
-        await this.refreshReceiveWorker();
-    }
-    async stopReceiveStream(streamId) {
-        this.receiveStreams.delete(streamId);
-        this.emit('stream', 'receive.stop.requested', { streamId, at: nowIsoString() });
-        await this.refreshReceiveWorker();
-    }
-    async attachOutput(streamId, consumer, mediaView, format, delivery, targetPath, maxFiles) {
-        if (!this.connected) {
-            throw new Error('connection is not established');
-        }
-        const outputId = 'rt-out-' + streamId + '-' + this.outputCounter;
-        this.outputCounter += 1;
-        const safeFormat = (format || 'bin').replace(/[^a-zA-Z0-9]/g, '').toLowerCase() || 'bin';
-        const resolvedTargetPath = targetPath && targetPath.trim().length > 0
-            ? path.resolve(targetPath)
-            : path.join(resolveOutputRoot(), `${outputId}.${safeFormat}`);
-        ensureDir(path.dirname(resolvedTargetPath));
-        let receiveMedia = this.receiveStreams.get(streamId);
-        if (!receiveMedia && consumer === 'web_preview') {
-            if (format.toLowerCase() === 'g711a' || format.toLowerCase() === 'alaw' || format.toLowerCase() === 'pcm') {
-                receiveMedia = 'audio';
-            }
-            else if (format.toLowerCase() === 'h264' || format.toLowerCase() === 'jpeg' || format.toLowerCase() === 'mjpeg') {
-                receiveMedia = 'video';
-            }
-            if (receiveMedia) {
-                this.receiveStreams.set(streamId, receiveMedia);
-            }
-        }
-        if (receiveMedia) {
-            for (const existing of this.outputs.values()) {
-                if (existing.streamId === streamId && existing.media === receiveMedia) {
-                    throw new Error(`output already attached for stream=${streamId} media=${receiveMedia}; detach existing output first`);
-                }
-            }
-        }
-        fs.writeFileSync(resolvedTargetPath, Buffer.alloc(0));
-        const attachedAt = nowIsoString();
-        let preview;
-        if (consumer === 'web_preview') {
-            if (!receiveMedia) {
-                throw new Error(`web_preview requires active receive stream binding for stream=${streamId}`);
-            }
-            preview = await this.previewGateway.registerSource(outputId, receiveMedia, streamId, resolvedTargetPath, async () => {
-                if (!this.connected) {
-                    throw new Error('connection is not established');
-                }
-                this.scheduleReceiveRefresh();
-                this.emit('stream', 'preview.start.requested', {
-                    streamId,
-                    media: receiveMedia,
-                    outputId,
-                    at: nowIsoString(),
-                });
-            }, async () => {
-                if (!this.connected) {
-                    return;
-                }
-                this.scheduleReceiveRefresh();
-                this.emit('stream', 'preview.stop.requested', {
-                    streamId,
-                    media: receiveMedia,
-                    outputId,
-                    at: nowIsoString(),
-                });
-            });
-        }
-        const attachment = {
-            outputId,
-            streamId,
-            media: receiveMedia,
-            consumer,
-            mediaView,
-            format,
-            delivery,
-            targetPath: resolvedTargetPath,
-            attachedAt,
-            receiveBoundEver: Boolean(receiveMedia),
-            preview,
-        };
-        this.outputs.set(outputId, attachment);
-        if (!receiveMedia) {
-            const bootstrapLine = JSON.stringify({
-                at: attachedAt,
-                family: 'stream',
-                kind: 'output.attach',
-                streamId,
-                outputId,
-                consumer,
-                mediaView,
-                format,
-                delivery,
-                maxFiles,
-            }) + '\n';
-            fs.appendFileSync(resolvedTargetPath, bootstrapLine, 'utf8');
-        }
-        if (receiveMedia && consumer !== 'web_preview') {
-            this.scheduleReceiveRefresh();
-        }
-        this.emit('stream', 'output.attach.requested', {
-            outputId,
-            streamId,
-            consumer,
-            mediaView,
-            format,
-            delivery,
-            targetPath: resolvedTargetPath,
-            maxFiles,
-            at: attachedAt,
-            runtimeDownlink: Boolean(receiveMedia),
-            preview,
-        });
-        return {
-            outputId,
-            targetPath: resolvedTargetPath,
-            attachedAt,
-            preview,
-        };
-    }
-    async detachOutput(outputId) {
-        const attachment = this.outputs.get(outputId);
-        if (attachment) {
-            if (attachment.consumer === 'web_preview') {
-                this.previewGateway.unregisterSource(outputId);
-            }
-            if (!attachment.receiveBoundEver) {
-                const line = JSON.stringify({
-                    at: nowIsoString(),
-                    family: 'stream',
-                    kind: 'output.detach',
-                    streamId: attachment.streamId,
-                    outputId,
-                }) + '\n';
-                try {
-                    fs.appendFileSync(attachment.targetPath, line, 'utf8');
-                }
-                catch {
-                    // no-op
-                }
-            }
-            this.outputs.delete(outputId);
-        }
-        await this.refreshReceiveWorker();
-        this.emit('stream', 'output.detach.requested', { outputId, at: nowIsoString() });
-    }
-    async sendCommand(commandId, payloadEncoding, payload, timeoutMs) {
-        if (!this.connected) {
-            throw new Error('connection is not established');
-        }
-        this.emit('command', 'send.requested', {
-            commandId,
-            payloadEncoding,
-            timeoutMs,
-            at: nowIsoString(),
-        });
-        const sequenceNumber = this.commandSequence;
-        this.commandSequence += 1;
-        const response = await this.sendWorker.requestCommand(commandId, decodePayload(payloadEncoding, payload), timeoutMs ?? 15000);
-        const encodedResponse = encodePayload(response.payload);
-        return {
-            sequenceNumber,
-            payloadEncoding: encodedResponse.payloadEncoding,
-            payload: encodedResponse.payload,
-        };
-    }
-    async replyRemoteCommand(remoteRequestId, commandId, payloadEncoding, payload) {
-        if (!this.connected) {
-            throw new Error('connection is not established');
-        }
-        this.emit('command', 'reply.requested', {
-            remoteRequestId,
-            commandId,
-            payloadEncoding,
-            payloadLength: payload.length,
-            at: nowIsoString(),
-        });
-        await this.sendWorker.replyRemoteCommand(remoteRequestId, commandId, decodePayload(payloadEncoding, payload));
-    }
-}
-exports.RuntimeBackedAdapter = RuntimeBackedAdapter;

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

@@ -1,37 +0,0 @@
-type ReceiveWorkerManagerOptions = {
-    repoRoot: string;
-    platform: string;
-    onLogLine?: (payload: {
-        source: 'downlink';
-        stream: 'stdout' | 'stderr';
-        line: string;
-        pid?: number;
-    }) => void;
-};
-type ReceiveWorkerStartOptions = {
-    key: string;
-    serviceEntry: string;
-    peerId: string;
-    token: string;
-    streamId: number;
-    media: 'audio' | 'video';
-    targetPath: string;
-    framed: boolean;
-};
-export declare class RuntimeReceiveWorkerManager {
-    private readonly bindings;
-    private readonly onLogLine?;
-    private readonly bridge;
-    private sharedSession?;
-    constructor(options: ReceiveWorkerManagerOptions);
-    private emitLog;
-    private buildDesiredConfig;
-    private stopSharedSession;
-    private ensureSharedSession;
-    syncBindings(bindings: ReceiveWorkerStartOptions[]): Promise<{
-        started: boolean;
-        pid?: number;
-    }>;
-    stopAll(): Promise<void>;
-}
-export {};