tirtc-devtools-cli 0.0.14 → 0.1.0

package/README.md

@@ -16,7 +16,7 @@
 - 不提供长驻 Host、HTTP API、共享 session 或桌面 UI。
 - 不替代业务鉴权系统；token 签发只服务 DevTools 联调与验收。
 - 不把 `bootstrap.json` 定义成移动端接入协议；它只是本机 CLI receive、sample smoke 和 validation automation 的交接产物。
-- 不宣称 Linux native send/receive 调试已支持；当前外部调试发布面先按 `macos-arm64` 收口。
+- 不提供长驻 Linux 服务端；Linux 调试发布面是 `linux-x64` native CLI/driver，运行在 Linux host 或 `linux/amd64` container。
 
 ## 依赖方向
 

package/USAGE.md

@@ -16,9 +16,7 @@ node products/cli/bin/tirtc-devtools-cli.js --help
 ## Platform Support
 
 - `macos-arm64`: supported for token, assets prepare, send, receive, package smoke, and native send+receive qualification.
-- `linux-x64`: runtime package surface and cross-build are covered, but native send/receive qualification is not a supported external debugging path yet.
-
-Do not treat Linux send/receive as ready until the Linux headless receive driver or a containerized online runner is delivered.
+- `linux-x64`: supported for token, assets prepare, send, receive, package smoke, and native driver packaging. Linux native send/receive runs through the packaged headless driver on Linux hosts or `linux/amd64` containers.
 
 ## Token
 

package/dist/cli/src/index.js

@@ -1,10 +1,26 @@
 "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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const embedded_paths_1 = require("./embedded_paths");
 const media_assets_1 = require("./media_assets");
 const token_command_1 = require("./token_command");
 const role_driver_1 = require("./role_driver");
-const cliVersion = '0.0.14';
+function resolveCliVersion() {
+    try {
+        const packageRoot = (0, embedded_paths_1.resolveCliPackageRoot)(__dirname);
+        const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(packageRoot, 'package.json'), 'utf8'));
+        return typeof packageJson.version === 'string' ? packageJson.version : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const cliVersion = resolveCliVersion();
 if (process.argv.includes('--version') || process.argv.includes('-V')) {
     console.log('CLI Version: ' + cliVersion);
     console.log('DevTools Driver Contract: 1');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirtc-devtools-cli",
-  "version": "0.0.14",
+  "version": "0.1.0",
   "private": false,
   "main": "dist/cli/src/index.js",
   "types": "dist/cli/src/index.d.ts",
@@ -30,7 +30,8 @@
     "lint": "eslint . --ext .ts --max-warnings=0",
     "lint:fix": "eslint . --ext .ts --fix",
     "package": "./script/package.sh",
-    "release:npm": "./script/release-npm.sh"
+    "release:npm": "./script/release-npm.sh",
+    "release:devtools-cli": "./script/release_devtools_cli.sh"
   },
   "pkg": {
     "assets": [

package/vendor/runtime/linux-x64/include/tirtc/audio.h

@@ -0,0 +1,216 @@
+#ifndef TIRTC_FACADE_AUDIO_H_
+#define TIRTC_FACADE_AUDIO_H_
+
+#include <stdint.h>
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/audio_io.h"
+#include "tirtc/audio_processing.h"
+#include "tirtc/media_codec.h"
+#include "tirtc/trp.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcAudioInput TirtcAudioInput;
+
+typedef struct TirtcAudioEncodedInput TirtcAudioEncodedInput;
+
+typedef struct TirtcAudioOutput TirtcAudioOutput;
+
+typedef enum TirtcInputState {
+
+  TIRTC_INPUT_STATE_IDLE = 0,
+
+  TIRTC_INPUT_STATE_RUNNING = 1,
+
+  TIRTC_INPUT_STATE_STOPPED = 2,
+
+  TIRTC_INPUT_STATE_FAILED = 3,
+} TirtcInputState;
+
+typedef enum TirtcAudioOutputState {
+
+  TIRTC_AUDIO_OUTPUT_STATE_IDLE = 0,
+
+  TIRTC_AUDIO_OUTPUT_STATE_BUFFERING = 1,
+
+  TIRTC_AUDIO_OUTPUT_STATE_PLAYING = 2,
+
+  TIRTC_AUDIO_OUTPUT_STATE_FAILED = 3,
+} TirtcAudioOutputState;
+
+typedef struct TirtcAudioInputOptions {
+  TirtcAudioSampleRate sample_rate;
+
+  TirtcAudioAecMode aec_mode;
+
+  TirtcAudioAgcLevel agc_level;
+
+  TirtcAudioAnsLevel ans_level;
+} TirtcAudioInputOptions;
+
+/**
+ * Options for a facade audio encoded input.
+ *
+ * The encoded input does not own or create an audio source. Callers submit already-encoded audio
+ * frames with `tirtc_audio_encoded_input_submit_frame()`. Non-NONE fields constrain submitted
+ * frames and reject mismatched packets with `TIRTC_ERROR_INVALID_ARGUMENT`.
+ */
+typedef struct TirtcAudioEncodedInputOptions {
+  TirtcMediaCodec codec;
+
+  TirtcAudioSampleRate sample_rate;
+} TirtcAudioEncodedInputOptions;
+
+typedef struct TirtcAudioOutputOptions {
+  uint32_t volume_percent;
+
+  TirtcAudioAgcLevel agc_level;
+
+  TirtcAudioAnsLevel ans_level;
+} TirtcAudioOutputOptions;
+
+typedef struct TirtcOutputStutterMetrics {
+  int session_started;
+  uint64_t session_duration_ms;
+  uint64_t session_stutter_total_ms;
+  uint32_t session_stutter_count;
+  uint64_t session_stutter_peak_ms;
+  double session_stutter_ratio;
+  uint32_t recent_window_duration_ms;
+  uint64_t recent_window_stutter_total_ms;
+  uint32_t recent_window_stutter_count;
+  uint64_t recent_window_stutter_peak_ms;
+  double recent_window_stutter_ratio;
+} TirtcOutputStutterMetrics;
+
+typedef struct TirtcPendingDurationMetrics {
+  uint64_t undecoded_duration_ms;
+  uint64_t decoded_duration_ms;
+} TirtcPendingDurationMetrics;
+
+typedef struct TirtcAudioOutputMetricsSnapshot {
+  TirtcOutputStutterMetrics stutter;
+  TirtcPendingDurationMetrics pending;
+} TirtcAudioOutputMetricsSnapshot;
+
+/**
+ * Audio input observer.
+ *
+ * `owned_message` is allocated by facade for this callback dispatch. Consumers must release it
+ * with `tirtc_owned_string_release()` after copying or converting the string they need.
+ */
+typedef struct TirtcAudioInputObserver {
+  void (*on_state_changed)(TirtcAudioInput* input, TirtcInputState state, void* user_data);
+
+  void (*on_error)(TirtcAudioInput* input, TirtcError error, TirtcOwnedString* owned_message,
+                   void* user_data);
+} TirtcAudioInputObserver;
+
+/**
+ * Audio encoded input observer.
+ *
+ * State callbacks report only facade input lifecycle changes. They do not mean a remote consumer
+ * has subscribed to, decoded, or rendered the stream. `owned_message` is allocated by facade for
+ * this callback dispatch; consumers must release it with `tirtc_owned_string_release()`.
+ */
+typedef struct TirtcAudioEncodedInputObserver {
+  void (*on_state_changed)(TirtcAudioEncodedInput* input, TirtcInputState state, void* user_data);
+
+  void (*on_error)(TirtcAudioEncodedInput* input, TirtcError error, TirtcOwnedString* owned_message,
+                   void* user_data);
+} TirtcAudioEncodedInputObserver;
+
+/**
+ * Audio output observer.
+ *
+ * `owned_message` is allocated by facade for this callback dispatch. Consumers must release it
+ * with `tirtc_owned_string_release()` after copying or converting the string they need.
+ */
+typedef struct TirtcAudioOutputObserver {
+  void (*on_state_changed)(TirtcAudioOutput* output, TirtcAudioOutputState state, void* user_data);
+
+  void (*on_error)(TirtcAudioOutput* output, TirtcError error, TirtcOwnedString* owned_message,
+                   void* user_data);
+} TirtcAudioOutputObserver;
+
+TirtcError tirtc_conn_subscribe_audio(TirtcConn* connection, uint8_t stream_id);
+
+TirtcError tirtc_conn_unsubscribe_audio(TirtcConn* connection, uint8_t stream_id);
+
+TirtcError tirtc_audio_input_create(TirtcAudioInput** out_input);
+
+TirtcError tirtc_audio_input_set_ain(TirtcAudioInput* input, TirtcAudioAin* ain);
+
+TirtcError tirtc_audio_input_set_options(TirtcAudioInput* input,
+                                         const TirtcAudioInputOptions* options);
+
+TirtcError tirtc_audio_input_set_observer(TirtcAudioInput* input,
+                                          const TirtcAudioInputObserver* observer, void* user_data);
+
+TirtcError tirtc_audio_input_start(TirtcAudioInput* input);
+
+TirtcError tirtc_audio_input_stop(TirtcAudioInput* input);
+
+TirtcError tirtc_audio_input_attach(TirtcAudioInput* input, TirtcConn* connection,
+                                    uint8_t stream_id);
+
+TirtcError tirtc_audio_input_detach(TirtcAudioInput* input, TirtcConn* connection);
+
+void tirtc_audio_input_destroy(TirtcAudioInput* input);
+
+TirtcError tirtc_audio_encoded_input_create(TirtcAudioEncodedInput** out_input);
+
+TirtcError tirtc_audio_encoded_input_set_options(TirtcAudioEncodedInput* input,
+                                                 const TirtcAudioEncodedInputOptions* options);
+
+TirtcError tirtc_audio_encoded_input_set_observer(TirtcAudioEncodedInput* input,
+                                                  const TirtcAudioEncodedInputObserver* observer,
+                                                  void* user_data);
+
+TirtcError tirtc_audio_encoded_input_start(TirtcAudioEncodedInput* input);
+
+TirtcError tirtc_audio_encoded_input_stop(TirtcAudioEncodedInput* input);
+
+TirtcError tirtc_audio_encoded_input_attach(TirtcAudioEncodedInput* input, TirtcConn* connection,
+                                            uint8_t stream_id);
+
+TirtcError tirtc_audio_encoded_input_detach(TirtcAudioEncodedInput* input, TirtcConn* connection);
+
+TirtcError tirtc_audio_encoded_input_submit_frame(TirtcAudioEncodedInput* input,
+                                                  const TirtcAudioEncodedFrame* frame);
+
+void tirtc_audio_encoded_input_destroy(TirtcAudioEncodedInput* input);
+
+TirtcError tirtc_audio_output_create(TirtcAudioOutput** out_output);
+
+TirtcError tirtc_audio_output_set_aout(TirtcAudioOutput* output, TirtcAudioAout* aout);
+
+TirtcError tirtc_audio_output_set_options(TirtcAudioOutput* output,
+                                          const TirtcAudioOutputOptions* options);
+
+TirtcError tirtc_audio_output_set_observer(TirtcAudioOutput* output,
+                                           const TirtcAudioOutputObserver* observer,
+                                           void* user_data);
+
+TirtcError tirtc_audio_output_attach(TirtcAudioOutput* output, TirtcConn* connection,
+                                     uint8_t stream_id);
+
+TirtcError tirtc_audio_output_detach(TirtcAudioOutput* output);
+
+void tirtc_audio_output_destroy(TirtcAudioOutput* output);
+
+TirtcError tirtc_audio_output_start_raw_dump(TirtcAudioOutput* output);
+
+TirtcError tirtc_audio_output_stop_raw_dump(TirtcAudioOutput* output);
+
+TirtcError tirtc_metrics_audio_output_get_snapshot(TirtcAudioOutput* output,
+                                                   TirtcAudioOutputMetricsSnapshot* out_snapshot);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/vendor/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/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/runtime/linux-x64/include/tirtc/audio_io.h

@@ -0,0 +1,65 @@
+#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;
+  /* AIN uses fixed 10 ms mono blocks; AOUT may use larger callback-sized multiples. */
+  uint32_t samples_per_buffer;
+} TirtcAudioIoConfig;
+
+typedef struct TirtcAudioHeadlessAoutOptions {
+  const char* first_output_json_path;
+  const char* pcm_path;
+  uint32_t max_capture_bytes;
+} TirtcAudioHeadlessAoutOptions;
+
+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_create_headless_capture(const TirtcAudioHeadlessAoutOptions* options,
+                                                    TirtcAudioAout** out_aout);
+
+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/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/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/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/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_

package/vendor/runtime/linux-x64/include/tirtc/audio_processing.h

@@ -0,0 +1,56 @@
+#ifndef TIRTC_AUDIO_PROCESSING_H_
+#define TIRTC_AUDIO_PROCESSING_H_
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcAudioProcessor TirtcAudioProcessor;
+
+typedef enum TirtcAudioAecMode {
+  TIRTC_AUDIO_AEC_MODE_DISABLED = 0,
+  TIRTC_AUDIO_AEC_MODE_ENABLED = 1,
+} TirtcAudioAecMode;
+
+typedef enum TirtcAudioAnsLevel {
+  TIRTC_AUDIO_ANS_LEVEL_DISABLED = 0,
+  TIRTC_AUDIO_ANS_LEVEL_LOW = 1,
+  TIRTC_AUDIO_ANS_LEVEL_MEDIUM = 2,
+  TIRTC_AUDIO_ANS_LEVEL_HIGH = 3,
+} TirtcAudioAnsLevel;
+
+typedef enum TirtcAudioAgcLevel {
+  TIRTC_AUDIO_AGC_LEVEL_DISABLED = 0,
+  TIRTC_AUDIO_AGC_LEVEL_LOW = 1,
+  TIRTC_AUDIO_AGC_LEVEL_MEDIUM = 2,
+  TIRTC_AUDIO_AGC_LEVEL_HIGH = 3,
+} TirtcAudioAgcLevel;
+
+typedef struct TirtcAudioProcessorConfig {
+  TirtcAudioSampleRate sample_rate;
+  TirtcAudioAecMode aec_mode;
+  TirtcAudioAnsLevel ans_level;
+  TirtcAudioAgcLevel agc_level;
+} TirtcAudioProcessorConfig;
+
+TirtcError tirtc_audio_processor_create(const TirtcAudioProcessorConfig* config,
+                                        TirtcAudioProcessor** out_processor);
+void tirtc_audio_processor_destroy(TirtcAudioProcessor* processor);
+
+TirtcError tirtc_audio_processor_set_config(TirtcAudioProcessor* processor,
+                                            const TirtcAudioProcessorConfig* config);
+
+TirtcError tirtc_audio_processor_process(TirtcAudioProcessor* processor,
+                                         const TirtcAudioPcmFrame* in_frame,
+                                         TirtcAudioPcmFrame* out_frame);
+
+TirtcError tirtc_audio_processor_reset(TirtcAudioProcessor* processor);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_PROCESSING_H_

package/vendor/runtime/linux-x64/include/tirtc/audio_sample_rate.h

@@ -0,0 +1,18 @@
+#ifndef TIRTC_MEDIA_CONTRACT_AUDIO_SAMPLE_RATE_H_
+#define TIRTC_MEDIA_CONTRACT_AUDIO_SAMPLE_RATE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum TirtcAudioSampleRate {
+  TIRTC_AUDIO_SAMPLE_RATE_NONE = 0,
+  TIRTC_AUDIO_SAMPLE_RATE_8K = 8000,
+  TIRTC_AUDIO_SAMPLE_RATE_16K = 16000,
+} TirtcAudioSampleRate;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_CONTRACT_AUDIO_SAMPLE_RATE_H_