@ceralive/modem-control 1.1.0 → 1.2.0

package/dist/usb-mode/runtime-capability.js

@@ -0,0 +1,157 @@
+export const RUNTIME_COMPOSITION_VENDORS = ['fibocom', 'quectel', 'simcom', 'sierra'];
+/** Commands only: selecting a port, sending, deadlines, and retries belong to the provider. */
+export const RUNTIME_COMPOSITION_QUERY_REGISTRY = Object.freeze({
+    fibocom: Object.freeze({ current: 'AT+GTUSBMODE?', enumerate: 'AT+GTUSBMODE=?' }),
+    quectel: Object.freeze({ current: 'AT+QCFG="usbnet"', enumerate: 'AT+QCFG=?' }),
+    simcom: Object.freeze({ current: 'AT+CUSBPIDSWITCH?', enumerate: 'AT+CUSBPIDSWITCH=?' }),
+    sierra: Object.freeze({ current: 'AT!USBCOMP?', enumerate: 'AT!USBCOMP=?' }),
+});
+function decimalSetCommand(prefix) {
+    return (target) => typeof target === 'number' && Number.isSafeInteger(target) && target >= 0
+        ? `${prefix}${target}`
+        : undefined;
+}
+/** Exact reviewed SET forms. Callers still allowlist only the one enumerated target selected. */
+export const RUNTIME_COMPOSITION_SET_REGISTRY = Object.freeze({
+    fibocom: decimalSetCommand('AT+GTUSBMODE='),
+    quectel: decimalSetCommand('AT+QCFG="usbnet",'),
+    simcom: (target) => typeof target === 'string' && /^[0-9A-Fa-f]{4}$/.test(target)
+        ? `AT+CUSBPIDSWITCH=${target.toUpperCase()},1,1`
+        : undefined,
+    sierra: decimalSetCommand('AT!USBCOMP='),
+});
+const UNKNOWN_VENDOR = Object.freeze({
+    status: 'unknown',
+    current: null,
+    enumerated: [],
+    returnPathProven: false,
+    offerable: [],
+    reason: 'vendor-unsupported',
+});
+const MALFORMED_RESPONSE = Object.freeze({
+    status: 'unknown',
+    current: null,
+    enumerated: [],
+    returnPathProven: false,
+    offerable: [],
+    reason: 'malformed-response',
+});
+function parseDecimalDomain(domain) {
+    const values = [];
+    for (const member of domain.split(',')) {
+        const token = member.trim();
+        const range = /^(\d+)-(\d+)$/.exec(token);
+        if (range !== null) {
+            const start = Number(range[1]);
+            const end = Number(range[2]);
+            if (!Number.isSafeInteger(start) ||
+                !Number.isSafeInteger(end) ||
+                start > end ||
+                end - start > 255)
+                return undefined;
+            for (let value = start; value <= end; value += 1)
+                values.push(value);
+            continue;
+        }
+        if (!/^\d+$/.test(token))
+            return undefined;
+        const value = Number(token);
+        if (!Number.isSafeInteger(value))
+            return undefined;
+        values.push(value);
+    }
+    return values.length > 0 && new Set(values).size === values.length ? values : undefined;
+}
+function parseFibocom(input) {
+    const current = /^\s*\+GTUSBMODE:\s*(\d+)\s*$/m.exec(input.currentResponse);
+    const enumeration = /^\s*\+GTUSBMODE:\s*\(([^)]+)\)\s*$/m.exec(input.enumerationResponse);
+    if (current === null || enumeration === null)
+        return undefined;
+    const enumerated = parseDecimalDomain(enumeration[1] ?? '');
+    return enumerated === undefined ? undefined : { current: Number(current[1]), enumerated };
+}
+function parseQuectel(input) {
+    const current = /^\s*\+QCFG:\s*"usbnet"\s*,\s*(\d+)\s*$/m.exec(input.currentResponse);
+    const enumeration = /^\s*\+QCFG:\s*"usbnet"\s*,\s*\(([^)]+)\)\s*$/m.exec(input.enumerationResponse);
+    if (current === null || enumeration === null)
+        return undefined;
+    const enumerated = parseDecimalDomain(enumeration[1] ?? '');
+    return enumerated === undefined ? undefined : { current: Number(current[1]), enumerated };
+}
+function parseSimcom(input) {
+    const current = /^\s*\+CUSBPIDSWITCH:\s*([0-9A-Fa-f]{4})\s*$/m.exec(input.currentResponse);
+    const enumeration = /\+CUSBPIDSWITCH:\s*\(([^)]+)\)\s*,\s*\(0-1\)\s*,\s*\(0-1\)/m.exec(input.enumerationResponse);
+    if (current === null || enumeration === null)
+        return undefined;
+    const tokens = (enumeration[1] ?? '').split(',').map((token) => token.trim().toUpperCase());
+    if (tokens.length === 0 || tokens.some((token) => !/^[0-9A-F]{4}$/.test(token)))
+        return undefined;
+    if (new Set(tokens).size !== tokens.length)
+        return undefined;
+    return { current: (current[1] ?? '').toUpperCase(), enumerated: tokens };
+}
+function parseSierra(input) {
+    const current = /^\s*!USBCOMP:\s*(\d+)(?:\s*,.*)?$/m.exec(input.currentResponse);
+    if (current === null)
+        return undefined;
+    const enumerated = Array.from(input.enumerationResponse.matchAll(/^\s*(\d+)\s*:\s*.+$/gm), (match) => Number(match[1]));
+    if (enumerated.length === 0 || new Set(enumerated).size !== enumerated.length)
+        return undefined;
+    return { current: Number(current[1]), enumerated };
+}
+const PARSERS = {
+    fibocom: parseFibocom,
+    quectel: parseQuectel,
+    simcom: parseSimcom,
+    sierra: parseSierra,
+};
+export function isRuntimeCompositionVendor(vendor) {
+    return Object.hasOwn(RUNTIME_COMPOSITION_QUERY_REGISTRY, vendor);
+}
+export function buildRuntimeCompositionSetCommand(vendor, target) {
+    const normalized = vendor.trim().toLowerCase();
+    return isRuntimeCompositionVendor(normalized)
+        ? RUNTIME_COMPOSITION_SET_REGISTRY[normalized](target)
+        : undefined;
+}
+/** Parse only the vendor READ response used by the weaker post-switch proof tier. */
+export function readRuntimeCompositionCurrent(vendor, response) {
+    const normalized = vendor.trim().toLowerCase();
+    if (!isRuntimeCompositionVendor(normalized))
+        return undefined;
+    switch (normalized) {
+        case 'fibocom': {
+            const match = /^\s*\+GTUSBMODE:\s*(\d+)\s*$/m.exec(response);
+            return match === null ? undefined : Number(match[1]);
+        }
+        case 'quectel': {
+            const match = /^\s*\+QCFG:\s*"usbnet"\s*,\s*(\d+)\s*$/m.exec(response);
+            return match === null ? undefined : Number(match[1]);
+        }
+        case 'simcom': {
+            const match = /^\s*\+CUSBPIDSWITCH:\s*([0-9A-Fa-f]{4})\s*$/m.exec(response);
+            return match === null ? undefined : (match[1] ?? '').toUpperCase();
+        }
+        case 'sierra': {
+            const match = /^\s*!USBCOMP:\s*(\d+)(?:\s*,.*)?$/m.exec(response);
+            return match === null ? undefined : Number(match[1]);
+        }
+    }
+}
+/** Derive controls exclusively from the device's current and enumerated response text. */
+export function resolveRuntimeCompositionCapability(input) {
+    const vendor = input.vendor.trim().toLowerCase();
+    if (!isRuntimeCompositionVendor(vendor))
+        return UNKNOWN_VENDOR;
+    const parsed = PARSERS[vendor](input);
+    if (parsed === undefined)
+        return MALFORMED_RESPONSE;
+    const returnPathProven = parsed.enumerated.includes(parsed.current);
+    return {
+        status: 'available',
+        current: parsed.current,
+        enumerated: parsed.enumerated,
+        returnPathProven,
+        offerable: returnPathProven ? parsed.enumerated : [],
+    };
+}

package/dist/ussd/refusal.d.ts

@@ -12,7 +12,7 @@
  *   timeout              — the bounded wait elapsed with no answer.
  *   transport-failed     — the bus call itself failed; the modem never answered.
  */
-export declare const USSD_REFUSAL_REASONS: readonly ["unsupported", "lte-only-unsupported", "carrier-rejected", "not-registered", "session-busy", "no-session", "invalid-state", "timeout", "transport-failed"];
+export declare const USSD_REFUSAL_REASONS: readonly ['unsupported', 'lte-only-unsupported', 'carrier-rejected', 'not-registered', 'session-busy', 'no-session', 'invalid-state', 'timeout', 'transport-failed'];
 export type UssdRefusalReason = (typeof USSD_REFUSAL_REASONS)[number];
 /**
  * What the modem is registered on, as far as anyone has looked.

package/dist/ussd/session.d.ts

@@ -8,10 +8,32 @@ import type { UssdRefusalReason } from './refusal.js';
  * them a second `initiate` racing the first would be judged against `idle` and
  * allowed through, which is exactly the double-open the network answers busy.
  */
-export declare const USSD_SESSION_STATES: readonly ["idle", "initiating", "active", "awaiting-reply", "responding", "cancelling", "closed"];
+export declare const USSD_SESSION_STATES: readonly [
+/** No session. MM `IDLE`. */
+'idle', 
+/** `Initiate` dispatched, reply outstanding. Local. */
+'initiating', 
+/** Network answered and the session is open with nothing pending. MM `ACTIVE`. */
+'active', 
+/** Network asked a question; a `Respond` is required. MM `USER_RESPONSE`. */
+'awaiting-reply', 
+/** `Respond` dispatched, reply outstanding. Local. */
+'responding', 
+/** `Cancel` dispatched, confirmation outstanding. Local. */
+'cancelling', 
+/** Terminal for this session object. A new session starts from a new machine. */
+'closed'];
 export type UssdSessionState = (typeof USSD_SESSION_STATES)[number];
 /** How a session that reached `closed` got there. */
-export declare const USSD_SESSION_OUTCOMES: readonly ["completed", "cancelled", "timed-out", "failed"];
+export declare const USSD_SESSION_OUTCOMES: readonly [
+/** The network completed the dialogue and released the session. */
+'completed', 
+/** The operator cancelled it. */
+'cancelled', 
+/** No answer within the bound; the machine closed it locally. */
+'timed-out', 
+/** The network or the modem refused. `refusal` names which. */
+'failed'];
 export type UssdSessionOutcome = (typeof USSD_SESSION_OUTCOMES)[number];
 /** MM's post-call session state, decoded. */
 export type UssdRepliedState = 'awaiting-reply' | 'active' | 'released';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ceralive/modem-control",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"type": "module",
 	"description": "Cellular modem control for CeraLive — ModemManager D-Bus backend, NetworkManager adapter, desired-state reconciler, USB composition-mode model, data-usage sampler.",
 	"license": "AGPL-3.0",