tirtc-devtools-cli 0.0.1

package/vendor/app-server/dist/host/native/RuntimeCredentialTokenIssuer.d.ts

@@ -0,0 +1,26 @@
+export type AutoTokenIssueOptions = {
+    openapiEntry?: string;
+    accessId: string;
+    secretKey: string;
+    localId: string;
+    peerId: string;
+    userTtlSeconds?: number;
+    channelTtlSeconds?: number;
+};
+type RuntimeCredentialTokenIssuerOptions = {
+    repoRoot: string;
+    platform: string;
+    runtimeBundleRoot: string;
+};
+export declare class RuntimeCredentialTokenIssuer {
+    private readonly repoRoot;
+    private readonly platform;
+    private readonly runtimeBundleRoot;
+    private binding?;
+    constructor(options: RuntimeCredentialTokenIssuerOptions);
+    private ensureRuntimeBundleReady;
+    private resolveAddonPath;
+    private ensureBinding;
+    issueToken(options: AutoTokenIssueOptions): Promise<string>;
+}
+export {};

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

@@ -0,0 +1,118 @@
+"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 module_1 = require("module");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtimeRequire = (0, module_1.createRequire)(__filename);
+function pathExists(filePath) {
+    return fs.existsSync(filePath);
+}
+class RuntimeCredentialTokenIssuer {
+    repoRoot;
+    platform;
+    runtimeBundleRoot;
+    binding;
+    constructor(options) {
+        this.repoRoot = options.repoRoot;
+        this.platform = options.platform;
+        this.runtimeBundleRoot = options.runtimeBundleRoot;
+    }
+    ensureRuntimeBundleReady() {
+        const includeDir = path.join(this.runtimeBundleRoot, 'include');
+        const libDir = path.join(this.runtimeBundleRoot, 'lib');
+        if (!pathExists(includeDir) || !pathExists(libDir)) {
+            throw new Error('runtime-backed sdk bundle is missing: ' + this.runtimeBundleRoot);
+        }
+    }
+    resolveAddonPath() {
+        const explicit = process.env.TIRTC_CREDENTIAL_ADDON_PATH;
+        const candidates = [
+            explicit,
+            path.join(this.repoRoot, `bin/native/${this.platform}/credential_napi.node`),
+            path.join(this.repoRoot, `app-server/bin/native/${this.platform}/credential_napi.node`),
+            path.join(this.repoRoot, `.build/app-server/native/${this.platform}/credential_napi.node`),
+            path.resolve(process.cwd(), `app-server/bin/native/${this.platform}/credential_napi.node`),
+            path.resolve(process.cwd(), `.build/app-server/native/${this.platform}/credential_napi.node`),
+        ].filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+        for (const candidate of candidates) {
+            const normalized = path.resolve(candidate);
+            if (pathExists(normalized)) {
+                return normalized;
+            }
+        }
+        throw new Error('credential addon missing for platform ' + this.platform +
+            '; run: npm --prefix app-server run build:native');
+    }
+    ensureBinding() {
+        if (this.binding) {
+            return this.binding;
+        }
+        this.ensureRuntimeBundleReady();
+        const addonPath = this.resolveAddonPath();
+        const loaded = runtimeRequire(addonPath);
+        if (!loaded || typeof loaded.issueToken !== 'function') {
+            throw new Error('credential addon missing issueToken() export: ' + addonPath);
+        }
+        this.binding = loaded;
+        return loaded;
+    }
+    async issueToken(options) {
+        const binding = 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/native/RuntimeHostBridge.d.ts

@@ -0,0 +1,19 @@
+type RuntimeHostBridgeOptions = {
+    repoRoot: string;
+    platform: string;
+};
+export declare class RuntimeHostBridge {
+    private readonly repoRoot;
+    private readonly platform;
+    private binding?;
+    constructor(options: RuntimeHostBridgeOptions);
+    private resolveAddonPath;
+    private resolveRuntimeLibDirs;
+    private prepareDynamicLibraryEnv;
+    private ensureBinding;
+    startUplink(args: string[]): number;
+    stopUplink(): void;
+    startDownlink(args: string[]): number;
+    stopDownlink(): void;
+}
+export {};

package/vendor/app-server/dist/host/native/RuntimeHostBridge.js

@@ -0,0 +1,141 @@
+"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.RuntimeHostBridge = void 0;
+const module_1 = require("module");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtimeRequire = (0, module_1.createRequire)(__filename);
+function pathExists(filePath) {
+    return fs.existsSync(filePath);
+}
+class RuntimeHostBridge {
+    repoRoot;
+    platform;
+    binding;
+    constructor(options) {
+        this.repoRoot = options.repoRoot;
+        this.platform = options.platform;
+    }
+    resolveAddonPath() {
+        const explicit = process.env.TIRTC_RUNTIME_HOST_ADDON_PATH;
+        const candidates = [
+            explicit,
+            path.join(this.repoRoot, `bin/native/${this.platform}/runtime_host_napi.node`),
+            path.join(this.repoRoot, `app-server/bin/native/${this.platform}/runtime_host_napi.node`),
+            path.join(this.repoRoot, `.build/app-server/native/${this.platform}/runtime_host_napi.node`),
+            path.resolve(process.cwd(), `app-server/bin/native/${this.platform}/runtime_host_napi.node`),
+            path.resolve(process.cwd(), `.build/app-server/native/${this.platform}/runtime_host_napi.node`),
+        ].filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+        for (const candidate of candidates) {
+            const normalized = path.resolve(candidate);
+            if (pathExists(normalized)) {
+                return normalized;
+            }
+        }
+        throw new Error('runtime host addon missing for platform ' + this.platform +
+            '; run: npm --prefix app-server run build:native');
+    }
+    resolveRuntimeLibDirs() {
+        const dirs = [];
+        const envBundleRoot = process.env.TIRTC_RUNTIME_BUNDLE_ROOT;
+        const runtimeBundleLibFromEnv = envBundleRoot && envBundleRoot.trim().length > 0
+            ? path.join(path.resolve(envBundleRoot.trim()), 'lib')
+            : '';
+        const runtimeBundleLib = path.join(this.repoRoot, `bin/runtime/${this.platform}/lib`);
+        const repoRuntimeBundleLib = path.join(this.repoRoot, `app-server/bin/runtime/${this.platform}/lib`);
+        const nanoLib = path.join(this.repoRoot, `runtime/core/3rd/tirtc-nano/install/${this.platform}/TIRTC_NANO/lib`);
+        if (runtimeBundleLibFromEnv && pathExists(runtimeBundleLibFromEnv)) {
+            dirs.push(runtimeBundleLibFromEnv);
+        }
+        if (pathExists(runtimeBundleLib)) {
+            dirs.push(runtimeBundleLib);
+        }
+        if (pathExists(repoRuntimeBundleLib)) {
+            dirs.push(repoRuntimeBundleLib);
+        }
+        if (pathExists(nanoLib)) {
+            dirs.push(nanoLib);
+        }
+        return dirs;
+    }
+    prepareDynamicLibraryEnv() {
+        const dirs = this.resolveRuntimeLibDirs();
+        if (dirs.length === 0) {
+            return;
+        }
+        const appendUnique = (origin, additions) => {
+            const parts = (origin ?? '')
+                .split(path.delimiter)
+                .map((v) => v.trim())
+                .filter((v) => v.length > 0);
+            for (const item of additions) {
+                if (!parts.includes(item)) {
+                    parts.unshift(item);
+                }
+            }
+            return parts.join(path.delimiter);
+        };
+        process.env.DYLD_LIBRARY_PATH = appendUnique(process.env.DYLD_LIBRARY_PATH, dirs);
+        process.env.LD_LIBRARY_PATH = appendUnique(process.env.LD_LIBRARY_PATH, dirs);
+    }
+    ensureBinding() {
+        if (this.binding) {
+            return this.binding;
+        }
+        this.prepareDynamicLibraryEnv();
+        const addonPath = this.resolveAddonPath();
+        const loaded = runtimeRequire(addonPath);
+        if (!loaded || typeof loaded.startUplink !== 'function' || typeof loaded.stopUplink !== 'function' ||
+            typeof loaded.startDownlink !== 'function' || typeof loaded.stopDownlink !== 'function') {
+            throw new Error('runtime host addon exports are incomplete: ' + addonPath);
+        }
+        this.binding = loaded;
+        return loaded;
+    }
+    startUplink(args) {
+        return this.ensureBinding().startUplink(args);
+    }
+    stopUplink() {
+        this.ensureBinding().stopUplink();
+    }
+    startDownlink(args) {
+        return this.ensureBinding().startDownlink(args);
+    }
+    stopDownlink() {
+        this.ensureBinding().stopDownlink();
+    }
+}
+exports.RuntimeHostBridge = RuntimeHostBridge;

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

@@ -0,0 +1,10 @@
+export type RuntimeBackedPreflightResult = {
+    ready: boolean;
+    reason?: string;
+    runtimePlatform: string;
+    runtimeBundleRoot: string;
+};
+export declare function resolveRuntimePlatform(): string;
+export declare function resolveRuntimeBundleRoot(repoRoot: string, runtimePlatform: string): string;
+export declare function dockerAvailable(): boolean;
+export declare function probeRuntimeBackedPreflight(repoRoot: string): RuntimeBackedPreflightResult;

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

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimePlatform = resolveRuntimePlatform;
+exports.resolveRuntimeBundleRoot = resolveRuntimeBundleRoot;
+exports.dockerAvailable = dockerAvailable;
+exports.probeRuntimeBackedPreflight = probeRuntimeBackedPreflight;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+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(repoRoot, runtimePlatform) {
+    const explicit = process.env.TIRTC_RUNTIME_BUNDLE_ROOT;
+    if (explicit && explicit.trim().length > 0) {
+        return path_1.default.resolve(explicit.trim());
+    }
+    const appServerRoot = process.env.TIRTC_APP_SERVER_ROOT;
+    if (appServerRoot && appServerRoot.trim().length > 0) {
+        return path_1.default.resolve(appServerRoot.trim(), 'bin/runtime', runtimePlatform);
+    }
+    if (pathExists(path_1.default.resolve(repoRoot, 'bin/runtime', runtimePlatform))) {
+        return path_1.default.resolve(repoRoot, 'bin/runtime', runtimePlatform);
+    }
+    return path_1.default.resolve(repoRoot, 'app-server/bin/runtime', runtimePlatform);
+}
+function dockerAvailable() {
+    try {
+        (0, child_process_1.execFileSync)('docker', ['version'], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function pathExists(p) {
+    return fs_1.default.existsSync(p);
+}
+function probeRuntimeBackedPreflight(repoRoot) {
+    const runtimePlatform = resolveRuntimePlatform();
+    const runtimeBundleRoot = resolveRuntimeBundleRoot(repoRoot, runtimePlatform);
+    const required = [
+        path_1.default.join(runtimeBundleRoot, 'manifest.txt'),
+        path_1.default.join(runtimeBundleRoot, 'include'),
+        path_1.default.join(runtimeBundleRoot, 'lib'),
+    ];
+    if (required.some((entry) => !pathExists(entry))) {
+        return {
+            ready: false,
+            reason: 'runtime-backed sdk bundle is missing under app-server/bin/runtime/<platform>',
+            runtimePlatform,
+            runtimeBundleRoot,
+        };
+    }
+    if (runtimePlatform === 'linux-x64' && !dockerAvailable()) {
+        return {
+            ready: false,
+            reason: 'docker unavailable for linux-x64 runtime-backed gate',
+            runtimePlatform,
+            runtimeBundleRoot,
+        };
+    }
+    return {
+        ready: true,
+        runtimePlatform,
+        runtimeBundleRoot,
+    };
+}

package/vendor/app-server/dist/host/tests/helpers/host_socket_client.d.ts

@@ -0,0 +1,28 @@
+export type RpcMessage = {
+    id?: string | number;
+    method?: string;
+    params?: unknown;
+    result?: unknown;
+    error?: {
+        code?: number;
+        message?: string;
+        data?: {
+            reasonCode?: string;
+            message?: string;
+            retryable?: boolean;
+        };
+    };
+};
+export declare class HostSocketClient {
+    private socket;
+    private buffer;
+    private pending;
+    private eventHandlers;
+    constructor(socketPath: string);
+    waitConnected(): Promise<void>;
+    request(id: string | number, method: string, params: unknown): Promise<RpcMessage>;
+    notify(method: string, params: unknown): void;
+    onEvent(handler: (msg: RpcMessage) => void): void;
+    close(): void;
+}
+export declare function waitForSocketReady(socketPath: string, timeoutMs?: number): Promise<void>;

package/vendor/app-server/dist/host/tests/helpers/host_socket_client.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostSocketClient = void 0;
+exports.waitForSocketReady = waitForSocketReady;
+const fs_1 = __importDefault(require("fs"));
+const net_1 = __importDefault(require("net"));
+class HostSocketClient {
+    socket;
+    buffer = '';
+    pending = new Map();
+    eventHandlers = [];
+    constructor(socketPath) {
+        this.socket = net_1.default.createConnection(socketPath);
+        this.socket.setEncoding('utf8');
+        this.socket.on('data', (chunk) => {
+            this.buffer += chunk;
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim()) {
+                    continue;
+                }
+                const msg = JSON.parse(line);
+                if (msg.id !== undefined && this.pending.has(msg.id)) {
+                    const resolver = this.pending.get(msg.id);
+                    this.pending.delete(msg.id);
+                    resolver?.(msg);
+                    continue;
+                }
+                for (const handler of this.eventHandlers) {
+                    handler(msg);
+                }
+            }
+        });
+    }
+    waitConnected() {
+        if (!this.socket.connecting) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            this.socket.once('connect', () => resolve());
+            this.socket.once('error', (err) => reject(err));
+        });
+    }
+    request(id, method, params) {
+        return new Promise((resolve) => {
+            this.pending.set(id, resolve);
+            this.socket.write(JSON.stringify({ id, method, params }) + '\n');
+        });
+    }
+    notify(method, params) {
+        this.socket.write(JSON.stringify({ method, params }) + '\n');
+    }
+    onEvent(handler) {
+        this.eventHandlers.push(handler);
+    }
+    close() {
+        this.socket.destroy();
+    }
+}
+exports.HostSocketClient = HostSocketClient;
+function waitForSocketReady(socketPath, timeoutMs = 5000) {
+    const startedAt = Date.now();
+    return new Promise((resolve, reject) => {
+        const timer = setInterval(() => {
+            try {
+                if (fs_1.default.existsSync(socketPath)) {
+                    clearInterval(timer);
+                    resolve();
+                    return;
+                }
+            }
+            catch {
+                // no-op
+            }
+            if (Date.now() - startedAt > timeoutMs) {
+                clearInterval(timer);
+                reject(new Error('socket startup timeout: ' + socketPath));
+            }
+        }, 50);
+    });
+}

package/vendor/app-server/dist/host/tests/helpers/runtime_e2e_local_config.d.ts

@@ -0,0 +1,10 @@
+export type AppServerRuntimeE2eLocalConfig = {
+    license: string;
+    serviceEntry: string;
+    peerId: string;
+    accessId: string;
+    secretKey: string;
+    useFakeToken: boolean;
+    assetsDir: string;
+};
+export declare function loadAppServerRuntimeE2eLocalConfig(repoRoot: string): AppServerRuntimeE2eLocalConfig | undefined;

package/vendor/app-server/dist/host/tests/helpers/runtime_e2e_local_config.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAppServerRuntimeE2eLocalConfig = loadAppServerRuntimeE2eLocalConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function asString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function asBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function resolveConfigPath(repoRoot) {
+    return path_1.default.resolve(repoRoot, 'app-server/host/tests/.local/runtime-backed.e2e.local.json');
+}
+function requireString(raw, key) {
+    const value = asString(raw[key]);
+    if (value.length === 0) {
+        throw new Error(`runtime-backed app-server e2e config requires non-empty "${key}"`);
+    }
+    return value;
+}
+function loadAppServerRuntimeE2eLocalConfig(repoRoot) {
+    const configPath = resolveConfigPath(repoRoot);
+    if (!fs_1.default.existsSync(configPath)) {
+        return undefined;
+    }
+    const raw = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+    const useFakeToken = asBoolean(raw.useFakeToken);
+    return {
+        license: requireString(raw, 'license'),
+        serviceEntry: requireString(raw, 'serviceEntry'),
+        peerId: requireString(raw, 'peerId'),
+        accessId: requireString(raw, 'accessId'),
+        secretKey: requireString(raw, 'secretKey'),
+        useFakeToken: useFakeToken === undefined ? true : useFakeToken,
+        assetsDir: requireString(raw, 'assetsDir'),
+    };
+}

package/vendor/app-server/dist/host/tests/helpers/runtime_test_env.d.ts

@@ -0,0 +1,11 @@
+import { RuntimeBackedPreflightResult, resolveRuntimePlatform, dockerAvailable } from '../../runtime_backed_preflight';
+export { resolveRuntimePlatform, dockerAvailable };
+export type RuntimePrereq = RuntimeBackedPreflightResult & {
+    repoRoot: string;
+};
+export type RealTransportProbe = {
+    ready: boolean;
+    reason?: string;
+};
+export declare function probeRealTransportReady(repoRoot: string): RealTransportProbe;
+export declare function resolveRuntimePrereq(testDir: string): RuntimePrereq;

package/vendor/app-server/dist/host/tests/helpers/runtime_test_env.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dockerAvailable = exports.resolveRuntimePlatform = void 0;
+exports.probeRealTransportReady = probeRealTransportReady;
+exports.resolveRuntimePrereq = resolveRuntimePrereq;
+const path_1 = __importDefault(require("path"));
+const runtime_backed_preflight_1 = require("../../runtime_backed_preflight");
+Object.defineProperty(exports, "resolveRuntimePlatform", { enumerable: true, get: function () { return runtime_backed_preflight_1.resolveRuntimePlatform; } });
+Object.defineProperty(exports, "dockerAvailable", { enumerable: true, get: function () { return runtime_backed_preflight_1.dockerAvailable; } });
+let cachedProbe;
+function probeRealTransportReady(repoRoot) {
+    if (cachedProbe) {
+        return cachedProbe;
+    }
+    const preflight = (0, runtime_backed_preflight_1.probeRuntimeBackedPreflight)(repoRoot);
+    cachedProbe = {
+        ready: preflight.ready,
+        reason: preflight.reason,
+    };
+    return cachedProbe;
+}
+function resolveRuntimePrereq(testDir) {
+    const repoRoot = path_1.default.resolve(testDir, '../../..');
+    const preflight = (0, runtime_backed_preflight_1.probeRuntimeBackedPreflight)(repoRoot);
+    return {
+        ...preflight,
+        repoRoot,
+    };
+}