tirtc-devtools-cli 0.0.1

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

@@ -0,0 +1,224 @@
+"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.RuntimeCredentialTokenIssuer = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+function pathExists(filePath) {
+    return fs.existsSync(filePath);
+}
+function ensureDir(dirPath) {
+    if (!pathExists(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+function fileMtimeMs(filePath) {
+    if (!pathExists(filePath)) {
+        return 0;
+    }
+    return fs.statSync(filePath).mtimeMs;
+}
+function parseExecError(error) {
+    if (!error || typeof error !== 'object') {
+        return String(error);
+    }
+    const typed = error;
+    const stderr = typeof typed.stderr === 'string' ? typed.stderr.trim() : typed.stderr?.toString('utf8').trim();
+    const stdout = typeof typed.stdout === 'string' ? typed.stdout.trim() : typed.stdout?.toString('utf8').trim();
+    if (stderr && stderr.length > 0) {
+        return stderr;
+    }
+    if (stdout && stdout.length > 0) {
+        return stdout;
+    }
+    if (typed.message) {
+        return typed.message;
+    }
+    if (typed.code !== undefined) {
+        return 'process exited with code ' + String(typed.code);
+    }
+    return 'process failed';
+}
+class RuntimeCredentialTokenIssuer {
+    repoRoot;
+    platform;
+    runtimeBundleRoot;
+    binding;
+    constructor(options) {
+        this.repoRoot = options.repoRoot;
+        this.platform = options.platform;
+        this.runtimeBundleRoot = options.runtimeBundleRoot;
+    }
+    resolveSourcePath() {
+        const sourcePath = path.join(this.repoRoot, 'app-server/host/native/credential_napi.cc');
+        if (!pathExists(sourcePath)) {
+            throw new Error('credential source missing: ' + sourcePath);
+        }
+        return sourcePath;
+    }
+    resolveBuildOutputPath() {
+        return path.join(this.repoRoot, `.build/app-server/runtime-backed/credential_issue_token/${this.platform}/credential_napi.node`);
+    }
+    resolveRuntimeLibDir() {
+        const libDir = path.join(this.runtimeBundleRoot, 'lib');
+        if (!pathExists(libDir)) {
+            throw new Error('runtime-backed sdk libs are missing for platform ' + this.platform + ': ' + libDir);
+        }
+        return libDir;
+    }
+    resolveRuntimeIncludeDir() {
+        const includeDir = path.join(this.runtimeBundleRoot, 'include');
+        if (!pathExists(includeDir)) {
+            throw new Error('runtime-backed sdk headers are missing for platform ' + this.platform + ': ' + includeDir);
+        }
+        return includeDir;
+    }
+    resolveNodeHeadersDir() {
+        const configured = process.env.TIRTC_NODE_HEADERS_DIR;
+        const candidates = [
+            configured,
+            path.join(this.repoRoot, '.tmp/node-headers'),
+            path.join(this.repoRoot, '.tmp/node_headers'),
+        ].filter((v) => typeof v === 'string' && v.trim().length > 0);
+        for (const candidate of candidates) {
+            const normalized = path.resolve(candidate);
+            if (pathExists(path.join(normalized, 'node_api.h'))) {
+                return normalized;
+            }
+        }
+        throw new Error('node_api.h not found; set TIRTC_NODE_HEADERS_DIR to Node headers include dir');
+    }
+    async ensureCredentialAddon() {
+        const sourcePath = this.resolveSourcePath();
+        const outputPath = this.resolveBuildOutputPath();
+        ensureDir(path.dirname(outputPath));
+        const runtimeManifestPath = path.join(this.runtimeBundleRoot, 'manifest.txt');
+        const dependencyStampMs = Math.max(fileMtimeMs(sourcePath), fileMtimeMs(runtimeManifestPath));
+        const stale = fileMtimeMs(outputPath) < dependencyStampMs;
+        if (pathExists(outputPath) && !stale) {
+            return outputPath;
+        }
+        const runtimeLibDir = this.resolveRuntimeLibDir();
+        const runtimeIncludeDir = this.resolveRuntimeIncludeDir();
+        const nodeHeadersDir = this.resolveNodeHeadersDir();
+        const requiredRuntimeLibs = [
+            'libmatrix_runtime_credential.a',
+            'libmatrix_runtime_foundation_http.a',
+            'libmatrix_runtime_foundation_logging.a',
+            'libxlog.a',
+            'libssl.a',
+            'libcrypto.a',
+        ].map((name) => path.join(runtimeLibDir, name));
+        for (const libPath of requiredRuntimeLibs) {
+            if (!pathExists(libPath)) {
+                throw new Error('credential dependency missing: ' + libPath);
+            }
+        }
+        const args = [
+            '-O2',
+            '-std=c++17',
+            '-shared',
+            '-undefined',
+            'dynamic_lookup',
+            sourcePath,
+            '-o',
+            outputPath,
+            '-I',
+            runtimeIncludeDir,
+            '-I',
+            nodeHeadersDir,
+            ...requiredRuntimeLibs,
+            '-lpthread',
+            '-lm',
+        ];
+        if (this.platform === 'macos-arm64') {
+            args.push('-framework', 'Foundation', '-framework', 'CoreFoundation', '-lobjc', '-lz');
+        }
+        try {
+            await execFileAsync('c++', args, {
+                cwd: this.repoRoot,
+                env: process.env,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+        }
+        catch (error) {
+            throw new Error('failed to build credential napi addon: ' + parseExecError(error));
+        }
+        if (!pathExists(outputPath)) {
+            throw new Error('credential napi addon was not produced: ' + outputPath);
+        }
+        return outputPath;
+    }
+    async ensureBinding() {
+        if (this.binding) {
+            return this.binding;
+        }
+        const addonPath = await this.ensureCredentialAddon();
+        const loaded = require(addonPath);
+        if (!loaded || typeof loaded.issueToken !== 'function') {
+            throw new Error('credential addon missing issueToken() export');
+        }
+        this.binding = loaded;
+        return loaded;
+    }
+    async issueToken(options) {
+        const binding = await this.ensureBinding();
+        let token;
+        try {
+            token = binding.issueToken({
+                openapiEntry: options.openapiEntry,
+                accessId: options.accessId,
+                secretKey: options.secretKey,
+                localId: options.localId,
+                peerId: options.peerId,
+                userTtlSeconds: options.userTtlSeconds,
+                channelTtlSeconds: options.channelTtlSeconds,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error('issue token failed: ' + message);
+        }
+        const normalized = token.trim();
+        if (normalized.length === 0) {
+            throw new Error('issue token failed: empty token');
+        }
+        return normalized;
+    }
+}
+exports.RuntimeCredentialTokenIssuer = RuntimeCredentialTokenIssuer;

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

@@ -0,0 +1,37 @@
+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 {};

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

@@ -0,0 +1,186 @@
+"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.RuntimeReceiveWorkerManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const RuntimeHostBridge_1 = require("./native/RuntimeHostBridge");
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+function nowIsoString() {
+    return new Date().toISOString();
+}
+function sameDesiredConfig(left, right) {
+    return left.serviceEntry === right.serviceEntry &&
+        left.peerId === right.peerId &&
+        left.token === right.token &&
+        left.audioEnabled === right.audioEnabled &&
+        left.videoEnabled === right.videoEnabled &&
+        left.audioStreamId === right.audioStreamId &&
+        left.videoStreamId === right.videoStreamId &&
+        left.audioOutputPath === right.audioOutputPath &&
+        left.videoOutputPath === right.videoOutputPath &&
+        left.audioFramed === right.audioFramed &&
+        left.videoFramed === right.videoFramed;
+}
+class RuntimeReceiveWorkerManager {
+    bindings = new Map();
+    onLogLine;
+    bridge;
+    sharedSession;
+    constructor(options) {
+        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: 'downlink', stream, line: normalized });
+    }
+    buildDesiredConfig(serviceEntry, peerId, token) {
+        const desired = {
+            serviceEntry,
+            peerId,
+            token,
+            audioEnabled: false,
+            videoEnabled: false,
+        };
+        for (const binding of this.bindings.values()) {
+            if (binding.serviceEntry !== serviceEntry || binding.peerId !== peerId || binding.token !== token) {
+                continue;
+            }
+            if (binding.media === 'audio') {
+                desired.audioEnabled = true;
+                desired.audioStreamId = binding.streamId;
+                desired.audioOutputPath = binding.targetPath;
+                desired.audioFramed = binding.framed;
+            }
+            else if (binding.media === 'video') {
+                desired.videoEnabled = true;
+                desired.videoStreamId = binding.streamId;
+                desired.videoOutputPath = binding.targetPath;
+                desired.videoFramed = binding.framed;
+            }
+        }
+        return desired;
+    }
+    async stopSharedSession() {
+        if (!this.sharedSession) {
+            return;
+        }
+        this.bridge.stopDownlink();
+        this.sharedSession = undefined;
+        this.emitLog('stdout', '[runtime-backed receiver] session stopped');
+    }
+    async ensureSharedSession(serviceEntry, peerId, token) {
+        const desired = this.buildDesiredConfig(serviceEntry, peerId, token);
+        if (!desired.audioEnabled && !desired.videoEnabled) {
+            await this.stopSharedSession();
+            return { started: false };
+        }
+        const current = this.sharedSession;
+        if (current && sameDesiredConfig(current.config, desired)) {
+            return { started: false, pid: current.sessionId };
+        }
+        await this.stopSharedSession();
+        if (desired.audioOutputPath) {
+            ensureDir(path.dirname(desired.audioOutputPath));
+        }
+        if (desired.videoOutputPath) {
+            ensureDir(path.dirname(desired.videoOutputPath));
+        }
+        const args = [
+            '--service-entry=' + desired.serviceEntry,
+            '--peer-id=' + desired.peerId,
+            '--token=' + desired.token,
+        ];
+        if (desired.audioEnabled && desired.audioStreamId !== undefined && desired.audioOutputPath) {
+            args.push('--audio-stream-id=' + String(desired.audioStreamId));
+            args.push('--audio-output=' + desired.audioOutputPath);
+            if (desired.audioFramed) {
+                args.push('--audio-framed=1');
+            }
+        }
+        if (desired.videoEnabled && desired.videoStreamId !== undefined && desired.videoOutputPath) {
+            args.push('--video-stream-id=' + String(desired.videoStreamId));
+            args.push('--video-output=' + desired.videoOutputPath);
+            if (desired.videoFramed) {
+                args.push('--video-framed=1');
+            }
+        }
+        const sessionId = this.bridge.startDownlink(args);
+        this.sharedSession = {
+            startedAt: nowIsoString(),
+            config: desired,
+            sessionId,
+        };
+        this.emitLog('stdout', '[runtime-backed receiver] session started sessionId=' + String(sessionId));
+        return { started: true, pid: sessionId };
+    }
+    async syncBindings(bindings) {
+        this.bindings.clear();
+        for (const binding of bindings) {
+            this.bindings.set(binding.key, {
+                key: binding.key,
+                serviceEntry: binding.serviceEntry,
+                peerId: binding.peerId,
+                token: binding.token,
+                streamId: binding.streamId,
+                media: binding.media,
+                targetPath: binding.targetPath,
+                framed: binding.framed,
+            });
+        }
+        if (bindings.length === 0) {
+            await this.stopSharedSession();
+            return { started: false };
+        }
+        const first = bindings[0];
+        return await this.ensureSharedSession(first.serviceEntry, first.peerId, first.token);
+    }
+    async stopAll() {
+        this.bindings.clear();
+        await this.stopSharedSession();
+    }
+}
+exports.RuntimeReceiveWorkerManager = RuntimeReceiveWorkerManager;

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

@@ -0,0 +1,42 @@
+type SendWorkerManagerOptions = {
+    repoRoot: string;
+    platform: string;
+    onLogLine?: (payload: {
+        source: 'uplink';
+        stream: 'stdout' | 'stderr';
+        line: string;
+        pid?: number;
+    }) => void;
+};
+type SendWorkerStartOptions = {
+    key: string;
+    serviceEntry: string;
+    license: string;
+    assetsDir: string;
+    streamId: number;
+    media: 'audio' | 'video';
+};
+export declare class RuntimeSendWorkerManager {
+    private readonly repoRoot;
+    private readonly bindings;
+    private readonly onLogLine?;
+    private readonly bridge;
+    private sharedSession?;
+    constructor(options: SendWorkerManagerOptions);
+    private emitLog;
+    private resolveFixtureAssetsDir;
+    private buildDesiredConfig;
+    private stopSharedSession;
+    private ensureSharedSession;
+    ensureServiceSession(serviceEntry: string, license: string): Promise<{
+        started: boolean;
+        pid?: number;
+    }>;
+    startDeviceStream(options: SendWorkerStartOptions): Promise<{
+        started: boolean;
+        pid?: number;
+    }>;
+    stopStream(key: string): Promise<void>;
+    stopAll(): Promise<void>;
+}
+export {};