tirtc-devtools-cli 0.0.1

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

@@ -0,0 +1,256 @@
+"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.parseStreamReceiveStartParams = parseStreamReceiveStartParams;
+exports.parseOutputAttachParams = parseOutputAttachParams;
+exports.parseOutputDetachParams = parseOutputDetachParams;
+exports.parseCommandSendParams = parseCommandSendParams;
+exports.parseEventsSubscribeParams = parseEventsSubscribeParams;
+exports.parseArtifactExportParams = parseArtifactExportParams;
+exports.parseStreamRequestPolicySetParams = parseStreamRequestPolicySetParams;
+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 getOptionalBoolean(params, key) {
+    const value = params[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'boolean') {
+        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) {
+    return {
+        serviceEntry: getOptionalString(params, 'serviceEntry'),
+        license: getString(params, 'license'),
+        timeoutMs: getNumber(params, 'timeoutMs'),
+    };
+}
+function parseConnectionConnectParams(params) {
+    const token = getOptionalString(params, 'token');
+    const rawTokenMode = getOptionalString(params, 'tokenMode');
+    const tokenMode = rawTokenMode === undefined ? undefined : (() => {
+        if (rawTokenMode !== 'manual' && rawTokenMode !== 'auto') {
+            throw new HostProtocolError('invalid_request', 'Invalid tokenMode', false);
+        }
+        return rawTokenMode;
+    })();
+    const autoTokenRaw = params.autoToken;
+    let autoToken;
+    if (autoTokenRaw !== undefined) {
+        if (!isRecord(autoTokenRaw)) {
+            throw new HostProtocolError('invalid_request', 'Invalid autoToken', false);
+        }
+        autoToken = {
+            openapiEntry: getOptionalString(autoTokenRaw, 'openapiEntry'),
+            accessId: getString(autoTokenRaw, 'accessId'),
+            secretKey: getString(autoTokenRaw, 'secretKey'),
+            localId: getOptionalString(autoTokenRaw, 'localId'),
+            userTtlSeconds: getOptionalNumber(autoTokenRaw, 'userTtlSeconds'),
+            channelTtlSeconds: getOptionalNumber(autoTokenRaw, 'channelTtlSeconds'),
+        };
+    }
+    if (!token && !autoToken) {
+        throw new HostProtocolError('invalid_request', 'connection/connect requires token or autoToken', false);
+    }
+    return {
+        serviceEntry: getOptionalString(params, 'serviceEntry'),
+        peerId: getString(params, 'peerId'),
+        token,
+        tokenMode,
+        autoToken,
+        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 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'),
+        kind: getString(params, 'kind'),
+        payloadEncoding: getString(params, 'payloadEncoding'),
+        payload: getString(params, 'payload'),
+        replyToSequenceNumber: getOptionalNumber(params, 'replyToSequenceNumber'),
+        awaitResponse: getOptionalBoolean(params, 'awaitResponse'),
+        timeoutMs: getOptionalNumber(params, 'timeoutMs'),
+    };
+}
+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 parseStreamRequestPolicySetParams(params) {
+    const mode = getString(params, 'mode');
+    if (mode !== 'manual' && mode !== 'auto-if-bound') {
+        throw new HostProtocolError('invalid_request', 'Invalid mode', false);
+    }
+    return {
+        mode,
+    };
+}
+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

@@ -0,0 +1,49 @@
+import { ArtifactManager } from './ArtifactManager';
+import { RuntimeAdapter } from './RuntimeAdapter';
+export declare class HostServer {
+    private state;
+    private artifactManager;
+    private runtimeAdapter;
+    private isInitialized;
+    private eventCounter;
+    private commandSequence;
+    private tokenTool;
+    private runtimeCredentialTokenIssuer;
+    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 maybeAutoStartStreamFromRemoteDemand;
+    private dispatch;
+    private handleInitialize;
+    private handleHostStatus;
+    private handleHostShutdown;
+    private handleServiceStart;
+    private handleServiceStop;
+    private handleConnectionGet;
+    private resolveConnectionToken;
+    private handleConnectionConnect;
+    private startDeferredSendStreamsOnConnected;
+    private activatePendingStreamsOnConnected;
+    private handleConnectionDisconnect;
+    private handleStreamList;
+    private handleStreamSendStart;
+    private handleStreamSendStop;
+    private handleStreamReceiveStart;
+    private handleStreamReceiveStop;
+    private handleStreamRequestPolicyGet;
+    private handleStreamRequestPolicySet;
+    private handleOutputAttach;
+    private handleOutputDetach;
+    private handleCommandSend;
+    private handleEventsSubscribe;
+    private handleArtifactReadReport;
+    private handleArtifactExportLogs;
+    private handleArtifactExportReport;
+    private handleDebugTokenQrcode;
+}