tirtc-devtools-cli 0.0.1

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

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.issueToken = issueToken;
+exports.buildIssuedTokenPayload = buildIssuedTokenPayload;
+exports.writePngQrcode = writePngQrcode;
+exports.issueTokenWithQrcode = issueTokenWithQrcode;
+exports.formatTokenIssueConsoleOutput = formatTokenIssueConsoleOutput;
+const module_1 = require("module");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const qrcode_1 = __importDefault(require("qrcode"));
+const embedded_paths_1 = require("./embedded_paths");
+const runtimeRequire = (0, module_1.createRequire)(__filename);
+const kDefaultOpenapiEntry = 'http://api-test-tirtc.tange365.com';
+const kDefaultUserTtlSeconds = 86400;
+const kDefaultChannelTtlSeconds = 300;
+function pathExists(filePath) {
+    return fs_1.default.existsSync(filePath);
+}
+function ensureDirectory(dirPath) {
+    fs_1.default.mkdirSync(dirPath, { recursive: true });
+}
+function sanitizePathSegment(text) {
+    return text.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'value';
+}
+function resolveQrCodeOutputDir() {
+    return path_1.default.resolve(process.cwd(), '.tmp/tirtc-devtool/qrcode');
+}
+function buildQrCodePngPath(payload) {
+    const fileName = [
+        'token',
+        sanitizePathSegment(payload.local_id),
+        sanitizePathSegment(payload.peer_id),
+        Date.now().toString(),
+    ].join('-') + '.png';
+    return path_1.default.join(resolveQrCodeOutputDir(), fileName);
+}
+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(), 'devtools/cli/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) {
+        if (pathExists(path_1.default.join(candidate, 'manifest.txt'))) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function resolveRepoRoot() {
+    const embeddedAppServerRoot = (0, embedded_paths_1.resolveEmbeddedAppServerRoot)(__dirname);
+    if (embeddedAppServerRoot) {
+        return path_1.default.resolve(embeddedAppServerRoot, '..');
+    }
+    const candidates = [
+        path_1.default.resolve(__dirname, '../../../../../../'),
+        path_1.default.resolve(__dirname, '../../../../../'),
+        path_1.default.resolve(__dirname, '../../../..'),
+        path_1.default.resolve(process.cwd()),
+    ];
+    for (const candidate of candidates) {
+        if (pathExists(path_1.default.join(candidate, 'app-server')) && pathExists(path_1.default.join(candidate, 'devtools'))) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function ensureRuntimeBundleReady(runtimeBundleRoot) {
+    const includeDir = path_1.default.join(runtimeBundleRoot, 'include');
+    const libDir = path_1.default.join(runtimeBundleRoot, 'lib');
+    if (!pathExists(includeDir) || !pathExists(libDir)) {
+        throw new Error('runtime-backed sdk bundle is missing: ' + runtimeBundleRoot);
+    }
+}
+function resolveAddonPath(repoRoot, runtimePlatform) {
+    const explicit = process.env.TIRTC_CREDENTIAL_ADDON_PATH;
+    const candidates = [
+        explicit,
+        path_1.default.join(repoRoot, `app-server/bin/native/${runtimePlatform}/credential_napi.node`),
+        path_1.default.join(repoRoot, `app-server/.build/app-server/native/${runtimePlatform}/credential_napi.node`),
+        path_1.default.resolve(process.cwd(), `app-server/bin/native/${runtimePlatform}/credential_napi.node`),
+        path_1.default.resolve(process.cwd(), `.build/app-server/native/${runtimePlatform}/credential_napi.node`),
+    ].filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+    for (const candidate of candidates) {
+        const normalized = path_1.default.resolve(candidate);
+        if (pathExists(normalized)) {
+            return normalized;
+        }
+    }
+    throw new Error('credential addon missing for platform ' + runtimePlatform +
+        '; run: npm --prefix app-server run build:native');
+}
+function loadCredentialBinding() {
+    const runtimePlatform = resolveRuntimePlatform();
+    const runtimeBundleRoot = resolveRuntimeBundleRoot(runtimePlatform);
+    const repoRoot = resolveRepoRoot();
+    ensureRuntimeBundleReady(runtimeBundleRoot);
+    const addonPath = resolveAddonPath(repoRoot, runtimePlatform);
+    const loaded = runtimeRequire(addonPath);
+    if (!loaded || typeof loaded.issueToken !== 'function') {
+        throw new Error('credential addon missing issueToken() export: ' + addonPath);
+    }
+    return loaded;
+}
+function normalizeIssuedToken(token) {
+    const normalized = token.trim();
+    if (normalized.length === 0) {
+        throw new Error('issue token failed: empty token');
+    }
+    return normalized;
+}
+async function issueToken(input) {
+    const binding = loadCredentialBinding();
+    let token;
+    try {
+        token = binding.issueToken({
+            openapiEntry: input.openapiEntry,
+            accessId: input.accessId,
+            secretKey: input.secretKey,
+            localId: input.localId,
+            peerId: input.peerId,
+            userTtlSeconds: input.userTtlSeconds,
+            channelTtlSeconds: input.channelTtlSeconds,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error('issue token failed: ' + message);
+    }
+    return normalizeIssuedToken(token);
+}
+function buildIssuedTokenPayload(input, token) {
+    return {
+        version: 1,
+        type: 'tirtc-connect-token',
+        peer_id: input.peerId,
+        local_id: input.localId,
+        service_entry: input.serviceEntry ?? '',
+        token,
+        openapi_entry: input.openapiEntry?.trim() || kDefaultOpenapiEntry,
+        user_ttl_seconds: input.userTtlSeconds ?? kDefaultUserTtlSeconds,
+        channel_ttl_seconds: input.channelTtlSeconds ?? kDefaultChannelTtlSeconds,
+        generated_at: new Date().toISOString(),
+    };
+}
+async function writePngQrcode(payloadJson, outputPath) {
+    const resolvedPath = path_1.default.resolve(outputPath);
+    ensureDirectory(path_1.default.dirname(resolvedPath));
+    await qrcode_1.default.toFile(resolvedPath, payloadJson, {
+        errorCorrectionLevel: 'M',
+        margin: 2,
+        type: 'png',
+        width: 960,
+    });
+    return resolvedPath;
+}
+async function issueTokenWithQrcode(input) {
+    const token = await issueToken(input);
+    const payload = buildIssuedTokenPayload(input, token);
+    const payloadJson = JSON.stringify(payload);
+    const qrCodePngPath = await writePngQrcode(payloadJson, buildQrCodePngPath(payload));
+    return {
+        payload,
+        payloadJson,
+        token,
+        qrCodePngPath,
+    };
+}
+function formatTokenIssueConsoleOutput(output) {
+    const summaryLines = [
+        'Issued Token Summary:',
+        '  local_id: ' + output.payload.local_id,
+        '  peer_id: ' + output.payload.peer_id,
+        '  service_entry: ' + (output.payload.service_entry || '(empty)'),
+        '  openapi_entry: ' + output.payload.openapi_entry,
+        '  user_ttl_seconds: ' + output.payload.user_ttl_seconds,
+        '  channel_ttl_seconds: ' + output.payload.channel_ttl_seconds,
+        '  generated_at: ' + output.payload.generated_at,
+        '',
+        'Token:',
+        output.token,
+        '',
+        'Payload JSON:',
+        JSON.stringify(output.payload, null, 2),
+        '',
+        'QR Code PNG:',
+        output.qrCodePngPath,
+    ];
+    return summaryLines.join('\n');
+}

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

@@ -0,0 +1,30 @@
+import { Transport } from '../../../app-server/protocol-client';
+type ProcessTransportOptions = {
+    env?: NodeJS.ProcessEnv;
+};
+export declare class ProcessTransport implements Transport {
+    private child;
+    private messageHandler;
+    private closeHandler;
+    private errorHandler;
+    constructor(command: string, args: string[], options?: ProcessTransportOptions);
+    send(data: string): void;
+    onMessage(handler: (data: string) => void): void;
+    onClose(handler: () => void): void;
+    onError(handler: (error: Error) => void): void;
+    stop(): void;
+    getPid(): number;
+}
+export declare class SocketTransport implements Transport {
+    private socket;
+    private messageHandler;
+    private closeHandler;
+    private errorHandler;
+    constructor(socketPath: string);
+    send(data: string): void;
+    onMessage(handler: (data: string) => void): void;
+    onClose(handler: () => void): void;
+    onError(handler: (error: Error) => void): void;
+    stop(): void;
+}
+export {};

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

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketTransport = exports.ProcessTransport = void 0;
+const net_1 = __importDefault(require("net"));
+const child_process_1 = require("child_process");
+class ProcessTransport {
+    child;
+    messageHandler = () => { };
+    closeHandler = () => { };
+    errorHandler = () => { };
+    constructor(command, args, options) {
+        const env = options?.env ? { ...process.env, ...options.env } : process.env;
+        this.child = (0, child_process_1.spawn)(command, args, {
+            stdio: ['pipe', 'pipe', 'inherit'],
+            env,
+        });
+        this.child.stdout?.on('data', (data) => {
+            this.messageHandler(data.toString());
+        });
+        this.child.on('error', (err) => {
+            this.errorHandler(err);
+        });
+        this.child.on('close', () => {
+            this.closeHandler();
+        });
+    }
+    send(data) {
+        this.child.stdin?.write(data);
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
+    onError(handler) {
+        this.errorHandler = handler;
+    }
+    stop() {
+        this.child.kill();
+    }
+    getPid() {
+        return this.child.pid ?? -1;
+    }
+}
+exports.ProcessTransport = ProcessTransport;
+class SocketTransport {
+    socket;
+    messageHandler = () => { };
+    closeHandler = () => { };
+    errorHandler = () => { };
+    constructor(socketPath) {
+        this.socket = net_1.default.createConnection(socketPath);
+        this.socket.on('data', (data) => {
+            this.messageHandler(data.toString());
+        });
+        this.socket.on('close', () => {
+            this.closeHandler();
+        });
+        this.socket.on('error', (error) => {
+            this.errorHandler(error);
+        });
+    }
+    send(data) {
+        this.socket.write(data);
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
+    onError(handler) {
+        this.errorHandler = handler;
+    }
+    stop() {
+        this.socket.end();
+        this.socket.destroy();
+    }
+}
+exports.SocketTransport = SocketTransport;

package/dist/dummy.js

@@ -0,0 +1 @@
+"use strict";

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const program = new commander_1.Command();
+const CLI_VERSION = '1.0.0';
+function getHostBinaryPath() {
+    // Local development path relative to dist/index.js
+    const localDevPath = path_1.default.resolve(__dirname, '../../../app-server/bin/tirtc-devtool-host.js');
+    if (fs_1.default.existsSync(localDevPath)) {
+        return localDevPath;
+    }
+    // Fallback to globally installed or in PATH
+    return 'tirtc-devtool-host';
+}
+program
+    .name('tirtc-devtool')
+    .description('TiRTC Developer Tool CLI')
+    .option('-v, --version', 'output the version number')
+    .action((options) => {
+    if (options.version) {
+        console.log(`CLI Version: ${CLI_VERSION}`);
+        const hostPath = getHostBinaryPath();
+        let hostCmdPath = hostPath;
+        let hostArgs = ['--version'];
+        if (hostPath.endsWith('.js')) {
+            hostArgs = [hostPath, '--version'];
+            hostCmdPath = process.execPath;
+        }
+        try {
+            const result = (0, child_process_1.spawnSync)(hostCmdPath, hostArgs, { encoding: 'utf-8' });
+            if (result.stdout) {
+                process.stdout.write(result.stdout);
+            }
+        }
+        catch (e) {
+            console.log('Host Version: unknown');
+            console.log('Protocol Version: unknown');
+        }
+        process.exit(0);
+    }
+});
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "tirtc-devtools-cli",
+  "version": "0.0.1",
+  "private": false,
+  "main": "dist/index.js",
+  "bin": {
+    "tirtc-devtool": "./bin/tirtc-devtool.js"
+  },
+  "files": [
+    "README.md",
+    "USAGE.md",
+    "bin/tirtc-devtool.js",
+    "dist",
+    "script/ensure_ffmpeg.sh",
+    "vendor"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:owner": "./script/test.sh owner",
+    "test:publish": "./script/test.sh publish",
+    "test:real-transport": "./script/test.sh real-transport",
+    "test:e2e": "./script/test.sh e2e",
+    "test:two-endpoints": "./script/test.sh two-endpoints",
+    "test:acceptance": "./script/test.sh acceptance",
+    "lint": "eslint . --ext .ts --max-warnings=0",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "package": "./script/package.sh",
+    "release:npm": "./script/release-npm.sh"
+  },
+  "pkg": {
+    "assets": [
+      "dist/**/*"
+    ]
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@types/qrcode": "^1.5.5",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.5.0",
+    "pkg": "^5.8.1",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "commander": "^11.0.0",
+    "qrcode": "^1.5.4",
+    "zod": "^3.22.4"
+  }
+}

package/script/ensure_ffmpeg.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+CLI_ROOT=$(cd "$SCRIPT_DIR/.." && pwd)
+CLI_DIST="$CLI_ROOT/dist/devtools/cli/src/ffmpeg_tool.js"
+
+if [[ ! -f "$CLI_DIST" ]]; then
+  echo "[ensure_ffmpeg] compiled helper missing: $CLI_DIST" >&2
+  echo "[ensure_ffmpeg] run: npm --prefix $CLI_ROOT run build" >&2
+  exit 1
+fi
+
+CLI_DIST="$CLI_DIST" node <<'NODE'
+const helperPath = process.env.CLI_DIST;
+if (!helperPath) {
+  throw new Error('missing CLI_DIST');
+}
+const {ensureFfmpegTools} = require(helperPath);
+const tools = ensureFfmpegTools();
+process.stdout.write(JSON.stringify(tools));
+NODE

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/audio_codec.h

@@ -0,0 +1,23 @@
+#ifndef TIRTC_AUDIO_CODEC_H_
+#define TIRTC_AUDIO_CODEC_H_
+
+#include <stddef.h>
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+TirtcError tirtc_audio_g711a_encode(const TirtcAudioPcmFrame* pcm_frame, void* out_buffer,
+                                    size_t out_buffer_capacity, TirtcAudioEncodedFrame* out_frame);
+
+TirtcError tirtc_audio_g711a_decode(const TirtcAudioEncodedFrame* in_frame, void* out_buffer,
+                                    size_t out_buffer_capacity, TirtcAudioPcmFrame* out_frame);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_CODEC_H_

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/audio_frame.h

@@ -0,0 +1,36 @@
+#ifndef TIRTC_AUDIO_FRAME_H_
+#define TIRTC_AUDIO_FRAME_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "tirtc/audio_sample_rate.h"
+#include "tirtc/media_codec.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcAudioPcmFrame {
+  TirtcAudioSampleRate sample_rate;
+  uint32_t samples_per_channel;
+  int64_t pts_us;
+  /* Mutable PCM payload for capture, processing, and render-fill paths. */
+  void* data;
+  size_t data_bytes;
+} TirtcAudioPcmFrame;
+
+typedef struct TirtcAudioEncodedFrame {
+  TirtcMediaCodec codec;
+  TirtcAudioSampleRate sample_rate;
+  uint32_t samples_per_channel;
+  int64_t pts_us;
+  const void* data;
+  size_t data_bytes;
+} TirtcAudioEncodedFrame;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_FRAME_H_

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/audio_io.h

@@ -0,0 +1,56 @@
+#ifndef TIRTC_AUDIO_IO_H_
+#define TIRTC_AUDIO_IO_H_
+
+#include <stdint.h>
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcAudioAin TirtcAudioAin;
+typedef struct TirtcAudioAout TirtcAudioAout;
+
+typedef struct TirtcAudioIoConfig {
+  TirtcAudioSampleRate sample_rate;
+  /* v1 uses fixed 10 ms mono blocks: 8K -> 80 samples, 16K -> 160 samples. */
+  uint32_t samples_per_buffer;
+} TirtcAudioIoConfig;
+
+typedef void (*TirtcAudioAinOnFrameFn)(TirtcAudioAin* ain, const TirtcAudioPcmFrame* frame,
+                                       void* user_data);
+
+/*
+ * AOUT pre-fills sample_rate, samples_per_channel, data, and data_bytes before
+ * calling render. The callback contract expects a non-negative rendered PCM
+ * byte count. Backends defensively clamp negative returns to zero and zero-fill
+ * any remaining buffer space.
+ *
+ * The render callback and user_data supplied at open-time must stay valid until
+ * close completes. Backends may invoke render without holding backend locks.
+ */
+typedef int (*TirtcAudioAoutRenderFn)(TirtcAudioAout* aout, TirtcAudioPcmFrame* frame,
+                                      void* user_data);
+
+TirtcError tirtc_audio_ain_open(TirtcAudioAin* ain, const TirtcAudioIoConfig* config,
+                                TirtcAudioAinOnFrameFn on_frame, void* user_data);
+
+TirtcError tirtc_audio_ain_close(TirtcAudioAin* ain);
+void tirtc_audio_ain_destroy(TirtcAudioAin* ain);
+
+TirtcError tirtc_audio_aout_open(TirtcAudioAout* aout, const TirtcAudioIoConfig* config,
+                                 TirtcAudioAoutRenderFn render, void* user_data);
+
+TirtcError tirtc_audio_aout_set_volume(TirtcAudioAout* aout, uint32_t volume_percent);
+TirtcError tirtc_audio_aout_pause(TirtcAudioAout* aout, int pause_on);
+TirtcError tirtc_audio_aout_flush(TirtcAudioAout* aout);
+TirtcError tirtc_audio_aout_close(TirtcAudioAout* aout);
+void tirtc_audio_aout_destroy(TirtcAudioAout* aout);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_H_

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/audio_io_android.h

@@ -0,0 +1,19 @@
+#ifndef TIRTC_AUDIO_IO_ANDROID_H_
+#define TIRTC_AUDIO_IO_ANDROID_H_
+
+#include "tirtc/audio_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__ANDROID__)
+TirtcError tirtc_audio_android_create_open_sl_ain(TirtcAudioAin** out_ain);
+TirtcError tirtc_audio_android_create_open_sl_aout(TirtcAudioAout** out_aout);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_ANDROID_H_

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/audio_io_apple.h

@@ -0,0 +1,19 @@
+#ifndef TIRTC_AUDIO_IO_APPLE_H_
+#define TIRTC_AUDIO_IO_APPLE_H_
+
+#include "tirtc/audio_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__APPLE__)
+TirtcError tirtc_audio_apple_create_audio_toolbox_ain(TirtcAudioAin** out_ain);
+TirtcError tirtc_audio_apple_create_audio_queue_aout(TirtcAudioAout** out_aout);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_APPLE_H_

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/audio_io_harmony.h

@@ -0,0 +1,19 @@
+#ifndef TIRTC_AUDIO_IO_HARMONY_H_
+#define TIRTC_AUDIO_IO_HARMONY_H_
+
+#include "tirtc/audio_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__OHOS__)
+TirtcError tirtc_audio_harmony_create_open_sl_ain(TirtcAudioAin** out_ain);
+TirtcError tirtc_audio_harmony_create_audio_render_aout(TirtcAudioAout** out_aout);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_HARMONY_H_

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/audio_io_windows.h

@@ -0,0 +1,19 @@
+#ifndef TIRTC_AUDIO_IO_WINDOWS_H_
+#define TIRTC_AUDIO_IO_WINDOWS_H_
+
+#include "tirtc/audio_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_WIN32)
+TirtcError tirtc_audio_windows_create_wasapi_ain(TirtcAudioAin** out_ain);
+TirtcError tirtc_audio_windows_create_wave_out_aout(TirtcAudioAout** out_aout);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_WINDOWS_H_