tirtc-devtools-cli 0.0.1

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

@@ -0,0 +1,274 @@
+"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.RuntimeSendWorkerManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const RuntimeHostBridge_1 = require("./native/RuntimeHostBridge");
+function pathExists(filePath) {
+    return fs.existsSync(filePath);
+}
+function nowIsoString() {
+    return new Date().toISOString();
+}
+function ensureValidAssetsDir(assetsDir) {
+    const resolved = path.resolve(assetsDir);
+    let stats;
+    try {
+        stats = fs.statSync(resolved);
+    }
+    catch {
+        throw new Error('stream local assets directory does not exist: ' + resolved);
+    }
+    if (!stats.isDirectory()) {
+        throw new Error('stream local assets path is not a directory: ' + resolved);
+    }
+    const manifestPath = path.join(resolved, 'manifest.json');
+    if (!pathExists(manifestPath)) {
+        throw new Error('stream local assets manifest not found: ' + manifestPath);
+    }
+    return resolved;
+}
+function findPreparedAssetsDir(rootDir) {
+    if (!pathExists(rootDir)) {
+        return undefined;
+    }
+    const manifestPath = path.join(rootDir, 'manifest.json');
+    const audioIndexPath = path.join(rootDir, 'audio', 'audio_packets.csv');
+    const videoIndexPath = path.join(rootDir, 'video', 'video_packets.csv');
+    if (pathExists(manifestPath) && pathExists(audioIndexPath) && pathExists(videoIndexPath)) {
+        return rootDir;
+    }
+    let entries = [];
+    try {
+        entries = fs.readdirSync(rootDir, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    const dirs = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort();
+    for (const dirName of dirs) {
+        if (!dirName.includes('_runtime_local_assets_prepare_')) {
+            continue;
+        }
+        const candidate = path.join(rootDir, dirName);
+        const candidateManifest = path.join(candidate, 'manifest.json');
+        const candidateAudioIndex = path.join(candidate, 'audio', 'audio_packets.csv');
+        const candidateVideoIndex = path.join(candidate, 'video', 'video_packets.csv');
+        if (pathExists(candidateManifest) && pathExists(candidateAudioIndex) && pathExists(candidateVideoIndex)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function resolveFallbackFixtureDir(repoRoot) {
+    const explicit = process.env.TIRTC_MEDIA_FIXTURE_DIR;
+    if (explicit && explicit.trim().length > 0) {
+        return path.resolve(explicit.trim());
+    }
+    const candidateRoots = [
+        path.join(repoRoot, 'runtime/assets/.workspace/runtime-assets-current'),
+        path.join(repoRoot, '.build/runtime-assets-local-flat/bundle/runtime-assets-current'),
+        path.join(repoRoot, '.build/runtime-assets-workspace-flat/workspace/runtime-assets-current'),
+        path.join(repoRoot, '.build/runtime-assets-local-flat-skill-v2/bundle/runtime-assets-current'),
+    ];
+    for (const rootDir of candidateRoots) {
+        const resolved = findPreparedAssetsDir(rootDir);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return candidateRoots[0];
+}
+function sameDesiredConfig(left, right) {
+    return left.audioEnabled === right.audioEnabled &&
+        left.videoEnabled === right.videoEnabled &&
+        left.audioStreamId === right.audioStreamId &&
+        left.videoStreamId === right.videoStreamId;
+}
+class RuntimeSendWorkerManager {
+    repoRoot;
+    bindings = new Map();
+    onLogLine;
+    bridge;
+    sharedSession;
+    constructor(options) {
+        this.repoRoot = options.repoRoot;
+        this.onLogLine = options.onLogLine;
+        this.bridge = new RuntimeHostBridge_1.RuntimeHostBridge({
+            repoRoot: options.repoRoot,
+            platform: options.platform,
+        });
+    }
+    emitLog(stream, line) {
+        const normalized = line.trim();
+        if (!this.onLogLine || normalized.length === 0) {
+            return;
+        }
+        this.onLogLine({ source: 'uplink', stream, line: normalized });
+    }
+    resolveFixtureAssetsDir(serviceEntry, license, desired) {
+        const explicit = process.env.TIRTC_MEDIA_FIXTURE_DIR;
+        if (explicit && explicit.trim().length > 0) {
+            return path.resolve(explicit.trim());
+        }
+        if (!desired.audioEnabled && !desired.videoEnabled) {
+            return resolveFallbackFixtureDir(this.repoRoot);
+        }
+        const requiredMedias = [];
+        if (desired.audioEnabled) {
+            requiredMedias.push('audio');
+        }
+        if (desired.videoEnabled) {
+            requiredMedias.push('video');
+        }
+        const assetsDirs = [];
+        for (const media of requiredMedias) {
+            const found = Array.from(this.bindings.values()).find((binding) => (binding.serviceEntry === serviceEntry &&
+                binding.license === license &&
+                binding.media === media));
+            if (!found) {
+                throw new Error('missing local assets binding for media=' + media + ' serviceEntry=' + serviceEntry);
+            }
+            assetsDirs.push(found.assetsDir);
+        }
+        const selected = assetsDirs[0];
+        for (const candidate of assetsDirs) {
+            if (candidate !== selected) {
+                throw new Error('mismatched local assets dir across bound medias: ' + selected + ' vs ' + candidate);
+            }
+        }
+        return selected;
+    }
+    buildDesiredConfig(serviceEntry, license) {
+        const desired = {
+            audioEnabled: false,
+            videoEnabled: false,
+        };
+        for (const binding of this.bindings.values()) {
+            if (binding.serviceEntry !== serviceEntry || binding.license !== license) {
+                continue;
+            }
+            if (binding.media === 'audio') {
+                desired.audioEnabled = true;
+                desired.audioStreamId = binding.streamId;
+            }
+            else if (binding.media === 'video') {
+                desired.videoEnabled = true;
+                desired.videoStreamId = binding.streamId;
+            }
+        }
+        return desired;
+    }
+    async stopSharedSession() {
+        if (!this.sharedSession) {
+            return;
+        }
+        this.bridge.stopUplink();
+        this.sharedSession = undefined;
+        this.emitLog('stdout', '[runtime-backed sender] session stopped');
+    }
+    async ensureSharedSession(serviceEntry, license, keepAliveWhenNoStreams) {
+        const desired = this.buildDesiredConfig(serviceEntry, license);
+        if (!desired.audioEnabled && !desired.videoEnabled && !keepAliveWhenNoStreams) {
+            await this.stopSharedSession();
+            return { started: false };
+        }
+        const current = this.sharedSession;
+        if (current &&
+            current.serviceEntry === serviceEntry &&
+            current.license === license &&
+            sameDesiredConfig(current.config, desired)) {
+            return { started: false, pid: current.sessionId };
+        }
+        await this.stopSharedSession();
+        const fixtureDir = this.resolveFixtureAssetsDir(serviceEntry, license, desired);
+        const args = [
+            '--license=' + license,
+            '--fixture-dir=' + fixtureDir,
+            '--enable-audio=' + (desired.audioEnabled ? '1' : '0'),
+            '--enable-video=' + (desired.videoEnabled ? '1' : '0'),
+        ];
+        if (serviceEntry.trim().length > 0) {
+            args.push('--service-entry=' + serviceEntry);
+        }
+        if (desired.audioStreamId !== undefined) {
+            args.push('--audio-stream-id=' + String(desired.audioStreamId));
+        }
+        if (desired.videoStreamId !== undefined) {
+            args.push('--video-stream-id=' + String(desired.videoStreamId));
+        }
+        const sessionId = this.bridge.startUplink(args);
+        this.sharedSession = {
+            startedAt: nowIsoString(),
+            serviceEntry,
+            license,
+            config: desired,
+            sessionId,
+        };
+        this.emitLog('stdout', '[runtime-backed sender] session started sessionId=' + String(sessionId));
+        return { started: true, pid: sessionId };
+    }
+    async ensureServiceSession(serviceEntry, license) {
+        return await this.ensureSharedSession(serviceEntry, license, true);
+    }
+    async startDeviceStream(options) {
+        this.bindings.set(options.key, {
+            key: options.key,
+            serviceEntry: options.serviceEntry,
+            license: options.license,
+            assetsDir: ensureValidAssetsDir(options.assetsDir),
+            streamId: options.streamId,
+            media: options.media,
+        });
+        return await this.ensureSharedSession(options.serviceEntry, options.license, true);
+    }
+    async stopStream(key) {
+        this.bindings.delete(key);
+        const current = this.sharedSession;
+        if (!current) {
+            return;
+        }
+        await this.ensureSharedSession(current.serviceEntry, current.license, false);
+    }
+    async stopAll() {
+        this.bindings.clear();
+        await this.stopSharedSession();
+    }
+}
+exports.RuntimeSendWorkerManager = RuntimeSendWorkerManager;

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

@@ -0,0 +1,15 @@
+export type TokenQrcodeParams = {
+    payload: string;
+    outputStem?: string;
+};
+export type TokenQrcodeResult = {
+    payload: string;
+    asciiPath: string;
+    pngPath: string;
+};
+export declare class TokenTool {
+    private readonly debugDir;
+    constructor(artifactRootPath: string);
+    private makeStem;
+    generateQrcode(params: TokenQrcodeParams): Promise<TokenQrcodeResult>;
+}

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

@@ -0,0 +1,84 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const qrcode_1 = __importDefault(require("qrcode"));
+function nowStamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+class TokenTool {
+    debugDir;
+    constructor(artifactRootPath) {
+        this.debugDir = path.join(artifactRootPath, 'debug');
+        ensureDir(this.debugDir);
+    }
+    makeStem(prefix, preferred) {
+        const stem = preferred && preferred.trim().length > 0 ? preferred.trim() : `${prefix}-${nowStamp()}`;
+        return stem.replace(/[^a-zA-Z0-9._-]/g, '_');
+    }
+    async generateQrcode(params) {
+        const stem = this.makeStem('bootstrap', params.outputStem);
+        const asciiPath = path.join(this.debugDir, `${stem}.qr.txt`);
+        const pngPath = path.join(this.debugDir, `${stem}.qr.png`);
+        const ascii = await qrcode_1.default.toString(params.payload, {
+            type: 'terminal',
+            small: true,
+            errorCorrectionLevel: 'M',
+        });
+        await qrcode_1.default.toFile(pngPath, params.payload, {
+            type: 'png',
+            errorCorrectionLevel: 'M',
+            margin: 2,
+            width: 480,
+        });
+        fs.writeFileSync(asciiPath, ascii);
+        return {
+            payload: params.payload,
+            asciiPath,
+            pngPath,
+        };
+    }
+}
+exports.TokenTool = TokenTool;

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

@@ -0,0 +1,28 @@
+type PreviewMedia = 'audio' | 'video';
+export type PreviewRegistration = {
+    url: string;
+    token: string;
+    endpoint: string;
+};
+export declare class WebPreviewGateway {
+    private server?;
+    private serverStarting?;
+    private pollTimer?;
+    private readonly sources;
+    private readonly clients;
+    private token;
+    private port;
+    private parseStreamFilter;
+    private sourceMatchesFilter;
+    private startSources;
+    private stopSources;
+    private getStatus;
+    private ensureServer;
+    registerSource(outputId: string, media: PreviewMedia, streamId: number, filePath: string, onStart?: () => Promise<void>, onStop?: () => Promise<void>): Promise<PreviewRegistration>;
+    unregisterSource(outputId: string): void;
+    dispose(): void;
+    private pollOnce;
+    private writeEvent;
+    private broadcast;
+}
+export {};