tirtc-devtools-cli 0.0.1

package/dist/devtools/cli/src/media_assets.d.ts

@@ -0,0 +1,25 @@
+type PrepareMediaAssetsRequest = {
+    source: string;
+    outputRoot: string;
+    outputDir?: string;
+    overwrite?: boolean;
+};
+type PrepareMediaAssetsResult = {
+    assets_dir: string;
+    manifest_path: string;
+    cache_hit: boolean;
+};
+type ExecFileLike = (file: string, args: string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    maxBuffer: number;
+}) => Promise<{
+    stdout?: string | Buffer;
+    stderr?: string | Buffer;
+}>;
+type PrepareMediaAssetsOptions = {
+    repoRoot?: string;
+    execFile?: ExecFileLike;
+};
+export declare function prepareMediaAssets(request: PrepareMediaAssetsRequest, options?: PrepareMediaAssetsOptions): Promise<PrepareMediaAssetsResult>;
+export {};

package/dist/devtools/cli/src/media_assets.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareMediaAssets = prepareMediaAssets;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const embedded_paths_1 = require("./embedded_paths");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+function resolveRepoRoot(fromDir) {
+    const candidates = [
+        path_1.default.resolve(fromDir, '../../..'),
+        path_1.default.resolve(fromDir, '../../../../..'),
+    ];
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(path_1.default.join(candidate, 'runtime/script/prepare_runtime_media_dataset.sh'))) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function resolveDefaultRepoRoot() {
+    const explicitCwd = process.cwd();
+    if (fs_1.default.existsSync(path_1.default.join(explicitCwd, 'runtime/script/prepare_runtime_media_dataset.sh'))) {
+        return explicitCwd;
+    }
+    return resolveRepoRoot(__dirname);
+}
+function resolvePrepareScript(repoRoot) {
+    const embedded = (0, embedded_paths_1.resolveEmbeddedRuntimeScript)(__dirname);
+    if (embedded) {
+        return embedded;
+    }
+    return path_1.default.join(repoRoot, 'runtime/script/prepare_runtime_media_dataset.sh');
+}
+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();
+    if (stderr && stderr.length > 0) {
+        return stderr;
+    }
+    const stdout = typeof typed.stdout === 'string' ? typed.stdout.trim() : typed.stdout?.toString('utf8').trim();
+    if (stdout && stdout.length > 0) {
+        return stdout;
+    }
+    if (typed.message && typed.message.length > 0) {
+        return typed.message;
+    }
+    return 'process failed';
+}
+function assertPrepareRequest(request) {
+    if (!request.source || request.source.trim().length === 0) {
+        throw new Error('media assets prepare requires non-empty --source');
+    }
+    if (!request.outputRoot || request.outputRoot.trim().length === 0) {
+        throw new Error('media assets prepare requires non-empty --output-root');
+    }
+    if (request.outputDir !== undefined && request.outputDir.trim().length === 0) {
+        throw new Error('media assets prepare requires non-empty --output-dir when provided');
+    }
+}
+async function prepareMediaAssets(request, options = {}) {
+    assertPrepareRequest(request);
+    const repoRoot = options.repoRoot ? path_1.default.resolve(options.repoRoot) : resolveDefaultRepoRoot();
+    const execFile = options.execFile ?? execFileAsync;
+    const scriptPath = resolvePrepareScript(repoRoot);
+    if (!fs_1.default.existsSync(scriptPath)) {
+        throw new Error('media assets prepare backend missing: ' + scriptPath);
+    }
+    const ensureFfmpegScriptPath = (0, embedded_paths_1.resolveCliScriptPath)(__dirname, 'script/ensure_ffmpeg.sh');
+    if (!fs_1.default.existsSync(ensureFfmpegScriptPath)) {
+        throw new Error('ffmpeg bootstrap script missing: ' + ensureFfmpegScriptPath);
+    }
+    const source = path_1.default.resolve(request.source);
+    const outputRoot = path_1.default.resolve(request.outputRoot);
+    const args = ['--source', source, '--output-root', outputRoot];
+    if (request.outputDir) {
+        args.push('--output-dir', path_1.default.resolve(request.outputDir));
+    }
+    if (request.overwrite) {
+        args.push('--overwrite');
+    }
+    let stdout = '';
+    try {
+        const result = await execFile('bash', [scriptPath, ...args], {
+            cwd: repoRoot,
+            env: {
+                ...process.env,
+                TIRTC_ENSURE_FFMPEG_SCRIPT: ensureFfmpegScriptPath,
+            },
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        stdout = String(result.stdout ?? '').trim();
+    }
+    catch (error) {
+        throw new Error(parseExecError(error));
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error('media assets prepare returned malformed json: ' + stdout);
+    }
+    if (typeof parsed.assets_dir !== 'string' ||
+        typeof parsed.manifest_path !== 'string' ||
+        typeof parsed.cache_hit !== 'boolean') {
+        throw new Error('media assets prepare returned incomplete result');
+    }
+    return {
+        assets_dir: path_1.default.resolve(parsed.assets_dir),
+        manifest_path: path_1.default.resolve(parsed.manifest_path),
+        cache_hit: parsed.cache_hit,
+    };
+}

package/dist/devtools/cli/src/session_manager.d.ts

@@ -0,0 +1,25 @@
+export type SessionRole = 'idle' | 'service' | 'client';
+export type SessionRecord = {
+    sessionId: string;
+    hostEndpoint: string;
+    socketPath: string;
+    runtimePlatform: string;
+    runtimeBundleRoot: string;
+    artifactDir: string;
+    logDir: string;
+    pid: number;
+    startedAt: string;
+    role: SessionRole;
+};
+type CreateSessionOptions = {
+    logRootDir?: string;
+    consoleMirror?: boolean;
+    role?: SessionRole;
+};
+export declare function createSession(options?: CreateSessionOptions): SessionRecord;
+export declare function listSessions(): SessionRecord[];
+export declare function stopSession(sessionId: string): SessionRecord;
+export declare function stopAllSessions(): SessionRecord[];
+export declare function resolveSession(sessionId?: string): SessionRecord;
+export declare function setSessionRole(sessionId: string, role: SessionRole): SessionRecord;
+export {};

package/dist/devtools/cli/src/session_manager.js

@@ -0,0 +1,393 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSession = createSession;
+exports.listSessions = listSessions;
+exports.stopSession = stopSession;
+exports.stopAllSessions = stopAllSessions;
+exports.resolveSession = resolveSession;
+exports.setSessionRole = setSessionRole;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const embedded_paths_1 = require("./embedded_paths");
+const kStartupTimeoutMs = 5000;
+const kStartupPollIntervalMs = 100;
+function ensureDir(dir) {
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+}
+function sleepMs(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function getStateDir() {
+    const explicit = process.env.TIRTC_DEVTOOL_STATE_DIR;
+    if (explicit && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    return path_1.default.join(os_1.default.homedir(), '.tirtc-devtool');
+}
+function getSocketDir() {
+    const explicit = process.env.TIRTC_DEVTOOL_SOCKET_DIR;
+    if (explicit && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    return '/tmp';
+}
+function buildSocketPath(sessionId) {
+    const compact = sessionId.replace(/-/g, '').slice(0, 16);
+    return path_1.default.join(getSocketDir(), `tirtc-${compact}.sock`);
+}
+function getRegistryPath() {
+    return path_1.default.join(getStateDir(), 'sessions.json');
+}
+function loadRegistry() {
+    const file = getRegistryPath();
+    if (!fs_1.default.existsSync(file)) {
+        return { sessions: [] };
+    }
+    const parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+    return {
+        sessions: Array.isArray(parsed.sessions) ? parsed.sessions : [],
+    };
+}
+function saveRegistry(registry) {
+    ensureDir(getStateDir());
+    fs_1.default.writeFileSync(getRegistryPath(), JSON.stringify(registry, null, 2));
+}
+function pidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 1) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+function tryUnlink(filePath) {
+    if (!fs_1.default.existsSync(filePath)) {
+        return;
+    }
+    try {
+        fs_1.default.unlinkSync(filePath);
+    }
+    catch {
+        // no-op
+    }
+}
+function socketExists(socketPath) {
+    return fs_1.default.existsSync(socketPath);
+}
+function normalizeRole(role) {
+    return role === 'service' || role === 'client' ? role : 'idle';
+}
+function purgeDeadSessions(registry) {
+    const alive = [];
+    for (const session of registry.sessions) {
+        if (pidAlive(session.pid) && socketExists(session.socketPath)) {
+            alive.push({
+                ...session,
+                role: normalizeRole(session.role),
+            });
+            continue;
+        }
+        tryUnlink(session.socketPath);
+    }
+    return { sessions: alive };
+}
+function resolveRuntimePlatform() {
+    const raw = process.env.TIRTC_RUNTIME_PLATFORM;
+    if (raw && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (process.platform === 'darwin' && process.arch === 'arm64') {
+        return 'macos-arm64';
+    }
+    return 'linux-x64';
+}
+function resolveRuntimeBundleRoot(runtimePlatform) {
+    const explicit = process.env.TIRTC_RUNTIME_BUNDLE_ROOT;
+    if (explicit && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    const embedded = (0, embedded_paths_1.resolveEmbeddedRuntimeBundleRoot)(__dirname, runtimePlatform);
+    if (embedded) {
+        return embedded;
+    }
+    const execDir = path_1.default.dirname(process.execPath);
+    const candidates = [
+        path_1.default.resolve(execDir, 'runtime', runtimePlatform),
+        path_1.default.resolve(execDir, '../runtime', runtimePlatform),
+        path_1.default.resolve(__dirname, '../bin/runtime', runtimePlatform),
+        path_1.default.resolve(__dirname, '../../../../bin/runtime', runtimePlatform),
+        path_1.default.resolve(process.cwd(), 'bin/runtime', runtimePlatform),
+        path_1.default.resolve(process.cwd(), '../bin/runtime', runtimePlatform),
+    ];
+    for (const candidate of candidates) {
+        const manifest = path_1.default.join(candidate, 'manifest.txt');
+        if (fs_1.default.existsSync(manifest)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function getHostBinaryPath() {
+    const embedded = (0, embedded_paths_1.resolveEmbeddedHostBinary)(__dirname);
+    if (embedded) {
+        return embedded;
+    }
+    const candidates = [
+        path_1.default.resolve(__dirname, '../../../app-server/bin/tirtc-devtool-host.js'),
+        path_1.default.resolve(__dirname, '../../../../../../app-server/bin/tirtc-devtool-host.js'),
+        path_1.default.resolve(process.cwd(), '../app-server/bin/tirtc-devtool-host.js'),
+        path_1.default.resolve(process.cwd(), 'app-server/bin/tirtc-devtool-host.js'),
+    ];
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return 'tirtc-devtool-host';
+}
+function spawnDetachedHost(env, socketPath, processLogPath) {
+    const hostPath = getHostBinaryPath();
+    const appServerRoot = hostPath.endsWith('.js') ? path_1.default.resolve(hostPath, '../..') : undefined;
+    const hostCmd = hostPath.endsWith('.js') ? process.execPath : hostPath;
+    const hostArgs = hostPath.endsWith('.js') ? [hostPath, '--socket', socketPath] : ['--socket', socketPath];
+    ensureDir(path_1.default.dirname(processLogPath));
+    ensureDir(getSocketDir());
+    const outFd = fs_1.default.openSync(processLogPath, 'a');
+    return (0, child_process_1.spawn)(hostCmd, hostArgs, {
+        env: {
+            ...env,
+            ...(appServerRoot ? { TIRTC_APP_SERVER_ROOT: appServerRoot } : {}),
+        },
+        detached: true,
+        stdio: ['ignore', outFd, outFd],
+    });
+}
+function waitForSocketReady(socketPath, pid) {
+    const start = Date.now();
+    while (Date.now() - start < kStartupTimeoutMs) {
+        if (fs_1.default.existsSync(socketPath)) {
+            return;
+        }
+        if (!pidAlive(pid)) {
+            throw new Error('host process exited before socket became ready');
+        }
+        sleepMs(kStartupPollIntervalMs);
+    }
+    throw new Error(`session startup timeout: socket not ready within ${kStartupTimeoutMs}ms`);
+}
+function resolveDefaultLogRootDir() {
+    return path_1.default.resolve(process.cwd(), '.tmp/tirtc-devtool/logging');
+}
+function createSession(options) {
+    const runtimePlatform = resolveRuntimePlatform();
+    const runtimeBundleRoot = resolveRuntimeBundleRoot(runtimePlatform);
+    const sessionId = (0, crypto_1.randomUUID)();
+    const artifactDir = path_1.default.join(os_1.default.tmpdir(), `tirtc-session-${sessionId}`);
+    const socketPath = buildSocketPath(sessionId);
+    const logRootDir = options?.logRootDir && options.logRootDir.trim().length > 0 ?
+        path_1.default.resolve(options.logRootDir) :
+        resolveDefaultLogRootDir();
+    const logDir = path_1.default.join(logRootDir, sessionId);
+    const processLogPath = path_1.default.join(logDir, 'host.process.log');
+    const role = normalizeRole(options?.role);
+    const registry = purgeDeadSessions(loadRegistry());
+    if (role === 'service') {
+        const existingService = registry.sessions.find((session) => session.role === 'service');
+        if (existingService) {
+            saveRegistry(registry);
+            throw new Error(`service session already exists: ${existingService.sessionId}; stop it first with "host stop --all" or "host session stop ${existingService.sessionId}"`);
+        }
+    }
+    ensureDir(logDir);
+    tryUnlink(socketPath);
+    const child = spawnDetachedHost({
+        ...process.env,
+        TIRTC_RUNTIME_PLATFORM: runtimePlatform,
+        TIRTC_RUNTIME_BUNDLE_ROOT: runtimeBundleRoot,
+        TIRTC_HOST_ARTIFACT_DIR: artifactDir,
+        TIRTC_HOST_ENDPOINT: `ipc://${socketPath}`,
+        TIRTC_HOST_LOG_DIR: logDir,
+        TIRTC_HOST_LOG_STDOUT_MIRROR: options?.consoleMirror === false ? '0' : '1',
+    }, socketPath, processLogPath);
+    const pid = child.pid ?? -1;
+    child.unref();
+    waitForSocketReady(socketPath, pid);
+    const record = {
+        sessionId,
+        hostEndpoint: `ipc://${socketPath}`,
+        socketPath,
+        runtimePlatform,
+        runtimeBundleRoot,
+        artifactDir,
+        logDir,
+        pid,
+        startedAt: new Date().toISOString(),
+        role,
+    };
+    registry.sessions.push(record);
+    saveRegistry(registry);
+    return record;
+}
+function listSessions() {
+    const registry = purgeDeadSessions(loadRegistry());
+    saveRegistry(registry);
+    return registry.sessions;
+}
+function stopSessionRecord(target) {
+    try {
+        process.kill(target.pid, 'SIGTERM');
+    }
+    catch {
+        // no-op
+    }
+    sleepMs(100);
+    if (pidAlive(target.pid)) {
+        try {
+            process.kill(target.pid, 'SIGKILL');
+        }
+        catch {
+            // no-op
+        }
+    }
+    tryUnlink(target.socketPath);
+}
+function killLingeringHostProcesses() {
+    const killed = [];
+    try {
+        const output = (0, child_process_1.execFileSync)('ps', ['-eo', 'pid=,command='], { encoding: 'utf8' });
+        const lines = output.split(/\r?\n/);
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.length === 0) {
+                continue;
+            }
+            const match = trimmed.match(/^(\d+)\s+(.+)$/);
+            if (!match) {
+                continue;
+            }
+            const pid = Number.parseInt(match[1], 10);
+            const command = match[2];
+            if (!Number.isInteger(pid) || pid <= 1 || pid === process.pid) {
+                continue;
+            }
+            if (!command.includes('app-server/bin/tirtc-devtool-host.js')) {
+                continue;
+            }
+            if (!command.includes('--socket /tmp/tirtc-')) {
+                continue;
+            }
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch {
+                // no-op
+            }
+            if (pidAlive(pid)) {
+                try {
+                    process.kill(pid, 'SIGKILL');
+                }
+                catch {
+                    // no-op
+                }
+            }
+            if (!pidAlive(pid)) {
+                killed.push(pid);
+            }
+        }
+    }
+    catch {
+        // no-op
+    }
+    return killed;
+}
+function stopSession(sessionId) {
+    const registry = purgeDeadSessions(loadRegistry());
+    const idx = registry.sessions.findIndex((session) => session.sessionId === sessionId);
+    if (idx < 0) {
+        throw new Error(`session not found: ${sessionId}`);
+    }
+    const target = registry.sessions[idx];
+    stopSessionRecord(target);
+    registry.sessions.splice(idx, 1);
+    saveRegistry(registry);
+    return target;
+}
+function stopAllSessions() {
+    const registry = purgeDeadSessions(loadRegistry());
+    const stopped = [];
+    for (const session of registry.sessions) {
+        stopSessionRecord(session);
+        stopped.push(session);
+    }
+    const lingeringPids = killLingeringHostProcesses();
+    for (const pid of lingeringPids) {
+        stopped.push({
+            sessionId: `orphan-pid-${pid}`,
+            hostEndpoint: '',
+            socketPath: '',
+            runtimePlatform: '',
+            runtimeBundleRoot: '',
+            artifactDir: '',
+            logDir: '',
+            pid,
+            startedAt: '',
+            role: 'idle',
+        });
+    }
+    saveRegistry({ sessions: [] });
+    return stopped;
+}
+function resolveSession(sessionId) {
+    const sessions = listSessions();
+    if (sessionId && sessionId.trim().length > 0) {
+        const found = sessions.find((session) => session.sessionId === sessionId.trim());
+        if (!found) {
+            throw new Error(`session not found: ${sessionId}`);
+        }
+        return found;
+    }
+    if (sessions.length === 1) {
+        return sessions[0];
+    }
+    if (sessions.length === 0) {
+        throw new Error('no active session; run "host session start" first');
+    }
+    throw new Error('multiple active sessions; please specify --session <sessionId>');
+}
+function setSessionRole(sessionId, role) {
+    const registry = purgeDeadSessions(loadRegistry());
+    const normalizedRole = normalizeRole(role);
+    const idx = registry.sessions.findIndex((session) => session.sessionId === sessionId);
+    if (idx < 0) {
+        throw new Error(`session not found: ${sessionId}`);
+    }
+    if (normalizedRole === 'service') {
+        const existingService = registry.sessions.find((session, index) => index !== idx && session.role === 'service');
+        if (existingService) {
+            saveRegistry(registry);
+            throw new Error(`service session already exists: ${existingService.sessionId}; stop it first with "host stop --all" or "host session stop ${existingService.sessionId}"`);
+        }
+    }
+    const updated = {
+        ...registry.sessions[idx],
+        role: normalizedRole,
+    };
+    registry.sessions[idx] = updated;
+    saveRegistry(registry);
+    return updated;
+}

package/dist/devtools/cli/src/token_tool.d.ts

@@ -0,0 +1,33 @@
+export type TokenIssueInput = {
+    accessId: string;
+    secretKey: string;
+    localId: string;
+    peerId: string;
+    openapiEntry?: string;
+    serviceEntry?: string;
+    userTtlSeconds?: number;
+    channelTtlSeconds?: number;
+};
+export type IssuedTokenPayload = {
+    version: 1;
+    type: 'tirtc-connect-token';
+    peer_id: string;
+    local_id: string;
+    service_entry: string;
+    token: string;
+    openapi_entry: string;
+    user_ttl_seconds: number;
+    channel_ttl_seconds: number;
+    generated_at: string;
+};
+export type TokenIssueOutput = {
+    payload: IssuedTokenPayload;
+    payloadJson: string;
+    token: string;
+    qrCodePngPath: string;
+};
+export declare function issueToken(input: TokenIssueInput): Promise<string>;
+export declare function buildIssuedTokenPayload(input: TokenIssueInput, token: string): IssuedTokenPayload;
+export declare function writePngQrcode(payloadJson: string, outputPath: string): Promise<string>;
+export declare function issueTokenWithQrcode(input: TokenIssueInput): Promise<TokenIssueOutput>;
+export declare function formatTokenIssueConsoleOutput(output: TokenIssueOutput): string;