@tx5dr/contracts 1.7.2 → 1.7.4

package/src/schema/__tests__/operator.schema.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import {
+  CreateRadioOperatorRequestSchema,
+  UpdateRadioOperatorRequestSchema,
+  sanitizeCallsignInput
+} from '../../index.js';
+import { MODES } from '../mode.schema.js';
+
+describe('operator callsign normalization', () => {
+  it('uppercases callsigns while preserving portable separators', () => {
+    expect(sanitizeCallsignInput(' bg5abc/p ')).toBe('BG5ABC/P');
+  });
+
+  it('normalizes callsigns in create and update payloads', () => {
+    const createPayload = CreateRadioOperatorRequestSchema.parse({
+      myCallsign: 'bg5abc/p',
+      myGrid: 'OL63',
+      frequency: 1000,
+      transmitCycles: [0],
+      mode: MODES.FT8,
+    });
+    const updatePayload = UpdateRadioOperatorRequestSchema.parse({
+      myCallsign: 'vk9/bg3yza',
+    });
+
+    expect(createPayload.myCallsign).toBe('BG5ABC/P');
+    expect(updatePayload.myCallsign).toBe('VK9/BG3YZA');
+  });
+});

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

@@ -0,0 +1,245 @@
+import { describe, expect, it } from 'vitest';
+import { ProcessSnapshotSchema } from '../process-monitor.schema.js';
+
+function createBaseSnapshot() {
+  return {
+    timestamp: 1,
+    uptimeSeconds: 10,
+    memory: {
+      heapUsed: 100,
+      heapTotal: 200,
+      rss: 300,
+      external: 20,
+      arrayBuffers: 10,
+    },
+    cpu: {
+      user: 10,
+      system: 5,
+      total: 15,
+      capacity: 800,
+      normalizedTotal: 1.875,
+    },
+    eventLoop: {
+      mean: 1,
+      p50: 1,
+      p99: 2,
+    },
+  };
+}
+
+describe('ProcessSnapshotSchema', () => {
+  it('accepts legacy snapshots without decode worker telemetry', () => {
+    expect(ProcessSnapshotSchema.parse(createBaseSnapshot()).decodeWorkers).toBeUndefined();
+  });
+
+  it('accepts decode worker telemetry snapshots', () => {
+    const parsed = ProcessSnapshotSchema.parse({
+      ...createBaseSnapshot(),
+      decodeWorkers: {
+        summary: {
+          status: 'ready',
+          workerCount: 2,
+          desiredWorkers: 2,
+          readyCount: 2,
+          busyCount: 1,
+          totalRss: 512,
+          totalCpu: 340,
+          nativeThreadsPerWorker: 4,
+          pendingJobs: 1,
+          activeJobs: 1,
+          restartAttempts: 0,
+          workerEntry: '/app/packages/server/dist/decode/decode-worker-entry.js',
+          workerMode: 'production',
+        },
+        workers: [
+          {
+            workerId: 1,
+            pid: 1234,
+            ready: true,
+            busy: true,
+            nativeThreads: 4,
+            uptimeSeconds: 30,
+            memory: {
+              heapUsed: 100,
+              heapTotal: 200,
+              rss: 256,
+              external: 20,
+              arrayBuffers: 10,
+            },
+            cpu: {
+              user: 300,
+              system: 40,
+              total: 340,
+            },
+            currentJob: {
+              jobId: 7,
+              slotId: 'FT8-1-0',
+              windowIdx: 0,
+              mode: 'FT8',
+              startedAt: 1,
+              elapsedMs: 1200,
+              requestAudioDurationMs: 11500,
+            },
+            lastSeenAt: 2,
+          },
+        ],
+      },
+    });
+
+    expect(parsed.decodeWorkers?.summary.workerCount).toBe(2);
+    expect(parsed.decodeWorkers?.workers[0].currentJob?.mode).toBe('FT8');
+  });
+
+  it('accepts decode worker unavailable snapshots without per-worker telemetry', () => {
+    const parsed = ProcessSnapshotSchema.parse({
+      ...createBaseSnapshot(),
+      decodeWorkers: {
+        summary: {
+          status: 'unavailable',
+          workerCount: 0,
+          desiredWorkers: 1,
+          readyCount: 0,
+          busyCount: 0,
+          totalRss: 0,
+          totalCpu: 0,
+          nativeThreadsPerWorker: 1,
+          pendingJobs: 2,
+          activeJobs: 0,
+          lastError: 'decode worker startup timed out',
+          lastFailureAt: 2,
+          restartAttempts: 3,
+          workerEntry: '/app/packages/server/dist/decode/decode-worker-entry.js',
+          workerMode: 'production',
+        },
+        workers: [],
+      },
+    });
+
+    expect(parsed.decodeWorkers?.summary.status).toBe('unavailable');
+    expect(parsed.decodeWorkers?.summary.lastError).toContain('startup');
+  });
+
+  it('accepts stopped decode worker snapshots without treating them as failures', () => {
+    const parsed = ProcessSnapshotSchema.parse({
+      ...createBaseSnapshot(),
+      decodeWorkers: {
+        summary: {
+          status: 'stopped',
+          workerCount: 0,
+          desiredWorkers: 0,
+          readyCount: 0,
+          busyCount: 0,
+          totalRss: 0,
+          totalCpu: 0,
+          nativeThreadsPerWorker: 1,
+          pendingJobs: 0,
+          activeJobs: 0,
+          restartAttempts: 0,
+        },
+        workers: [],
+      },
+    });
+
+    expect(parsed.decodeWorkers?.summary.status).toBe('stopped');
+    expect(parsed.decodeWorkers?.summary.lastError).toBeUndefined();
+  });
+
+  it('accepts generic worker pool telemetry while preserving decodeWorkers compatibility', () => {
+    const decodeWorkerTelemetry = {
+      summary: {
+        status: 'ready' as const,
+        workerCount: 1,
+        desiredWorkers: 1,
+        readyCount: 1,
+        busyCount: 0,
+        totalRss: 256,
+        totalCpu: 12,
+        nativeThreadsPerWorker: 2,
+        pendingJobs: 0,
+        activeJobs: 0,
+      },
+      workers: [
+        {
+          workerId: 1,
+          pid: 1234,
+          ready: true,
+          busy: false,
+          nativeThreads: 2,
+          uptimeSeconds: 30,
+          memory: {
+            heapUsed: 100,
+            heapTotal: 200,
+            rss: 256,
+            external: 20,
+            arrayBuffers: 10,
+          },
+          cpu: {
+            user: 10,
+            system: 2,
+            total: 12,
+          },
+          lastSeenAt: 2,
+        },
+      ],
+    };
+
+    const parsed = ProcessSnapshotSchema.parse({
+      ...createBaseSnapshot(),
+      decodeWorkers: decodeWorkerTelemetry,
+      workerPools: [
+        {
+          id: 'ft8-decode',
+          name: 'FT8 Decode Workers',
+          kind: 'decode',
+          ...decodeWorkerTelemetry,
+        },
+        {
+          id: 'cw-decoder',
+          name: 'CW Decoder Workers',
+          kind: 'cw-decoder',
+          summary: {
+            status: 'ready',
+            workerCount: 1,
+            desiredWorkers: 1,
+            readyCount: 1,
+            busyCount: 0,
+            totalRss: 512,
+            totalCpu: 4,
+            nativeThreadsPerWorker: 1,
+            pendingJobs: 0,
+            activeJobs: 0,
+          },
+          workers: [
+            {
+              workerId: 1,
+              pid: 5678,
+              ready: true,
+              busy: false,
+              nativeThreads: 1,
+              uptimeSeconds: 8,
+              memory: {
+                heapUsed: 120,
+                heapTotal: 220,
+                rss: 512,
+                external: 30,
+                arrayBuffers: 15,
+              },
+              cpu: {
+                user: 3,
+                system: 1,
+                total: 4,
+              },
+              lastSeenAt: 3,
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(parsed.decodeWorkers?.summary.workerCount).toBe(1);
+    expect(parsed.workerPools?.map((pool) => pool.id)).toEqual(['ft8-decode', 'cw-decoder']);
+    expect(parsed.workerPools?.[0].workers[0].workerId).toBe(1);
+    expect(parsed.workerPools?.[1].summary.totalRss).toBe(512);
+    expect(parsed.workerPools?.[1].workers[0].pid).toBe(5678);
+  });
+});

package/src/schema/__tests__/radio.schema.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from 'vitest';
+import { PresetFrequencySchema } from '../radio.schema.js';
+
+describe('PresetFrequencySchema repeater DUP fields', () => {
+  it('accepts existing presets without repeater DUP fields', () => {
+    const parsed = PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      description: '145.000 MHz 2m FM',
+    });
+
+    expect(parsed.repeaterShift).toBeUndefined();
+    expect(parsed.repeaterOffsetHz).toBeUndefined();
+  });
+
+  it('accepts plus or minus DUP presets with positive Hz offsets', () => {
+    const parsed = PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      repeaterShift: 'plus',
+      repeaterOffsetHz: 600000,
+    });
+
+    expect(parsed.repeaterShift).toBe('plus');
+    expect(parsed.repeaterOffsetHz).toBe(600000);
+  });
+
+  it('rejects DUP direction without a positive offset', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      repeaterShift: 'minus',
+    })).toThrow();
+
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      repeaterShift: 'minus',
+      repeaterOffsetHz: 0,
+    })).toThrow();
+  });
+
+  it('rejects invalid DUP directions', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      repeaterShift: 'up',
+      repeaterOffsetHz: 600000,
+    })).toThrow();
+  });
+
+  it('rejects DUP presets outside VOICE FM', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '20m',
+      mode: 'VOICE',
+      radioMode: 'USB',
+      frequency: 14270000,
+      repeaterShift: 'plus',
+      repeaterOffsetHz: 600000,
+    })).toThrow();
+  });
+});
+
+describe('PresetFrequencySchema tone squelch fields', () => {
+  it('accepts CTCSS tone presets with positive 0.1 Hz values', () => {
+    const parsed = PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'ctcss',
+      ctcssToneTenthsHz: 885,
+    });
+
+    expect(parsed.toneMode).toBe('ctcss');
+    expect(parsed.ctcssToneTenthsHz).toBe(885);
+  });
+
+  it('accepts DCS presets with positive codes', () => {
+    const parsed = PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'dcs',
+      dcsCode: 23,
+    });
+
+    expect(parsed.toneMode).toBe('dcs');
+    expect(parsed.dcsCode).toBe(23);
+  });
+
+  it('rejects tone squelch modes without required values', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'ctcss',
+    })).toThrow();
+
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'dcs',
+    })).toThrow();
+  });
+
+  it('rejects invalid tone squelch values and modes', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'ctcss',
+      ctcssToneTenthsHz: 0,
+    })).toThrow();
+
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'dcs',
+      dcsCode: -1,
+    })).toThrow();
+
+    expect(() => PresetFrequencySchema.parse({
+      band: '2m',
+      mode: 'VOICE',
+      radioMode: 'FM',
+      frequency: 145000000,
+      toneMode: 'tone',
+      ctcssToneTenthsHz: 885,
+    })).toThrow();
+  });
+
+  it('rejects tone squelch presets outside VOICE FM', () => {
+    expect(() => PresetFrequencySchema.parse({
+      band: '20m',
+      mode: 'VOICE',
+      radioMode: 'USB',
+      frequency: 14270000,
+      toneMode: 'ctcss',
+      ctcssToneTenthsHz: 885,
+    })).toThrow();
+  });
+});

package/src/schema/ability.ts

@@ -34,6 +34,8 @@ export type CapabilitySubject =
   | 'RigctldBridge'
   | 'Engine'
   | 'ModeSwitch'
+  | 'CWDecoder'
+  | 'CWDecoderConfig'
   | 'SettingsDecodeWindows'
   | 'SettingsFrequencyPresets'
   | 'StationInfo';
@@ -59,6 +61,8 @@ export enum Permission {
   RIGCTLD_BRIDGE = 'rigctld:bridge',
   ENGINE_START_STOP = 'engine:start_stop',
   MODE_SWITCH = 'mode:switch',
+  CW_DECODER_CONTROL = 'cw:decoder_control',
+  CW_DECODER_CONFIG = 'cw:decoder_config',
   SETTINGS_DECODE_WINDOWS = 'settings:decode_windows',
   SETTINGS_FREQUENCY_PRESETS = 'settings:frequency_presets',
   STATION_UPDATE = 'station:update',
@@ -79,6 +83,8 @@ export const PERMISSION_RULE_MAP: Record<Permission, { action: AppAction; subjec
   [Permission.RIGCTLD_BRIDGE]: { action: 'execute', subject: 'RigctldBridge' },
   [Permission.ENGINE_START_STOP]: { action: 'execute', subject: 'Engine' },
   [Permission.MODE_SWITCH]: { action: 'execute', subject: 'ModeSwitch' },
+  [Permission.CW_DECODER_CONTROL]: { action: 'execute', subject: 'CWDecoder' },
+  [Permission.CW_DECODER_CONFIG]: { action: 'update', subject: 'CWDecoderConfig' },
   [Permission.SETTINGS_DECODE_WINDOWS]: { action: 'update', subject: 'SettingsDecodeWindows' },
   [Permission.SETTINGS_FREQUENCY_PRESETS]: { action: 'update', subject: 'SettingsFrequencyPresets' },
   [Permission.STATION_UPDATE]: { action: 'update', subject: 'StationInfo' },
@@ -181,6 +187,13 @@ export const PERMISSION_GROUPS: PermissionGroupDef[] = [
   },
   { key: 'engine', permissions: [Permission.ENGINE_START_STOP] },
   { key: 'mode', permissions: [Permission.MODE_SWITCH] },
+  {
+    key: 'cw',
+    permissions: [
+      Permission.CW_DECODER_CONTROL,
+      Permission.CW_DECODER_CONFIG,
+    ],
+  },
   {
     key: 'settings',
     permissions: [

package/src/schema/api-response.schema.ts

@@ -115,6 +115,23 @@ export const DisconnectRadioResponseSchema = z.object({
 export const LastFrequencyResponseSchema = z.object({
   success: z.boolean(),
   lastFrequency: PresetFrequencySchema.nullable(),
+  lastVoiceFrequency: z.object({
+    frequency: z.number(),
+    radioMode: z.string().optional(),
+    band: z.string(),
+    description: z.string().optional(),
+    repeaterShift: z.enum(['none', 'minus', 'plus']).optional(),
+    repeaterOffsetHz: z.number().optional(),
+    toneMode: z.enum(['none', 'ctcss', 'dcs']).optional(),
+    ctcssToneTenthsHz: z.number().optional(),
+    dcsCode: z.number().optional(),
+  }).nullable().optional(),
+  lastCWFrequency: z.object({
+    frequency: z.number(),
+    radioMode: z.string().optional(),
+    band: z.string(),
+    description: z.string().optional(),
+  }).nullable().optional(),
 });
 
 /**
@@ -127,6 +144,11 @@ export const SetFrequencyResponseSchema = z.object({
   mode: z.string().optional(),
   band: z.string().optional(),
   radioMode: z.string().optional(),
+  repeaterShift: z.enum(['none', 'minus', 'plus']).optional(),
+  repeaterOffsetHz: z.number().optional(),
+  toneMode: z.enum(['none', 'ctcss', 'dcs']).optional(),
+  ctcssToneTenthsHz: z.number().optional(),
+  dcsCode: z.number().optional(),
   radioConnected: z.boolean().optional(),
 });
 

package/src/schema/audio.schema.ts

@@ -9,6 +9,9 @@ export const AudioDeviceSchema = z.object({
   sampleRate: z.number(),
   sampleRates: z.array(z.number().int().positive()).optional(),
   type: z.enum(['input', 'output']),
+  availability: z.enum(['available', 'cached', 'active']).optional(),
+  isActiveByTx5dr: z.boolean().optional(),
+  lastSeenAt: z.number().int().positive().optional(),
 });
 
 export const AudioDeviceResolutionStatusSchema = z.enum([