@tx5dr/contracts 1.7.3 → 1.7.4

package/src/schema/device-ui.schema.ts

@@ -0,0 +1,182 @@
+import { z } from 'zod';
+
+export const DEVICE_UI_JWT_TYPE = 'device-ui' as const;
+export const DEVICE_UI_JWT_AUDIENCE = 'tx5dr-device-ui' as const;
+
+export const DeviceUiJwtPayloadSchema = z.object({
+  typ: z.literal(DEVICE_UI_JWT_TYPE),
+  aud: z.literal(DEVICE_UI_JWT_AUDIENCE),
+  deviceId: z.string().min(1),
+  sessionId: z.string().min(1),
+  iat: z.number().int().nonnegative(),
+  exp: z.number().int().positive(),
+});
+
+export type DeviceUiJwtPayload = z.infer<typeof DeviceUiJwtPayloadSchema>;
+
+export const DeviceUiSessionRequestSchema = z.object({
+  deviceId: z.string().trim().min(1).max(128),
+  sessionToken: z.string().min(1),
+});
+
+export type DeviceUiSessionRequest = z.infer<typeof DeviceUiSessionRequestSchema>;
+
+export const DeviceUiSessionResponseSchema = z.object({
+  jwt: z.string().min(1),
+  deviceId: z.string().min(1),
+  sessionId: z.string().min(1),
+  expiresAt: z.number().int().positive(),
+});
+
+export type DeviceUiSessionResponse = z.infer<typeof DeviceUiSessionResponseSchema>;
+
+export const DeviceUiAuthSessionStateSchema = z.object({
+  sessionId: z.string().min(1),
+  deviceId: z.string().min(1),
+  createdAt: z.number().int().nonnegative(),
+  expiresAt: z.number().int().positive(),
+  lastVerifiedAt: z.number().int().nonnegative().optional(),
+  revoked: z.boolean().optional(),
+});
+
+export type DeviceUiAuthSessionState = z.infer<typeof DeviceUiAuthSessionStateSchema>;
+
+export const DeviceUiAuthStateSchema = z.object({
+  jwtSecret: z.string().min(32),
+  sessions: z.array(DeviceUiAuthSessionStateSchema).default([]),
+  updatedAt: z.number().int().nonnegative().optional(),
+});
+
+export type DeviceUiAuthState = z.infer<typeof DeviceUiAuthStateSchema>;
+
+const NullableStringSchema = z.string().nullable();
+const NullableNumberSchema = z.number().nullable();
+
+export const DeviceUiFrameSnapshotSchema = z.object({
+  slotId: NullableStringSchema.optional(),
+  slotStartMs: NullableNumberSchema.optional(),
+  snr: NullableNumberSchema,
+  freq: NullableNumberSchema,
+  dt: NullableNumberSchema,
+  message: z.string(),
+  operatorId: NullableStringSchema,
+  country: NullableStringSchema.optional(),
+  countryZh: NullableStringSchema.optional(),
+  countryEn: NullableStringSchema.optional(),
+  countryCode: NullableStringSchema.optional(),
+});
+
+export const DeviceUiCurrentTxSnapshotSchema = z.object({
+  active: z.boolean(),
+  operatorIds: z.array(z.string()),
+  messages: z.array(z.string()),
+  lastMessage: NullableStringSchema,
+  slotStartMs: NullableNumberSchema,
+});
+
+export const DeviceUiOperatorSnapshotSchema = z.object({
+  id: z.string(),
+  callsign: z.string(),
+  active: z.boolean(),
+  transmitting: z.boolean(),
+  ptt: z.boolean(),
+});
+
+export const DeviceUiCwSnapshotSchema = z.object({
+  decoder: z.object({
+    enabled: z.boolean(),
+    active: z.boolean(),
+    state: z.string(),
+    muted: z.boolean(),
+    pendingText: z.string(),
+    committedText: z.string(),
+    lastDecodeAt: NullableNumberSchema,
+    updatedAt: z.number().int().nonnegative(),
+  }),
+  keyer: z.object({
+    active: z.boolean(),
+    mode: NullableStringSchema,
+    messageId: NullableStringSchema,
+    currentText: NullableStringSchema,
+    lastText: NullableStringSchema,
+  }),
+  currentTx: z.object({
+    active: z.boolean(),
+    messages: z.array(z.string()),
+    lastMessage: NullableStringSchema,
+  }),
+});
+
+export const DeviceUiBootstrapSnapshotSchema = z.object({
+  server: z.object({
+    status: z.literal('ok'),
+    version: z.string(),
+    webPort: NullableNumberSchema,
+  }),
+  station: z.object({
+    callsign: NullableStringSchema,
+    callsigns: z.array(z.string()).default([]),
+  }),
+  operators: z.array(DeviceUiOperatorSnapshotSchema).default([]),
+  engine: z.object({
+    running: z.boolean(),
+    mode: NullableStringSchema,
+    currentMode: z.object({
+      name: z.string(),
+      slotMs: z.number().nonnegative().optional(),
+    }).nullable(),
+    state: NullableStringSchema,
+  }),
+  radio: z.object({
+    connected: z.boolean(),
+    frequency: NullableNumberSchema,
+    radioMode: NullableStringSchema,
+    ptt: z.boolean(),
+    tx: z.boolean(),
+  }),
+  ft8: z.object({
+    slot: z.object({
+      id: z.string(),
+      startMs: z.number(),
+      phaseMs: z.number(),
+      driftMs: z.number().optional(),
+      cycleNumber: z.number(),
+      utcSeconds: z.number(),
+      mode: z.string(),
+    }).nullable(),
+    utc: NullableNumberSchema,
+    cycle: NullableNumberSchema,
+    periodMs: NullableNumberSchema,
+    recentDecodeRawMessages: z.array(z.string()),
+    lastDecodeRawMessage: NullableStringSchema,
+    recentFramesSlotId: NullableStringSchema,
+    recentFramesSlotStartMs: NullableNumberSchema,
+    recentFrames: z.array(DeviceUiFrameSnapshotSchema),
+    currentTx: DeviceUiCurrentTxSnapshotSchema,
+  }),
+  voice: z.object({
+    active: z.boolean(),
+    radioMode: NullableStringSchema,
+    pttLocked: z.boolean(),
+    pttLockedByLabel: NullableStringSchema,
+    keyerActive: z.boolean(),
+    keyerMode: NullableStringSchema,
+    keyerSlotId: NullableStringSchema,
+  }),
+  cw: DeviceUiCwSnapshotSchema,
+  access: z.object({
+    localUrl: NullableStringSchema,
+    localUrls: z.array(z.string()),
+  }),
+  updatedAt: z.number().int().nonnegative(),
+});
+
+export type DeviceUiBootstrapSnapshot = z.infer<typeof DeviceUiBootstrapSnapshotSchema>;
+
+export const DeviceUiWsEventSchema = z.object({
+  type: z.literal('snapshot'),
+  payload: DeviceUiBootstrapSnapshotSchema,
+  timestamp: z.string(),
+});
+
+export type DeviceUiWsEvent = z.infer<typeof DeviceUiWsEventSchema>;

package/src/schema/mode.schema.ts

@@ -63,6 +63,14 @@ export const MODES = {
     transmitTiming: 0,
     encodeAdvance: 0,
   } as ModeDescriptor,
+  CW: {
+    name: 'CW',
+    slotMs: 0,            // CW 模式无时隙概念
+    toleranceMs: 0,
+    windowTiming: [],     // 无解码窗口
+    transmitTiming: 0,
+    encodeAdvance: 0,
+  } as ModeDescriptor,
 } as const;
 
 /**

package/src/schema/plugin.schema.ts

@@ -73,7 +73,7 @@ export type PluginPanelComponent = z.infer<typeof PluginPanelComponentSchema>;
  * These values control both validation expectations and default frontend
  * rendering in plugin settings UIs.
  */
-export const PluginSettingTypeSchema = z.enum(['boolean', 'number', 'string', 'string[]', 'object[]', 'info']);
+export const PluginSettingTypeSchema = z.enum(['boolean', 'number', 'string', 'string[]', 'object[]', 'keyedStringArrays', 'info']);
 
 /**
  * Supported generated-form field types for plugin settings.
@@ -103,6 +103,26 @@ export const PluginObjectArrayFieldSchema = z.object({
 });
 export type PluginObjectArrayField = z.infer<typeof PluginObjectArrayFieldSchema>;
 
+export const PluginKeyedStringArrayKeySchema = z.object({
+  key: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+});
+export type PluginKeyedStringArrayKey = z.infer<typeof PluginKeyedStringArrayKeySchema>;
+
+export const PluginSettingConditionSchema = z.object({
+  setting: z.string(),
+  equals: z.unknown().optional(),
+  notEquals: z.unknown().optional(),
+});
+export type PluginSettingCondition = z.infer<typeof PluginSettingConditionSchema>;
+
+export const PluginSettingConditionalDescriptionSchema = z.object({
+  when: PluginSettingConditionSchema,
+  description: z.string(),
+});
+export type PluginSettingConditionalDescription = z.infer<typeof PluginSettingConditionalDescriptionSchema>;
+
 /**
  * Persistence and UI scope for a plugin setting.
  *
@@ -134,6 +154,12 @@ export const PluginSettingDescriptorSchema = z.object({
   options: z.array(PluginSettingOptionSchema).optional(),
   /** Field schema used by generated editors for `object[]` settings. */
   itemFields: z.array(PluginObjectArrayFieldSchema).optional(),
+  /** Fixed key list used by generated editors for `keyedStringArrays` settings. */
+  keys: z.array(PluginKeyedStringArrayKeySchema).optional(),
+  /** Conditionally show the field based on another setting in the same form. */
+  visibleWhen: PluginSettingConditionSchema.optional(),
+  /** Conditionally override the field description based on another setting. */
+  descriptionWhen: z.array(PluginSettingConditionalDescriptionSchema).optional(),
   /** Internal settings are persisted/injected but hidden from generated UIs. */
   hidden: z.boolean().optional(),
   /** 设置作用域：global（所有操作员共享）或 operator（每操作员独立），默认 global */
@@ -212,7 +238,7 @@ export type PluginCapability = z.infer<typeof PluginCapabilitySchema>;
  * - `voice-left-top`: shown above the voice frequency control card.
  * - `voice-right-top`: shown in the tabbed top area of the voice right panel.
  */
-export const PluginPanelSlotSchema = z.enum(['operator', 'automation', 'main-right', 'voice-left-top', 'voice-right-top']);
+export const PluginPanelSlotSchema = z.enum(['operator', 'automation', 'main-right', 'voice-left-top', 'voice-right-top', 'cw-right-top']);
 
 /**
  * Rendering slot that determines where a panel appears in the UI.

package/src/schema/process-monitor.schema.ts

@@ -74,6 +74,19 @@ export const DecodeWorkerTelemetrySnapshotSchema = z.object({
   workers: z.array(DecodeWorkerTelemetryWorkerSchema),
 });
 
+export const WorkerPoolTelemetryWorkerSchema = DecodeWorkerTelemetryWorkerSchema;
+export const WorkerPoolTelemetrySummarySchema = DecodeWorkerTelemetrySummarySchema;
+
+export const WorkerPoolTelemetrySnapshotSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  kind: z.string().min(1),
+  summary: WorkerPoolTelemetrySummarySchema,
+  workers: z.array(WorkerPoolTelemetryWorkerSchema),
+});
+
+export const WorkerPoolTelemetryListSchema = z.array(WorkerPoolTelemetrySnapshotSchema);
+
 export const ProcessSnapshotSchema = z.object({
   timestamp: z.number(),
   uptimeSeconds: z.number(),
@@ -82,6 +95,7 @@ export const ProcessSnapshotSchema = z.object({
   hostCpu: HostCpuSchema.optional(),
   eventLoop: EventLoopDelaySchema,
   decodeWorkers: DecodeWorkerTelemetrySnapshotSchema.optional(),
+  workerPools: WorkerPoolTelemetryListSchema.optional(),
 });
 
 export const ProcessSnapshotHistorySchema = z.object({
@@ -98,5 +112,9 @@ export type DecodeWorkerCurrentJob = z.infer<typeof DecodeWorkerCurrentJobSchema
 export type DecodeWorkerTelemetryWorker = z.infer<typeof DecodeWorkerTelemetryWorkerSchema>;
 export type DecodeWorkerTelemetrySummary = z.infer<typeof DecodeWorkerTelemetrySummarySchema>;
 export type DecodeWorkerTelemetrySnapshot = z.infer<typeof DecodeWorkerTelemetrySnapshotSchema>;
+export type WorkerPoolTelemetryWorker = z.infer<typeof WorkerPoolTelemetryWorkerSchema>;
+export type WorkerPoolTelemetrySummary = z.infer<typeof WorkerPoolTelemetrySummarySchema>;
+export type WorkerPoolTelemetrySnapshot = z.infer<typeof WorkerPoolTelemetrySnapshotSchema>;
+export type WorkerPoolTelemetryList = z.infer<typeof WorkerPoolTelemetryListSchema>;
 export type ProcessSnapshot = z.infer<typeof ProcessSnapshotSchema>;
 export type ProcessSnapshotHistory = z.infer<typeof ProcessSnapshotHistorySchema>;

package/src/schema/radio-capability.schema.ts

@@ -247,21 +247,62 @@ export const CAPABILITY_IDS = [
   'compressor',
   'compressor_level',
   'monitor_gain',
+  'monitor_enabled',
+  'apf_enabled',
+  'apf_level',
   'nb',
+  'nb_level',
   'nr',
+  'nr_level',
+  'rf_gain',
+  'if_shift',
+  'pbt_in',
+  'pbt_out',
+  'cw_pitch',
+  'key_speed',
+  'notch_raw',
+  'agc_time',
+  'balance',
+  'drive_gain',
+  'digi_sel_enabled',
+  'digi_sel_level',
   'lock_mode',
   'mute',
   'vox',
+  'vox_gain',
+  'anti_vox',
+  'vox_delay',
+  'break_in_delay',
+  'auto_notch',
+  'manual_notch',
+  'rit_enabled',
+  'xit_enabled',
+  'tone_enabled',
+  'tone_squelch_enabled',
+  'beep_enabled',
+  'break_in_mode',
   'agc_mode',
   'preamp',
   'attenuator',
   'mode_bandwidth',
+  'split_enabled',
+  'vfo_select',
+  'audio_if_mode',
   'rit_offset',
   'xit_offset',
   'tuning_step',
   'repeater_shift',
   'repeater_offset',
   'ctcss_tone',
+  'spectrum_data_output',
+  'spectrum_hold',
+  'spectrum_speed',
+  'spectrum_ref',
+  'spectrum_average',
+  'spectrum_vbw',
+  'spectrum_rbw',
+  'spectrum_during_tx',
+  'spectrum_center_type',
   'dcs_code',
 ] as const;
 

package/src/schema/radio.schema.ts

@@ -1,5 +1,15 @@
 import { z } from 'zod';
 
+/**
+ * 中继差频方向
+ */
+export const RepeaterShiftSchema = z.enum(['none', 'minus', 'plus']);
+
+/**
+ * 哑音类型
+ */
+export const ToneSquelchModeSchema = z.enum(['none', 'ctcss', 'dcs']);
+
 /**
  * 预设频率Schema
  */
@@ -9,6 +19,85 @@ export const PresetFrequencySchema = z.object({
   radioMode: z.string().optional(), // 电台调制模式，如 USB, LSB, AM, FM
   frequency: z.number(),
   description: z.string().optional(),
+  repeaterShift: RepeaterShiftSchema.optional(), // 中继差频方向，默认 none
+  repeaterOffsetHz: z.number().int().positive().optional(), // 中继偏移，单位 Hz
+  toneMode: ToneSquelchModeSchema.optional(), // 哑音类型，默认 none
+  ctcssToneTenthsHz: z.number().int().positive().optional(), // CTCSS，单位 0.1Hz
+  dcsCode: z.number().int().positive().optional(), // DCS 码
+}).superRefine((preset, ctx) => {
+  const isVoiceFmPreset = preset.mode === 'VOICE' && preset.radioMode?.toUpperCase() === 'FM';
+  const hasRepeaterDuplex = preset.repeaterShift === 'minus' || preset.repeaterShift === 'plus';
+
+  if (hasRepeaterDuplex && !isVoiceFmPreset) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['repeaterShift'],
+      message: 'repeater duplex is only supported for VOICE FM presets',
+    });
+  }
+
+  if (
+    hasRepeaterDuplex
+    && preset.repeaterOffsetHz === undefined
+  ) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['repeaterOffsetHz'],
+      message: 'repeaterOffsetHz is required when repeaterShift is plus or minus',
+    });
+  }
+
+  if (!isVoiceFmPreset && preset.toneMode && preset.toneMode !== 'none') {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['toneMode'],
+      message: 'tone squelch is only supported for VOICE FM presets',
+    });
+  }
+
+  if (preset.toneMode === 'ctcss') {
+    if (preset.ctcssToneTenthsHz === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['ctcssToneTenthsHz'],
+        message: 'ctcssToneTenthsHz is required when toneMode is ctcss',
+      });
+    }
+    if (preset.dcsCode !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['dcsCode'],
+        message: 'dcsCode cannot be set when toneMode is ctcss',
+      });
+    }
+  }
+
+  if (preset.toneMode === 'dcs') {
+    if (preset.dcsCode === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['dcsCode'],
+        message: 'dcsCode is required when toneMode is dcs',
+      });
+    }
+    if (preset.ctcssToneTenthsHz !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['ctcssToneTenthsHz'],
+        message: 'ctcssToneTenthsHz cannot be set when toneMode is dcs',
+      });
+    }
+  }
+
+  if ((preset.toneMode === undefined || preset.toneMode === 'none')
+    && (preset.ctcssToneTenthsHz !== undefined || preset.dcsCode !== undefined)
+  ) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['toneMode'],
+      message: 'toneMode must be ctcss or dcs when tone values are set',
+    });
+  }
 });
 
 /**
@@ -163,6 +252,12 @@ export const HamlibConfigSchema = z.object({
   // PTT 独立串口路径（仅当 pttMethod 为 dtr/rts 时有效）
   // 留空则复用 CAT 同一串口
   pttPort: z.string().optional(),
+
+  // CW 键控串口路径（用于 DTR/RTS 引脚驱动电台 CW KEY 输入）
+  cwKeyPort: z.string().optional(),
+
+  // CW 键控引脚类型（dtr 或 rts）
+  cwKeyMethod: z.enum(['dtr', 'rts']).optional(),
 });
 
 /**
@@ -357,6 +452,8 @@ export const CustomFrequencyPresetsSchema = z.object({
 // 导出类型
 export type CustomFrequencyPresets = z.infer<typeof CustomFrequencyPresetsSchema>;
 export type PresetFrequency = z.infer<typeof PresetFrequencySchema>;
+export type RepeaterShift = z.infer<typeof RepeaterShiftSchema>;
+export type ToneSquelchMode = z.infer<typeof ToneSquelchModeSchema>;
 export type FrequencyListResponse = z.infer<typeof FrequencyListResponseSchema>;
 export type SerialConfig = z.infer<typeof SerialConfigSchema>;
 export type HamlibBackendConfig = z.infer<typeof HamlibBackendConfigSchema>;

package/src/schema/voice.schema.ts

@@ -24,5 +24,5 @@ export type VoicePTTLock = z.infer<typeof VoicePTTLockSchema>;
  * digital: FT8/FT4 等数字模式
  * voice: 语音通联模式（SSB/FM/AM）
  */
-export const EngineModeSchema = z.enum(['digital', 'voice']);
+export const EngineModeSchema = z.enum(['digital', 'voice', 'cw']);
 export type EngineMode = z.infer<typeof EngineModeSchema>;