tirtc-devtools-cli 0.0.13 → 0.0.15

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

@@ -1,103 +0,0 @@
-import { StreamSource } from './HostState';
-export type JsonRpcId = string | number;
-export type JsonRpcRequest = {
-    id?: JsonRpcId;
-    method: string;
-    params?: unknown;
-};
-export type ProtocolErrorPayload = {
-    reasonCode: string;
-    message: string;
-    retryable: boolean;
-};
-export type ProtocolErrorResponse = {
-    id?: JsonRpcId;
-    error: {
-        code: number;
-        message: string;
-        data?: ProtocolErrorPayload;
-    };
-};
-export type ServiceStartParams = {
-    serviceEntry?: string;
-    license: string;
-    timeoutMs: number;
-    bootstrapSendStreams?: StreamSendStartParams[];
-};
-export type ConnectionConnectParams = {
-    serviceEntry?: string;
-    peerId: string;
-    token: string;
-    timeoutMs: number;
-};
-export type StreamSendStartParams = {
-    streamId: number;
-    media: 'audio' | 'video';
-    source: StreamSource;
-};
-export type StreamStopParams = {
-    streamId: number;
-};
-export type StreamMessageSendParams = {
-    streamId: number;
-    payload: string;
-};
-export type StreamReceiveStartParams = {
-    streamId: number;
-    media: 'audio' | 'video';
-};
-export type OutputAttachParams = {
-    streamId: number;
-    consumer: string;
-    mediaView: string;
-    format: string;
-    delivery: string;
-    targetPath?: string;
-    maxFiles?: number;
-};
-export type OutputDetachParams = {
-    outputId: string;
-};
-export type CommandSendParams = {
-    commandId: number;
-    payloadEncoding: string;
-    payload: string;
-    timeoutMs?: number;
-};
-export type CommandReplyParams = {
-    remoteRequestId: number;
-    commandId: number;
-    payloadEncoding: string;
-    payload: string;
-};
-export type EventsSubscribeParams = {
-    families?: string[];
-};
-export type ArtifactExportParams = {
-    outputPath: string;
-};
-export type DebugTokenQrcodeParams = {
-    payload: string;
-    outputStem?: string;
-};
-export declare class HostProtocolError extends Error {
-    readonly reasonCode: string;
-    readonly retryable: boolean;
-    constructor(reasonCode: string, message: string, retryable: boolean);
-}
-export declare function parseRequest(message: string): JsonRpcRequest;
-export declare function toParamsRecord(params: unknown): Record<string, unknown>;
-export declare function parseServiceStartParams(params: Record<string, unknown>): ServiceStartParams;
-export declare function parseConnectionConnectParams(params: Record<string, unknown>): ConnectionConnectParams;
-export declare function parseStreamSendStartParams(params: Record<string, unknown>): StreamSendStartParams;
-export declare function parseStreamStopParams(params: Record<string, unknown>): StreamStopParams;
-export declare function parseStreamMessageSendParams(params: Record<string, unknown>): StreamMessageSendParams;
-export declare function parseStreamReceiveStartParams(params: Record<string, unknown>): StreamReceiveStartParams;
-export declare function parseOutputAttachParams(params: Record<string, unknown>): OutputAttachParams;
-export declare function parseOutputDetachParams(params: Record<string, unknown>): OutputDetachParams;
-export declare function parseCommandSendParams(params: Record<string, unknown>): CommandSendParams;
-export declare function parseCommandReplyParams(params: Record<string, unknown>): CommandReplyParams;
-export declare function parseEventsSubscribeParams(params: Record<string, unknown>): EventsSubscribeParams;
-export declare function parseArtifactExportParams(params: Record<string, unknown>): ArtifactExportParams;
-export declare function parseDebugTokenQrcodeParams(params: Record<string, unknown>): DebugTokenQrcodeParams;
-export declare function normalizeError(error: unknown): HostProtocolError;

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

@@ -1,239 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HostProtocolError = void 0;
-exports.parseRequest = parseRequest;
-exports.toParamsRecord = toParamsRecord;
-exports.parseServiceStartParams = parseServiceStartParams;
-exports.parseConnectionConnectParams = parseConnectionConnectParams;
-exports.parseStreamSendStartParams = parseStreamSendStartParams;
-exports.parseStreamStopParams = parseStreamStopParams;
-exports.parseStreamMessageSendParams = parseStreamMessageSendParams;
-exports.parseStreamReceiveStartParams = parseStreamReceiveStartParams;
-exports.parseOutputAttachParams = parseOutputAttachParams;
-exports.parseOutputDetachParams = parseOutputDetachParams;
-exports.parseCommandSendParams = parseCommandSendParams;
-exports.parseCommandReplyParams = parseCommandReplyParams;
-exports.parseEventsSubscribeParams = parseEventsSubscribeParams;
-exports.parseArtifactExportParams = parseArtifactExportParams;
-exports.parseDebugTokenQrcodeParams = parseDebugTokenQrcodeParams;
-exports.normalizeError = normalizeError;
-class HostProtocolError extends Error {
-    reasonCode;
-    retryable;
-    constructor(reasonCode, message, retryable) {
-        super(message);
-        this.name = 'HostProtocolError';
-        this.reasonCode = reasonCode;
-        this.retryable = retryable;
-    }
-}
-exports.HostProtocolError = HostProtocolError;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function parseRequest(message) {
-    const parsed = JSON.parse(message);
-    if (!isRecord(parsed) || typeof parsed.method !== 'string') {
-        throw new HostProtocolError('invalid_request', 'Invalid request envelope', false);
-    }
-    const id = parsed.id;
-    if (id !== undefined && typeof id !== 'string' && typeof id !== 'number') {
-        throw new HostProtocolError('invalid_request', 'Invalid request id', false);
-    }
-    return {
-        id,
-        method: parsed.method,
-        params: parsed.params,
-    };
-}
-function toParamsRecord(params) {
-    if (params === undefined) {
-        return {};
-    }
-    if (!isRecord(params)) {
-        throw new HostProtocolError('invalid_request', 'Params must be an object', false);
-    }
-    return params;
-}
-function getString(params, key) {
-    const value = params[key];
-    if (typeof value !== 'string') {
-        throw new HostProtocolError('invalid_request', `Invalid ${key}`, false);
-    }
-    return value;
-}
-function getOptionalString(params, key) {
-    const value = params[key];
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== 'string') {
-        throw new HostProtocolError('invalid_request', `Invalid ${key}`, false);
-    }
-    return value;
-}
-function getNumber(params, key) {
-    const value = params[key];
-    if (typeof value !== 'number' || Number.isNaN(value)) {
-        throw new HostProtocolError('invalid_request', `Invalid ${key}`, false);
-    }
-    return value;
-}
-function getOptionalNumber(params, key) {
-    const value = params[key];
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== 'number' || Number.isNaN(value)) {
-        throw new HostProtocolError('invalid_request', `Invalid ${key}`, false);
-    }
-    return value;
-}
-function getRecord(params, key) {
-    const value = params[key];
-    if (!isRecord(value)) {
-        throw new HostProtocolError('invalid_request', `Invalid ${key}`, false);
-    }
-    return value;
-}
-function parseStreamSource(source) {
-    if (!isRecord(source)) {
-        throw new HostProtocolError('invalid_request', 'Invalid source', false);
-    }
-    const mode = getString(source, 'mode');
-    if (mode !== 'local_assets') {
-        throw new HostProtocolError('invalid_request', 'Invalid source.mode', false);
-    }
-    const localAssets = getRecord(source, 'local_assets');
-    return {
-        mode: 'local_assets',
-        local_assets: {
-            assets_dir: getString(localAssets, 'assets_dir'),
-        },
-    };
-}
-function parseServiceStartParams(params) {
-    const bootstrapSendStreamsRaw = params.bootstrapSendStreams;
-    let bootstrapSendStreams;
-    if (bootstrapSendStreamsRaw !== undefined) {
-        if (!Array.isArray(bootstrapSendStreamsRaw)) {
-            throw new HostProtocolError('invalid_request', 'Invalid bootstrapSendStreams', false);
-        }
-        bootstrapSendStreams = bootstrapSendStreamsRaw.map((entry) => {
-            if (!isRecord(entry)) {
-                throw new HostProtocolError('invalid_request', 'Invalid bootstrapSendStreams item', false);
-            }
-            return parseStreamSendStartParams(entry);
-        });
-    }
-    return {
-        serviceEntry: getOptionalString(params, 'serviceEntry'),
-        license: getString(params, 'license'),
-        timeoutMs: getNumber(params, 'timeoutMs'),
-        bootstrapSendStreams,
-    };
-}
-function parseConnectionConnectParams(params) {
-    const token = getString(params, 'token').trim();
-    if (token.length === 0) {
-        throw new HostProtocolError('invalid_request', 'connection/connect requires non-empty token', false);
-    }
-    return {
-        serviceEntry: getOptionalString(params, 'serviceEntry'),
-        peerId: getString(params, 'peerId'),
-        token,
-        timeoutMs: getNumber(params, 'timeoutMs'),
-    };
-}
-function parseStreamSendStartParams(params) {
-    const media = getString(params, 'media');
-    if (media !== 'audio' && media !== 'video') {
-        throw new HostProtocolError('invalid_request', 'Invalid media', false);
-    }
-    return {
-        streamId: getNumber(params, 'streamId'),
-        media,
-        source: parseStreamSource(params.source),
-    };
-}
-function parseStreamStopParams(params) {
-    return { streamId: getNumber(params, 'streamId') };
-}
-function parseStreamMessageSendParams(params) {
-    return {
-        streamId: getNumber(params, 'streamId'),
-        payload: getString(params, 'payload'),
-    };
-}
-function parseStreamReceiveStartParams(params) {
-    const media = getString(params, 'media');
-    if (media !== 'audio' && media !== 'video') {
-        throw new HostProtocolError('invalid_request', 'Invalid media', false);
-    }
-    return {
-        streamId: getNumber(params, 'streamId'),
-        media,
-    };
-}
-function parseOutputAttachParams(params) {
-    return {
-        streamId: getNumber(params, 'streamId'),
-        consumer: getString(params, 'consumer'),
-        mediaView: getString(params, 'mediaView'),
-        format: getString(params, 'format'),
-        delivery: getString(params, 'delivery'),
-        targetPath: getOptionalString(params, 'targetPath'),
-        maxFiles: getOptionalNumber(params, 'maxFiles'),
-    };
-}
-function parseOutputDetachParams(params) {
-    return {
-        outputId: getString(params, 'outputId'),
-    };
-}
-function parseCommandSendParams(params) {
-    return {
-        commandId: getNumber(params, 'commandId'),
-        payloadEncoding: getString(params, 'payloadEncoding'),
-        payload: getString(params, 'payload'),
-        timeoutMs: getOptionalNumber(params, 'timeoutMs'),
-    };
-}
-function parseCommandReplyParams(params) {
-    return {
-        remoteRequestId: getNumber(params, 'remoteRequestId'),
-        commandId: getNumber(params, 'commandId'),
-        payloadEncoding: getString(params, 'payloadEncoding'),
-        payload: getString(params, 'payload'),
-    };
-}
-function parseEventsSubscribeParams(params) {
-    const families = params.families;
-    if (families === undefined) {
-        return {};
-    }
-    if (!Array.isArray(families) || families.some((f) => typeof f !== 'string')) {
-        throw new HostProtocolError('invalid_request', 'Invalid families', false);
-    }
-    return { families };
-}
-function parseArtifactExportParams(params) {
-    return {
-        outputPath: getString(params, 'outputPath'),
-    };
-}
-function parseDebugTokenQrcodeParams(params) {
-    return {
-        payload: getString(params, 'payload'),
-        outputStem: getOptionalString(params, 'outputStem'),
-    };
-}
-function normalizeError(error) {
-    if (error instanceof HostProtocolError) {
-        return error;
-    }
-    if (error instanceof Error) {
-        return new HostProtocolError('internal_error', error.message, false);
-    }
-    return new HostProtocolError('internal_error', 'Internal error', false);
-}

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

@@ -1,52 +0,0 @@
-import { ArtifactManager } from './ArtifactManager';
-import { RuntimeAdapter } from './RuntimeAdapter';
-export declare class HostServer {
-    private state;
-    private artifactManager;
-    private runtimeAdapter;
-    private commandCoordinator;
-    private isInitialized;
-    private eventCounter;
-    private commandSequence;
-    private tokenTool;
-    private eventSinks;
-    constructor(artifactManager: ArtifactManager, runtimeAdapter: RuntimeAdapter, hostEndpoint?: string);
-    handleMessage(message: string): Promise<string | undefined>;
-    private writeEvent;
-    private pushEvent;
-    addEventSink(sink: (event: Record<string, unknown>) => void): void;
-    removeEventSink(sink: (event: Record<string, unknown>) => void): void;
-    appendHostLog(line: string): void;
-    private handleRuntimeEvent;
-    private snapshotPendingConnectionSummary;
-    private noteIncomingConnection;
-    private handleIncomingConnectionDisconnected;
-    private maybeAutoStartStreamFromRemoteDemand;
-    private dispatch;
-    private handleInitialize;
-    private handleHostStatus;
-    private handleHostShutdown;
-    private handleServiceStart;
-    private handleServiceStop;
-    private handleConnectionGet;
-    private handleConnectionConnect;
-    private startDeferredSendStreamsOnConnected;
-    private activatePendingStreamsOnConnected;
-    private handleConnectionDisconnect;
-    private handleStreamList;
-    private handleStreamSendStart;
-    private handleStreamSendStop;
-    private handleStreamMessageSend;
-    private handleStreamReceiveStart;
-    private handleStreamReceiveStop;
-    private handleOutputAttach;
-    private handleOutputDetach;
-    private handleCommandSend;
-    private handleCommandReply;
-    private handleCommandPendingList;
-    private handleEventsSubscribe;
-    private handleArtifactReadReport;
-    private handleArtifactExportLogs;
-    private handleArtifactExportReport;
-    private handleDebugTokenQrcode;
-}