tirtc-devtools-cli 0.0.13 → 0.0.15

package/dist/cli/src/role_driver.d.ts

@@ -0,0 +1,33 @@
+export type CliOptions = {
+    json?: boolean;
+};
+type SendCommandOptions = {
+    executionId?: string;
+    caseId?: string;
+    appId?: string;
+    artifactRoot?: string;
+    remoteId?: string;
+    source?: string;
+    videoCodec?: string;
+    durationMs?: string;
+    connectTimeoutMs?: string;
+    firstPacketTimeoutMs?: string;
+    bootstrapTokenJson?: string;
+};
+type ReceiveCommandOptions = {
+    artifactRoot?: string;
+    bootstrap?: string;
+    remoteId?: string;
+    token?: string;
+    audioStreamId?: string;
+    videoStreamId?: string;
+    consumer?: string;
+    frameLimit?: string;
+    durationMs?: string;
+    connectTimeoutMs?: string;
+    firstPacketTimeoutMs?: string;
+    firstOutputTimeoutMs?: string;
+};
+export declare function runSendStart(commandOptions: SendCommandOptions, options: CliOptions): Promise<number>;
+export declare function runReceiveStart(commandOptions: ReceiveCommandOptions, options: CliOptions): Promise<number>;
+export {};

package/dist/cli/src/role_driver.js

@@ -0,0 +1,500 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSendStart = runSendStart;
+exports.runReceiveStart = runReceiveStart;
+const child_process_1 = __importDefault(require("child_process"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const embedded_paths_1 = require("./embedded_paths");
+const token_tool_1 = require("./token_tool");
+const defaultAudioStreamId = 10;
+const defaultVideoStreamId = 11;
+const defaultDurationMs = 10000;
+const defaultConnectTimeoutMs = 10000;
+const defaultFirstPacketTimeoutMs = 10000;
+const defaultFirstOutputTimeoutMs = 12000;
+const defaultFrameLimit = 1;
+const roleFailedExitCode = 1;
+const usageExitCode = 2;
+const preflightExitCode = 3;
+class RoleCommandError extends Error {
+    reasonCode;
+    failedStage;
+    exitCode;
+    constructor(reasonCode, failedStage, exitCode, message) {
+        super(message);
+        this.name = 'RoleCommandError';
+        this.reasonCode = reasonCode;
+        this.failedStage = failedStage;
+        this.exitCode = exitCode;
+    }
+}
+function rolePreflightError(reasonCode, detail) {
+    return new RoleCommandError(reasonCode, 'preflight', preflightExitCode, reasonCode + ': ' + detail);
+}
+function roleUsageError(message) {
+    return new RoleCommandError('invalid_request', 'config', usageExitCode, message);
+}
+function pathExists(filePath) {
+    return fs_1.default.existsSync(filePath);
+}
+function pathIsExecutable(filePath) {
+    try {
+        fs_1.default.accessSync(filePath, fs_1.default.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveRuntimePlatform() {
+    const explicit = process.env.TIRTC_RUNTIME_PLATFORM?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    if (process.platform === 'darwin' && process.arch === 'arm64') {
+        return 'macos-arm64';
+    }
+    return 'linux-x64';
+}
+function resolveRoleDriverRoots(fromDir = __dirname) {
+    return {
+        packageRoot: (0, embedded_paths_1.resolveCliPackageRoot)(fromDir),
+        repoRoot: (0, embedded_paths_1.resolveWorkspaceRepoRoot)(fromDir),
+    };
+}
+function appendIfDefined(candidates, candidate) {
+    if (candidate && candidate.length > 0) {
+        candidates.push(candidate);
+    }
+}
+function resolveDriverPath(roots, platform) {
+    const explicit = process.env.TIRTC_DEVTOOLS_DRIVER_PATH?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    const candidates = [];
+    appendIfDefined(candidates, roots.repoRoot
+        ? path_1.default.join(roots.repoRoot, '.build/devtools-driver/bin', platform, 'devtools_driver_probe')
+        : undefined);
+    appendIfDefined(candidates, roots.repoRoot
+        ? path_1.default.join(roots.repoRoot, 'products/devtools/driver/bin', platform, 'devtools_driver_probe')
+        : undefined);
+    appendIfDefined(candidates, roots.repoRoot
+        ? path_1.default.join(roots.repoRoot, 'products/cli/vendor/devtools/driver', platform, 'devtools_driver_probe')
+        : undefined);
+    candidates.push(path_1.default.join(roots.packageRoot, 'vendor/devtools/driver', platform, 'devtools_driver_probe'));
+    for (const candidate of candidates) {
+        if (pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0] ?? '';
+}
+function hasRuntimeBundle(runtimeRoot) {
+    return pathExists(path_1.default.join(runtimeRoot, 'include/tirtc/av.h')) &&
+        pathExists(path_1.default.join(runtimeRoot, 'lib/libmatrix_runtime_facade.a'));
+}
+function resolveRuntimeRoot(roots, platform) {
+    const explicit = process.env.TIRTC_RUNTIME_BUNDLE_ROOT?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    const candidates = [];
+    appendIfDefined(candidates, roots.repoRoot ? path_1.default.join(roots.repoRoot, '.build/products/runtime', platform) : undefined);
+    appendIfDefined(candidates, roots.repoRoot ? path_1.default.join(roots.repoRoot, 'products/cli/bin/runtime', platform) : undefined);
+    appendIfDefined(candidates, roots.repoRoot ? path_1.default.join(roots.repoRoot, 'products/cli/vendor/runtime', platform) : undefined);
+    candidates.push(path_1.default.join(roots.packageRoot, 'vendor/runtime', platform));
+    for (const candidate of candidates) {
+        if (hasRuntimeBundle(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0] ?? '';
+}
+function resolveAssetRoot(roots) {
+    const explicit = process.env.MATRIX_ASSET_WORKSPACE_ROOT?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    if (roots.repoRoot) {
+        return path_1.default.join(roots.repoRoot, 'runtime/assets/.workspace/runtime-assets-current');
+    }
+    return path_1.default.join(roots.packageRoot, 'runtime/assets/.workspace/runtime-assets-current');
+}
+function parsePositiveInt(raw, fallback, name) {
+    if (raw === undefined) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw roleUsageError(name + ' must be a positive integer');
+    }
+    return parsed;
+}
+function requireEnv(name) {
+    const value = process.env[name]?.trim();
+    if (!value) {
+        throw rolePreflightError('missing_env', 'missing environment: ' + name);
+    }
+    return value;
+}
+function executionSuffix() {
+    return new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14);
+}
+function ensureDir(dirPath) {
+    fs_1.default.mkdirSync(dirPath, { recursive: true });
+}
+function writeJson(filePath, value) {
+    ensureDir(path_1.default.dirname(filePath));
+    fs_1.default.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n');
+}
+function redactRequestValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => redactRequestValue(item));
+    }
+    if (typeof value !== 'object' || value === null) {
+        return value;
+    }
+    const result = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (key === 'license' || key === 'token' || key === 'client_token' || key === 'secret_key') {
+            result[key] = '[REDACTED]';
+        }
+        else {
+            result[key] = redactRequestValue(child);
+        }
+    }
+    return result;
+}
+function readJson(filePath) {
+    return JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+}
+function trimOptional(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function tokenFingerprint(token) {
+    return 'sha256:' + crypto_1.default.createHash('sha256').update(token).digest('hex');
+}
+function readTokenIssueJson(filePath) {
+    const resolved = path_1.default.resolve(filePath);
+    if (!pathExists(resolved)) {
+        throw rolePreflightError('token_issue_missing', resolved);
+    }
+    let parsed;
+    try {
+        parsed = readJson(resolved);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw rolePreflightError('token_issue_invalid', detail);
+    }
+    const token = trimOptional(parsed.data?.token);
+    if (!token) {
+        throw rolePreflightError('token_issue_invalid', 'missing data.token');
+    }
+    return {
+        token,
+        remoteId: trimOptional(parsed.data?.payload?.remote_id),
+        endpoint: trimOptional(parsed.data?.payload?.endpoint),
+        appId: trimOptional(parsed.data?.payload?.app_id),
+    };
+}
+function readBootstrap(bootstrapPath) {
+    const resolved = path_1.default.resolve(bootstrapPath);
+    const parsed = readJson(resolved);
+    if (parsed.schema_version !== 1 || !parsed.remote_id || !parsed.token) {
+        throw roleUsageError('bootstrap_invalid');
+    }
+    return parsed;
+}
+function requestMediaSourcePath(request) {
+    const media = request.media;
+    const sourcePath = media?.source?.path;
+    return typeof sourcePath === 'string' && sourcePath.trim() ? sourcePath.trim() : undefined;
+}
+function resolveDriverAssetRoot(request, roots) {
+    const source = requestMediaSourcePath(request);
+    if (source) {
+        const sourcePath = path_1.default.resolve(source);
+        if (fs_1.default.existsSync(sourcePath) && fs_1.default.statSync(sourcePath).isDirectory()) {
+            return sourcePath;
+        }
+        if (path_1.default.basename(sourcePath) === 'manifest.json') {
+            return path_1.default.dirname(sourcePath);
+        }
+        if (path_1.default.basename(path_1.default.dirname(sourcePath)) === 'video') {
+            return path_1.default.dirname(path_1.default.dirname(sourcePath));
+        }
+    }
+    return resolveAssetRoot(roots);
+}
+function codecOrDefault(raw) {
+    const codec = raw?.trim() || 'h264';
+    if (codec !== 'h264' && codec !== 'h265' && codec !== 'mjpeg') {
+        throw roleUsageError('video-codec must be h264, h265, or mjpeg');
+    }
+    return codec;
+}
+function consumerOrDefault(raw) {
+    const consumer = raw?.trim() || 'frame_dump';
+    if (consumer !== 'frame_dump' && consumer !== 'packet_dump') {
+        throw roleUsageError('consumer must be packet_dump or frame_dump');
+    }
+    return consumer;
+}
+function failedStage(summary) {
+    for (const [name, stage] of Object.entries(summary.stage_status ?? {})) {
+        if (stage.status === 'failed') {
+            return name;
+        }
+    }
+    return undefined;
+}
+function printEnvelope(options, code, message, data) {
+    if (options.json) {
+        console.log(JSON.stringify({ code, message, data }));
+        return;
+    }
+    if (code === 0) {
+        console.log('OK:', JSON.stringify(data, null, 2));
+    }
+    else {
+        console.error('Error:', message);
+        if (data !== undefined) {
+            console.error(JSON.stringify(data, null, 2));
+        }
+    }
+}
+async function buildSendRequest(roots, artifactRoot, options) {
+    const codec = codecOrDefault(options.videoCodec);
+    const executionId = trimOptional(options.executionId) ?? 'cli-send-' + codec + '-' + executionSuffix();
+    const caseId = trimOptional(options.caseId) ?? 'devtools-cli-send.' + codec;
+    let remoteId = trimOptional(options.remoteId);
+    let endpoint = trimOptional(process.env.TIRTC_ENDPOINT);
+    let appId = trimOptional(options.appId) ?? trimOptional(process.env.TIRTC_APP_ID);
+    let token;
+    try {
+        if (options.bootstrapTokenJson) {
+            const tokenIssue = readTokenIssueJson(options.bootstrapTokenJson);
+            token = tokenIssue.token;
+            remoteId = remoteId ?? tokenIssue.remoteId;
+            endpoint = tokenIssue.endpoint ?? endpoint;
+            appId = appId ?? tokenIssue.appId;
+        }
+        else {
+            remoteId = remoteId ?? requireEnv('TIRTC_DEVICE_ID');
+            appId = appId ?? requireEnv('TIRTC_APP_ID');
+            token = await (0, token_tool_1.issueToken)({
+                accessId: requireEnv('TIRTC_ACCESS_KEY_ID'),
+                secretKey: requireEnv('TIRTC_SECRET_KEY_ID'),
+                appId,
+                remoteId,
+                openapiEndpoint: process.env.TIRTC_OPEN_API_ENDPOINT || process.env.TIRTC_OPENAPI_ENDPOINT,
+                endpoint,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof RoleCommandError) {
+            throw error;
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        throw rolePreflightError('token_issue_failed', detail);
+    }
+    remoteId = remoteId ?? requireEnv('TIRTC_DEVICE_ID');
+    endpoint = endpoint ?? requireEnv('TIRTC_ENDPOINT');
+    appId = appId ?? requireEnv('TIRTC_APP_ID');
+    if (!token) {
+        throw rolePreflightError('token_issue_invalid', 'missing client token');
+    }
+    return {
+        schema_version: 1,
+        execution_id: executionId,
+        case_id: caseId,
+        role: 'send',
+        endpoint,
+        identity: {
+            license: remoteId + ',' + requireEnv('TIRTC_DEVICE_SECRET_KEY'),
+            remote_id: remoteId,
+        },
+        bootstrap: {
+            client_token: token,
+            token_fingerprint: tokenFingerprint(token),
+        },
+        streams: {
+            audio_stream_id: defaultAudioStreamId,
+            video_stream_id: defaultVideoStreamId,
+        },
+        media: {
+            source: { kind: 'encoded_asset', path: options.source ?? resolveAssetRoot(roots) },
+            video: { codec },
+        },
+        output: { consumer: 'frame_dump', video: { frame_limit: defaultFrameLimit } },
+        run: {
+            duration_ms: parsePositiveInt(options.durationMs, defaultDurationMs, '--duration-ms'),
+            connect_timeout_ms: parsePositiveInt(options.connectTimeoutMs, defaultConnectTimeoutMs, '--connect-timeout-ms'),
+            first_packet_timeout_ms: parsePositiveInt(options.firstPacketTimeoutMs, defaultFirstPacketTimeoutMs, '--first-packet-timeout-ms'),
+            first_output_timeout_ms: defaultFirstOutputTimeoutMs,
+        },
+        artifact: { root_dir: artifactRoot },
+        probe: { app_id: appId },
+    };
+}
+function buildReceiveRequest(roots, artifactRoot, options) {
+    const bootstrap = options.bootstrap ? readBootstrap(options.bootstrap) : undefined;
+    const remoteId = options.remoteId?.trim() || bootstrap?.remote_id || process.env.TIRTC_REMOTE_ID?.trim() || process.env.TIRTC_DEVICE_ID?.trim();
+    const token = options.token?.trim() || bootstrap?.token || process.env.TIRTC_TOKEN?.trim();
+    if (!remoteId) {
+        throw rolePreflightError('missing_env', 'missing remote id: pass --remote-id, --bootstrap, or TIRTC_REMOTE_ID');
+    }
+    if (!token) {
+        throw rolePreflightError('missing_env', 'missing token: pass --token, --bootstrap, or TIRTC_TOKEN');
+    }
+    const executionId = 'cli-receive-' + executionSuffix();
+    const identityOverride = Boolean(bootstrap && (options.remoteId || options.token));
+    const videoCodec = codecOrDefault(bootstrap?.video_codec);
+    return {
+        schema_version: 1,
+        execution_id: executionId,
+        case_id: 'devtools-cli-receive',
+        role: 'receive',
+        endpoint: process.env.TIRTC_ENDPOINT?.trim() || bootstrap?.endpoint || '',
+        identity: {
+            remote_id: remoteId,
+            token,
+            bootstrap_path: options.bootstrap ? path_1.default.resolve(options.bootstrap) : undefined,
+            bootstrap_id: bootstrap?.bootstrap_id,
+            identity_override: identityOverride,
+        },
+        streams: {
+            audio_stream_id: parsePositiveInt(options.audioStreamId, bootstrap?.audio_stream_id ?? defaultAudioStreamId, '--audio-stream-id'),
+            video_stream_id: parsePositiveInt(options.videoStreamId, bootstrap?.video_stream_id ?? defaultVideoStreamId, '--video-stream-id'),
+        },
+        media: {
+            source: { kind: 'encoded_asset', path: resolveAssetRoot(roots) },
+            video: { codec: videoCodec },
+        },
+        output: {
+            consumer: consumerOrDefault(options.consumer),
+            video: { frame_limit: parsePositiveInt(options.frameLimit, defaultFrameLimit, '--frame-limit') },
+        },
+        run: {
+            duration_ms: parsePositiveInt(options.durationMs, defaultDurationMs, '--duration-ms'),
+            connect_timeout_ms: parsePositiveInt(options.connectTimeoutMs, defaultConnectTimeoutMs, '--connect-timeout-ms'),
+            first_packet_timeout_ms: parsePositiveInt(options.firstPacketTimeoutMs, defaultFirstPacketTimeoutMs, '--first-packet-timeout-ms'),
+            first_output_timeout_ms: parsePositiveInt(options.firstOutputTimeoutMs, defaultFirstOutputTimeoutMs, '--first-output-timeout-ms'),
+        },
+        artifact: { root_dir: artifactRoot },
+        probe: { app_id: process.env.TIRTC_APP_ID?.trim() || bootstrap?.app_id || '' },
+    };
+}
+function runDriver(request, artifactRoot, roots) {
+    const platform = resolveRuntimePlatform();
+    const driverPath = resolveDriverPath(roots, platform);
+    const runtimeRoot = resolveRuntimeRoot(roots, platform);
+    const assetRoot = resolveDriverAssetRoot(request, roots);
+    if (!pathExists(driverPath)) {
+        throw rolePreflightError('driver_not_found', driverPath);
+    }
+    if (!pathIsExecutable(driverPath)) {
+        throw rolePreflightError('driver_not_executable', driverPath);
+    }
+    if (!hasRuntimeBundle(runtimeRoot)) {
+        throw rolePreflightError('runtime_bundle_missing', runtimeRoot);
+    }
+    if (!pathExists(path_1.default.join(assetRoot, 'manifest.json'))) {
+        throw rolePreflightError('asset_missing', assetRoot);
+    }
+    const requestTempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'tirtc-devtools-cli-request-'));
+    const requestPath = path_1.default.join(requestTempDir, 'request.json');
+    writeJson(requestPath, request);
+    writeJson(path_1.default.join(artifactRoot, 'request.redacted.json'), redactRequestValue(request));
+    const stdoutFd = fs_1.default.openSync(path_1.default.join(artifactRoot, 'stdout.log'), 'w');
+    const stderrFd = fs_1.default.openSync(path_1.default.join(artifactRoot, 'stderr.log'), 'w');
+    const result = child_process_1.default.spawnSync(driverPath, [
+        '--request', requestPath,
+        '--runtime-root', runtimeRoot,
+        '--asset-root', assetRoot,
+        '--artifact-root', artifactRoot,
+    ], {
+        stdio: ['ignore', stdoutFd, stderrFd],
+    });
+    fs_1.default.closeSync(stdoutFd);
+    fs_1.default.closeSync(stderrFd);
+    fs_1.default.rmSync(requestTempDir, { recursive: true, force: true });
+    const summaryPath = path_1.default.join(artifactRoot, 'summary.json');
+    if (!pathExists(summaryPath)) {
+        const message = result.error instanceof Error
+            ? result.error.message
+            : 'driver exited without summary: status=' + String(result.status);
+        if (result.error) {
+            throw new RoleCommandError('artifact_write_failed', 'artifact', roleFailedExitCode, message);
+        }
+        throw new RoleCommandError('artifact_write_failed', 'artifact', roleFailedExitCode, message);
+    }
+    return readJson(summaryPath);
+}
+function normalizeRoleError(error) {
+    if (error instanceof RoleCommandError) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new RoleCommandError('artifact_write_failed', 'artifact', roleFailedExitCode, message);
+}
+async function runRole(role, commandOptions, options) {
+    const roots = resolveRoleDriverRoots();
+    const defaultBaseRoot = roots.repoRoot ?? roots.packageRoot;
+    const defaultRoot = path_1.default.join(defaultBaseRoot, '.build/devtools-cli', role + '-' + executionSuffix());
+    const artifactRoot = path_1.default.resolve(commandOptions.artifactRoot ?? defaultRoot);
+    ensureDir(artifactRoot);
+    try {
+        const request = role === 'send' ?
+            await buildSendRequest(roots, artifactRoot, commandOptions) :
+            buildReceiveRequest(roots, artifactRoot, commandOptions);
+        const summary = runDriver(request, artifactRoot, roots);
+        const summaryPath = path_1.default.join(artifactRoot, 'summary.json');
+        const data = {
+            status: summary.status,
+            exit_code: summary.exit_code,
+            role: summary.role,
+            execution_id: summary.execution_id,
+            artifact_root: artifactRoot,
+            summary_path: summaryPath,
+            bootstrap_path: summary.bootstrap_path,
+            reason_code: summary.reason_code,
+            failed_stage: failedStage(summary),
+        };
+        if (summary.exit_code === 0 && summary.status === 'completed') {
+            printEnvelope(options, 0, 'OK', data);
+            return 0;
+        }
+        printEnvelope(options, 1, summary.reason_code ?? 'driver failed', data);
+        return summary.exit_code || 1;
+    }
+    catch (error) {
+        const normalized = normalizeRoleError(error);
+        printEnvelope(options, 1, normalized.message, {
+            status: 'failed',
+            exit_code: normalized.exitCode,
+            role,
+            reason_code: normalized.reasonCode,
+            failed_stage: normalized.failedStage,
+            artifact_root: artifactRoot,
+            summary_path: path_1.default.join(artifactRoot, 'summary.json'),
+        });
+        return normalized.exitCode;
+    }
+}
+function runSendStart(commandOptions, options) {
+    return runRole('send', commandOptions, options);
+}
+function runReceiveStart(commandOptions, options) {
+    return runRole('receive', commandOptions, options);
+}

package/dist/cli/src/token_command.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerTokenCommands = registerTokenCommands;
-const facade_1 = require("./facade");
 const token_tool_1 = require("./token_tool");
 const kTokenIssueAccessKeyIdEnvVar = 'TIRTC_ACCESS_KEY_ID';
 const kTokenIssueSecretKeyIdEnvVar = 'TIRTC_SECRET_KEY_ID';
 const kTokenIssueAppIdEnvVar = 'TIRTC_APP_ID';
+const errorReasonCodeMapping = {
+    internal_error: 5,
+};
 function normalizeTokenCommandError(error) {
     if (error instanceof Error) {
         return {
@@ -31,7 +33,7 @@ function normalizeTokenCommandError(error) {
 function printTokenCommandError(error, options) {
     const normalized = normalizeTokenCommandError(error);
     const reasonCode = normalized.reasonCode;
-    const exitCode = facade_1.ErrorReasonCodeMapping[reasonCode] ?? 1;
+    const exitCode = errorReasonCodeMapping[reasonCode] ?? 1;
     if (options.json) {
         console.log(JSON.stringify({
             code: exitCode,

package/dist/cli/src/token_issue.d.ts

@@ -0,0 +1,9 @@
+export type IssueTokenInput = {
+    accessId: string;
+    secretKey: string;
+    remoteId: string;
+    openapiEndpoint?: string;
+    userTtlSeconds?: number;
+    channelTtlSeconds?: number;
+};
+export declare function issueToken(input: IssueTokenInput): Promise<string>;