@mentra/bluetooth-sdk 0.1.21-beta.3 → 3.1.0-beta.100

package/plugin/build/withIos.d.ts

@@ -1,3 +1,5 @@
-import { type ConfigPlugin } from "expo/config-plugins";
+import { IOSConfig, type ConfigPlugin } from "expo/config-plugins";
 import { type BluetoothSdkPluginProps } from "./index";
+export declare const INFO_SDK_VERSION = "MentraBluetoothSdkVersion";
+export declare function applyBluetoothSdkInfoPlist(infoPlist: IOSConfig.InfoPlist, props: BluetoothSdkPluginProps | undefined): IOSConfig.InfoPlist;
 export declare const withIosConfiguration: ConfigPlugin<BluetoothSdkPluginProps>;

package/plugin/build/withIos.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withIosConfiguration = void 0;
+exports.withIosConfiguration = exports.INFO_SDK_VERSION = void 0;
+exports.applyBluetoothSdkInfoPlist = applyBluetoothSdkInfoPlist;
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -11,6 +12,7 @@ const config_plugins_1 = require("expo/config-plugins");
 const BLUETOOTH_SDK_EXPO_ADAPTER_ENV = "MENTRA_BLUETOOTH_SDK_INCLUDE_EXPO_ADAPTER";
 const BLUETOOTH_SDK_EXPO_ADAPTER_LINE = `ENV['${BLUETOOTH_SDK_EXPO_ADAPTER_ENV}'] ||= '1'`;
 const INFO_ANALYTICS_DISABLED = "MentraBluetoothSdkAnalyticsDisabled";
+exports.INFO_SDK_VERSION = "MentraBluetoothSdkVersion";
 const STALE_INFO_POSTHOG_API_KEY = "MentraBluetoothSdkPostHogApiKey";
 const STALE_INFO_POSTHOG_HOST = "MentraBluetoothSdkPostHogHost";
 const ensureBluetoothSdkExpoAdapterPodEnv = (podfile) => {
@@ -70,15 +72,25 @@ function resolveAnalyticsProps(props) {
         disabled,
     };
 }
-function withAnalyticsInfoPlist(config, props) {
+function applyBluetoothSdkInfoPlist(infoPlist, props) {
+    const packageJson = require("../../package.json");
+    const sdkVersion = typeof packageJson.version === "string" ? packageJson.version.trim() : "";
+    if (!sdkVersion) {
+        throw new Error("@mentra/bluetooth-sdk package.json is missing a version");
+    }
+    const analytics = resolveAnalyticsProps(props);
+    delete infoPlist[INFO_ANALYTICS_DISABLED];
+    delete infoPlist[STALE_INFO_POSTHOG_API_KEY];
+    delete infoPlist[STALE_INFO_POSTHOG_HOST];
+    infoPlist[exports.INFO_SDK_VERSION] = sdkVersion;
+    if (analytics.disabled !== undefined) {
+        infoPlist[INFO_ANALYTICS_DISABLED] = analytics.disabled;
+    }
+    return infoPlist;
+}
+function withBluetoothSdkInfoPlist(config, props) {
     return (0, config_plugins_1.withInfoPlist)(config, (config) => {
-        const analytics = resolveAnalyticsProps(props);
-        delete config.modResults[INFO_ANALYTICS_DISABLED];
-        delete config.modResults[STALE_INFO_POSTHOG_API_KEY];
-        delete config.modResults[STALE_INFO_POSTHOG_HOST];
-        if (analytics.disabled !== undefined) {
-            config.modResults[INFO_ANALYTICS_DISABLED] = analytics.disabled;
-        }
+        config.modResults = applyBluetoothSdkInfoPlist(config.modResults, props);
         return config;
     });
 }
@@ -87,7 +99,7 @@ const withIosConfiguration = (config, props) => {
         config.modResults.contents = ensureBluetoothSdkExpoAdapterPodEnv(config.modResults.contents);
         return config;
     });
-    config = withAnalyticsInfoPlist(config, props);
+    config = withBluetoothSdkInfoPlist(config, props);
     if (props?.node) {
         config = withXcodeEnvLocal(config);
     }

package/scripts/public-ota-api.test.mjs

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict"
+import {readFileSync} from "node:fs"
+import path from "node:path"
+import test from "node:test"
+import {fileURLToPath} from "node:url"
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+
+test("publishes the supported OTA transport entrypoint", () => {
+  const manifest = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8"))
+  assert.deepEqual(manifest.exports["./ota-transport"], {
+    "react-native": "./src/ota-transport/index.ts",
+    "types": "./build/ota-transport/index.d.ts",
+    "default": "./build/ota-transport/index.js",
+  })
+
+  const source = readFileSync(path.join(packageRoot, "src/ota-transport/index.ts"), "utf8")
+  assert.match(source, /export const otaLocalNetwork/)
+  assert.match(source, /export const otaServer/)
+  assert.doesNotMatch(source, /export \{default as Mentra(LocalNetwork|OtaServer)/)
+})
+
+test("keeps restart signals and correlated OTA status on the public root", () => {
+  const source = readFileSync(path.join(packageRoot, "src/index.ts"), "utf8")
+  for (const required of [
+    '"glasses_session_changed"',
+    '"mtk_update_complete"',
+    "queryOtaStatus",
+    "subscribeGlassesStatus",
+    "subscribeBluetoothStatus",
+    "setSystemTime",
+    "ping",
+  ]) {
+    assert.ok(source.includes(required), `missing public OTA primitive: ${required}`)
+  }
+  assert.match(source, /Unsupported BluetoothSdk event/)
+})

package/scripts/verify-release-package.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import {readFileSync} from "node:fs"
+import path from "node:path"
+
+function option(name) {
+  const index = process.argv.indexOf(`--${name}`)
+  if (index < 0 || !process.argv[index + 1]) throw new Error(`Missing --${name}`)
+  return process.argv[index + 1]
+}
+
+const packageRoot = path.resolve(option("package-root"))
+const releaseIdentity = option("release-identity")
+const otaManifestUrl = option("ota-manifest-url")
+const otaManifestSha256 = option("ota-manifest-sha256")
+const packageJson = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8"))
+if (packageJson.version !== releaseIdentity) {
+  throw new Error(`Packed SDK version ${JSON.stringify(packageJson.version)} does not match ${releaseIdentity}`)
+}
+
+const files = [
+  "src/generated/releaseMetadata.ts",
+  "build/generated/releaseMetadata.js",
+  "android/src/main/java/com/mentra/bluetoothsdk/GeneratedReleaseMetadata.kt",
+  "ios/Source/GeneratedReleaseMetadata.swift",
+]
+for (const relativePath of files) {
+  const contents = readFileSync(path.join(packageRoot, relativePath), "utf8")
+  if (!contents.includes(otaManifestUrl)) throw new Error(`${relativePath} does not contain the OTA manifest URL`)
+  if (!contents.includes(otaManifestSha256))
+    throw new Error(`${relativePath} does not contain the OTA manifest SHA-256`)
+  if (!contents.includes(releaseIdentity)) throw new Error(`${relativePath} does not contain the release identity`)
+}
+
+console.log(`Verified packed Bluetooth SDK ${releaseIdentity} metadata across JavaScript, Android, and iOS`)

package/scripts/write-release-metadata.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import {mkdirSync, writeFileSync} from "node:fs"
+import path from "node:path"
+import {fileURLToPath} from "node:url"
+
+const STABLE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/
+const RELEASE_IDENTITY_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:dev|beta)\.[1-9]\d*)?$/
+const COMMIT_PATTERN = /^[0-9a-f]{40}$/
+const SHA256_PATTERN = /^[0-9a-f]{64}$/
+
+function validateHttpsUrl(value) {
+  let url
+  try {
+    url = new URL(value)
+  } catch {
+    throw new Error(`OTA manifest URL is invalid: ${JSON.stringify(value)}`)
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.hash) {
+    throw new Error("OTA manifest URL must be credential-free HTTPS without a fragment")
+  }
+  return url.toString()
+}
+
+export function validateReleaseMetadata(input) {
+  if (!STABLE_VERSION_PATTERN.test(input.familyBaseVersion)) {
+    throw new Error("familyBaseVersion must be a plain X.Y.Z version")
+  }
+  if (!RELEASE_IDENTITY_PATTERN.test(input.releaseIdentity)) {
+    throw new Error("releaseIdentity must be X.Y.Z, X.Y.Z-dev.N, or X.Y.Z-beta.N")
+  }
+  if (
+    input.releaseIdentity !== input.familyBaseVersion &&
+    !input.releaseIdentity.startsWith(`${input.familyBaseVersion}-`)
+  ) {
+    throw new Error("releaseIdentity does not belong to familyBaseVersion")
+  }
+  if (input.releaseSetId !== `mentra-${input.releaseIdentity}`) {
+    throw new Error("releaseSetId must be mentra-<releaseIdentity>")
+  }
+  if (!COMMIT_PATTERN.test(input.sourceCommit)) throw new Error("sourceCommit must be a full lowercase Git SHA")
+  if (!SHA256_PATTERN.test(input.otaManifestSha256)) {
+    throw new Error("otaManifestSha256 must be a lowercase SHA-256 digest")
+  }
+  return {
+    schemaVersion: 1,
+    familyBaseVersion: input.familyBaseVersion,
+    releaseIdentity: input.releaseIdentity,
+    releaseSetId: input.releaseSetId,
+    sourceCommit: input.sourceCommit,
+    otaManifestUrl: validateHttpsUrl(input.otaManifestUrl),
+    otaManifestSha256: input.otaManifestSha256,
+  }
+}
+
+function swiftString(value) {
+  return JSON.stringify(value)
+}
+
+export function renderReleaseMetadata(input) {
+  const metadata = validateReleaseMetadata(input)
+  const typescript = [
+    "/** Generated by release CI. Do not edit in a release checkout. */",
+    "export interface BluetoothSdkReleaseMetadata {",
+    "  schemaVersion: 1",
+    "  familyBaseVersion: string | null",
+    "  releaseIdentity: string | null",
+    "  releaseSetId: string | null",
+    "  sourceCommit: string | null",
+    "  otaManifestUrl: string | null",
+    "  otaManifestSha256: string | null",
+    "}",
+    "",
+    `export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze(${JSON.stringify(
+      metadata,
+      null,
+      2,
+    )})`,
+    "",
+  ].join("\n")
+  const kotlin = [
+    "package com.mentra.bluetoothsdk",
+    "",
+    "/** Generated by release CI. Do not edit in a release checkout. */",
+    "internal object GeneratedReleaseMetadata {",
+    `    const val FAMILY_BASE_VERSION: String = ${JSON.stringify(metadata.familyBaseVersion)}`,
+    `    const val RELEASE_IDENTITY: String = ${JSON.stringify(metadata.releaseIdentity)}`,
+    `    const val RELEASE_SET_ID: String = ${JSON.stringify(metadata.releaseSetId)}`,
+    `    const val SOURCE_COMMIT: String = ${JSON.stringify(metadata.sourceCommit)}`,
+    `    const val OTA_MANIFEST_URL: String = ${JSON.stringify(metadata.otaManifestUrl)}`,
+    `    const val OTA_MANIFEST_SHA256: String = ${JSON.stringify(metadata.otaManifestSha256)}`,
+    "}",
+    "",
+  ].join("\n")
+  const swift = [
+    "import Foundation",
+    "",
+    "/// Generated by release CI. Do not edit in a release checkout.",
+    "enum GeneratedReleaseMetadata {",
+    `    static let familyBaseVersion = ${swiftString(metadata.familyBaseVersion)}`,
+    `    static let releaseIdentity = ${swiftString(metadata.releaseIdentity)}`,
+    `    static let releaseSetId = ${swiftString(metadata.releaseSetId)}`,
+    `    static let sourceCommit = ${swiftString(metadata.sourceCommit)}`,
+    `    static let otaManifestUrl = ${swiftString(metadata.otaManifestUrl)}`,
+    `    static let otaManifestSha256 = ${swiftString(metadata.otaManifestSha256)}`,
+    "}",
+    "",
+  ].join("\n")
+  return {metadata, typescript, kotlin, swift}
+}
+
+function parseArgs(args) {
+  const values = {}
+  for (let index = 0; index < args.length; index += 2) {
+    const option = args[index]
+    const value = args[index + 1]
+    if (!option?.startsWith("--") || value === undefined) throw new Error("Expected --name value pairs")
+    values[option.slice(2)] = value
+  }
+  return values
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2))
+  const required = [
+    "family-base-version",
+    "release-identity",
+    "release-set-id",
+    "source-commit",
+    "ota-manifest-url",
+    "ota-manifest-sha256",
+  ]
+  for (const field of required) if (!args[field]) throw new Error(`Missing --${field}`)
+  const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+  const rendered = renderReleaseMetadata({
+    familyBaseVersion: args["family-base-version"],
+    releaseIdentity: args["release-identity"],
+    releaseSetId: args["release-set-id"],
+    sourceCommit: args["source-commit"],
+    otaManifestUrl: args["ota-manifest-url"],
+    otaManifestSha256: args["ota-manifest-sha256"],
+  })
+  const outputs = {
+    typescript: path.join(packageRoot, "src/generated/releaseMetadata.ts"),
+    kotlin: path.join(packageRoot, "android/src/main/java/com/mentra/bluetoothsdk/GeneratedReleaseMetadata.kt"),
+    swift: path.join(packageRoot, "ios/Source/GeneratedReleaseMetadata.swift"),
+  }
+  for (const [target, file] of Object.entries(outputs)) {
+    mkdirSync(path.dirname(file), {recursive: true})
+    writeFileSync(file, rendered[target])
+  }
+  console.log(`Wrote Bluetooth SDK release metadata for ${rendered.metadata.releaseSetId}`)
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main()

package/scripts/write-release-metadata.test.mjs

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import {renderReleaseMetadata, validateReleaseMetadata} from "./write-release-metadata.mjs"
+
+const input = {
+  familyBaseVersion: "3.1.0",
+  releaseIdentity: "3.1.0-beta.57",
+  releaseSetId: "mentra-3.1.0-beta.57",
+  sourceCommit: "a".repeat(40),
+  otaManifestUrl:
+    "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-3.1.0-beta.57/mentra-live-ota-3.1.0-beta.57.json",
+  otaManifestSha256: "b".repeat(64),
+}
+
+test("renders identical immutable metadata for TypeScript, Kotlin, and Swift", () => {
+  const rendered = renderReleaseMetadata(input)
+  for (const contents of [rendered.typescript, rendered.kotlin, rendered.swift]) {
+    assert.match(contents, /3\.1\.0-beta\.57/)
+    assert.match(contents, /mentra-live-ota-3\.1\.0-beta\.57\.json/)
+    assert.match(contents, new RegExp("b".repeat(64)))
+  }
+})
+
+test("rejects mutable or cross-family release metadata", () => {
+  assert.throws(() => validateReleaseMetadata({...input, releaseIdentity: "3.2.0-beta.57"}), /does not belong/)
+  assert.throws(() => validateReleaseMetadata({...input, otaManifestUrl: "http://example.com/version.json"}), /HTTPS/)
+  assert.throws(() => validateReleaseMetadata({...input, otaManifestSha256: "short"}), /SHA-256/)
+})

package/src/BluetoothSdk.types.ts

@@ -155,6 +155,8 @@ export type VersionInfoResult = {
   systemTimeMs?: number
   otaVersionUrl: string
   appVersion: string
+  /** Phone-served hotspot OTA protocol version; 0 means unsupported/legacy glasses. */
+  hotspotOtaVersion: number
 }
 
 export type VersionInfoEvent = VersionInfoResult & {
@@ -648,6 +650,23 @@ export type PairFailureEvent = {
   error: string
 }
 
+export type PairingInfoEvent = {
+  had_previous_bond: boolean
+  pairing_code?: string
+  classic_bond_ready?: boolean
+  secure_pairing_capable?: boolean
+  protocol_version?: number
+}
+
+export type EnteringPairingModeEvent = {
+  window_ms: number
+  reason?: string
+}
+
+export type OwnerReplacedEvent = {
+  reason: string
+}
+
 export type AudioPairingNeededEvent = {
   type: "audio_pairing_needed"
   deviceName: string
@@ -701,6 +720,17 @@ export type MicLc3Event = {
   voiceActivityDetectionEnabled: boolean
 }
 
+/** Native glasses-microphone diagnostics emitted when the SDK detects a transport or decode issue. */
+export type MicHealthEvent = {
+  type: "mic_health"
+  reason: "sequence_gap" | "decode_failure"
+  sequenceGapEvents: number
+  decodeFailures: number
+  lastLc3ReceivedAt?: number
+  lastPcmProducedAt?: number
+  timestamp: number
+}
+
 export type StreamStatusLifecycleState = "initializing" | "streaming" | "stopping" | "stopped"
 export type StreamStatusReconnectState = "reconnecting" | "reconnected" | "reconnect_failed"
 export type StreamStatusState = StreamStatusLifecycleState | StreamStatusReconnectState | "error"
@@ -895,6 +925,9 @@ export type BluetoothSdkModuleEvents = {
   rgb_led_control_response: (event: RgbLedControlResponseEvent) => void
   settings_ack: (event: SettingsAckEvent) => void
   pair_failure: (event: PairFailureEvent) => void
+  pairing_info: (event: PairingInfoEvent) => void
+  entering_pairing_mode: (event: EnteringPairingModeEvent) => void
+  owner_replaced: (event: OwnerReplacedEvent) => void
   audio_pairing_needed: (event: AudioPairingNeededEvent) => void
   audio_connected: (event: AudioConnectedEvent) => void
   audio_disconnected: (event: AudioDisconnectedEvent) => void
@@ -903,6 +936,7 @@ export type BluetoothSdkModuleEvents = {
   ws_bin: (event: WsBinEvent) => void
   mic_pcm: (event: MicPcmEvent) => void
   mic_lc3: (event: MicLc3Event) => void
+  mic_health: (event: MicHealthEvent) => void
   stream_status: (event: StreamStatusEvent) => void
   keep_alive_ack: (event: KeepAliveAckEvent) => void
   mtk_update_complete: (event: MtkUpdateCompleteEvent) => void
@@ -999,12 +1033,20 @@ export type BluetoothSdkEventMap = {
   rgb_led_control_response: RgbLedControlResponseEvent
   settings_ack: SettingsAckEvent
   pair_failure: PairFailureEvent
+  pairing_info: PairingInfoEvent
+  entering_pairing_mode: EnteringPairingModeEvent
+  owner_replaced: OwnerReplacedEvent
   audio_pairing_needed: AudioPairingNeededEvent
   audio_connected: AudioConnectedEvent
   audio_disconnected: AudioDisconnectedEvent
   mic_pcm: MicPcmEvent
   mic_lc3: MicLc3Event
+  mic_health: MicHealthEvent
   stream_status: StreamStatusEvent
+  /** Mentra Live MTK updater completed and the glasses are about to restart. */
+  mtk_update_complete: MtkUpdateCompleteEvent
+  /** The ASG process restarted while the BES kept the BLE connection alive. */
+  glasses_session_changed: GlassesSessionChangedEvent
   ota_start_ack: OtaStartAckEvent
   ota_status: OtaStatusEvent
   ar99_ota_status: Ar99OtaStatusEvent
@@ -1030,6 +1072,15 @@ export interface BluetoothSdkPublicModule {
     listener: BluetoothSdkEventListener<EventName>,
   ): BluetoothSdkSubscription
 
+  /** Read an immutable snapshot of the current glasses state. */
+  getGlassesStatus(): Promise<PublicGlassesStatus>
+  /** Read an immutable snapshot of the phone Bluetooth adapter state. */
+  getBluetoothStatus(): Promise<PublicBluetoothStatus>
+  /** Observe immutable glasses-state patches. Returns an unsubscribe function. */
+  subscribeGlassesStatus(listener: (changed: Partial<PublicGlassesStatus>) => void): () => void
+  /** Observe immutable Bluetooth-state patches. Returns an unsubscribe function. */
+  subscribeBluetoothStatus(listener: (changed: Partial<PublicBluetoothStatus>) => void): () => void
+
   getDefaultDevice(): Promise<Device | null>
   setDefaultDevice(device: Device | null): Promise<void>
   clearDefaultDevice(): Promise<void>
@@ -1051,11 +1102,17 @@ export interface BluetoothSdkPublicModule {
   setHeadUpAngle(angleDegrees: number): Promise<void>
   setImuEnabled(enabled: boolean): Promise<void>
   setScreenDisabled(disabled: boolean): Promise<void>
+  /** Keep legacy Mentra Live OTA sessions awake. Modern sessions normally do not require this. */
+  ping(): Promise<void>
 
   requestWifiScan(): Promise<WifiSearchResult[]>
   sendWifiCredentials(ssid: string, password: string): Promise<WifiStatusChangeEvent>
   forgetWifiNetwork(ssid: string): Promise<WifiStatusChangeEvent>
   setHotspotState(enabled: boolean): Promise<HotspotStatusChangeEvent>
+  /** Set the glasses clock from the phone after an OTA clock-skew failure. */
+  setSystemTime(timestampMs: number): Promise<void>
+  /** Enable or disable Wi-Fi ADB on Mentra Live (no-op on other devices). */
+  setWifiAdbState(enabled: boolean): Promise<void>
 
   setGalleryModeEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>
   setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>
@@ -1110,6 +1167,8 @@ export interface BluetoothSdkPublicModule {
     webhookUrl?: string,
     authToken?: string,
   ): Promise<VideoRecordingStoppedStatusEvent>
+  /** Query the glasses for the current recording state and elapsed duration. */
+  queryVideoRecordingStatus(requestId: string): Promise<VideoRecordingStatusEvent>
 
   startStream(params: StreamStartRequest): Promise<StreamStatusEvent>
   stopStream(): Promise<StreamStatusEvent>
@@ -1131,14 +1190,31 @@ export interface BluetoothSdkPublicModule {
   ): Promise<RgbLedControlSuccessResponseEvent>
 
   requestVersionInfo(): Promise<VersionInfoResult>
+  /**
+   * Select the OTA manifest used by subsequent update checks and installs.
+   * The URL may point at Mentra's hosted manifest or any customer-controlled HTTP(S) server.
+   */
+  setOtaVersionUrl(otaVersionUrl: string): void
+  /** Return the configured or release-embedded OTA manifest URL. Rejects when a source build is unconfigured. */
+  getOtaVersionUrl(): string
   /** Fetch the configured OTA manifest and return whether any ASG/BES/MTK update is available. */
   checkForOtaUpdate(): Promise<boolean>
-  /** Start the OTA flow with the same configured manifest URL used by checkForOtaUpdate(). */
-  startOtaUpdate(): Promise<OtaStartAckEvent>
+  /** Return bundled release changelogs crossed between two coordinated product versions, newest first. */
+  getReleaseChangelogs(fromVersion?: string | null, toVersion?: string | null): ReleaseChangelog[]
+  /** Start OTA from the configured or explicitly supplied manifest URL. */
+  startOtaUpdate(otaVersionUrl?: string | null): Promise<OtaStartAckEvent>
+  /** Query the active OTA session and return the correlated status response. */
+  queryOtaStatus(): Promise<OtaQueryResult>
   startAr99OtaFromFile(path: string): Promise<boolean>
   cancelAr99Ota(): Promise<void>
   sendAr99FactoryReset(): Promise<void>
-  buildAr99OtaSignature(secret: string, appName: string, currentVersion: string, serialNumber: string, nonce: string): string
+  buildAr99OtaSignature(
+    secret: string,
+    appName: string,
+    currentVersion: string,
+    serialNumber: string,
+    nonce: string,
+  ): string
 
   // // stt commands (MOVE TO CRUST)
   // setSttModelDetails(path: string, languageCode: string): Promise<void>
@@ -1201,10 +1277,19 @@ export interface OtaUpdateInfo {
   updates: string[] // ["apk", "mtk", "bes"]
   totalSize: number
   cacheReady?: boolean
+  /** Exact BES target selected from the OTA manifest, when a BES step is pending. */
+  besVersion?: string
   /** True when the APK step installs an older build than the glasses currently run (exact-pin manifests only). */
   isDowngrade?: boolean
 }
 
+export interface ReleaseChangelog {
+  /** Base production version, for example `3.1.0`. */
+  version: string
+  /** Markdown body authored in `/changelogs/<version>.md`. */
+  markdown: string
+}
+
 export interface OtaProgress {
   stage: OtaStage
   status: OtaProgressStatus
@@ -1231,6 +1316,7 @@ export interface GlassesStatus {
   besFirmwareVersion: string
   mtkFirmwareVersion: string
   bluetoothMacAddress: string
+  wifiMacAddress: string
   leftMacAddress: string
   rightMacAddress: string
   buildNumber: string
@@ -1238,6 +1324,8 @@ export interface GlassesStatus {
   systemTimeMs?: number
   otaVersionUrl: string
   appVersion: string
+  /** Phone-served hotspot OTA protocol version; 0 means unsupported/legacy glasses. */
+  hotspotOtaVersion: number
   bluetoothName: string
   serialNumber: string
   style: string
@@ -1301,6 +1389,12 @@ export interface Device {
    * appear in a later scan update when the platform reports RSSI metadata.
    */
   rssi?: number
+  /** Mentra Live: unit is currently in pairing mode (adv flag). */
+  pairingMode?: boolean
+  /** Mentra Live: four-character hex spoken pairing code when available. */
+  pairingCode?: string
+  /** Mentra Live: advertisement carries the secure-pairing capability trailer. */
+  securePairingCapable?: boolean
 }
 
 export interface ConnectOptions {

package/src/_internal.ts

@@ -11,4 +11,6 @@ export type {BluetoothSdkInternalModule} from "./_private/BluetoothSdkModule"
 export * from "./BluetoothSdk.types"
 export {default as MentraLocalNetwork} from "./_private/MentraLocalNetworkModule"
 export * from "./_private/MentraLocalNetworkModule"
+export {default as MentraOtaServer} from "./ota-server"
+export * from "./ota-server/MentraOtaServer.types"
 export {BLUETOOTH_SDK_VERSION, sdkPinnedOtaManifestUrl} from "./_private/sdkOtaManifest"

package/src/_private/BluetoothSdkModule.ts

@@ -44,6 +44,7 @@ import {
   VideoRecordingStartedStatusEvent,
   VideoRecordingSettings,
   VideoRecordingStoppedStatusEvent,
+  VideoRecordingStatusEvent,
   VersionInfoResult,
   WarmUpCameraParams,
   WifiSearchResult,
@@ -117,6 +118,8 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
   sendWifiCredentials(ssid: string, password: string): Promise<WifiStatusChangeEvent>
   forgetWifiNetwork(ssid: string): Promise<WifiStatusChangeEvent>
   setHotspotState(enabled: boolean): Promise<HotspotStatusChangeEvent>
+  /** Enable or disable Wi-Fi ADB on Mentra Live (no-op on other devices). */
+  setWifiAdbState(enabled: boolean): Promise<void>
   /** Set the glasses system clock when phone detects clock skew (Mentra Live and G2). */
   setSystemTime(timestampMs: number): Promise<void>
   /** Logs current WiFi frequency (MHz) and 5 GHz band to Android logcat. */
@@ -179,6 +182,7 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
     webhookUrl?: string,
     authToken?: string,
   ): Promise<VideoRecordingStoppedStatusEvent>
+  queryVideoRecordingStatus(requestId: string): Promise<VideoRecordingStatusEvent>
 
   // Stream Commands
   startStream(params: StreamStartRequest): Promise<StreamStatusEvent>
@@ -293,7 +297,7 @@ const CAMERA_ROI_POSITION_VALUES: Record<CameraRoiPosition, CameraFovSetting["ro
 }
 
 // Named presets are a convenience layer over the numeric {fov, roiPosition} API.
-// The default is the full sensor; "standard" preserves the historical 102� crop.
+// The default is the full sensor; "standard" preserves the historical 102° crop.
 const CAMERA_FOV_PRESETS: Record<CameraFovPreset, CameraFovSetting> = {
   narrow: {fov: 82, roiPosition: 0},
   standard: {fov: 102, roiPosition: 0},
@@ -649,7 +653,3 @@ NativeBluetoothSdkModule.warmUpCamera = function (params: WarmUpCameraParams) {
 
 export default NativeBluetoothSdkModule
 export const BluetoothSdk = NativeBluetoothSdkModule as BluetoothSdkInternalModule
-
-
-
-

package/src/_private/MentraLocalNetworkModule.ts

@@ -26,7 +26,7 @@ type LocalNetworkEvents = {
 }
 
 declare class MentraLocalNetworkNativeModule extends NativeModule<LocalNetworkEvents> {
-  connect(ssid: string, password: string): Promise<{connected: boolean; ssid: string}>
+  connect(ssid: string, password: string): Promise<{connected: boolean; ssid: string; localAddress?: string}>
   request(
     requestId: string,
     url: string,

package/src/_private/sdkOtaManifest.ts

@@ -1,17 +1,9 @@
 /**
- * SDK-pinned OTA manifest URL derivation.
- *
- * Each Bluetooth SDK release publishes an immutable manifest
- * (`bluetooth-sdk-<version>-version.json`) pinning the exact ASG artifact paired with that SDK
- * version. The URL is derived from this package's own version — the version is frozen into the
- * published artifact, so this is equivalent to baking the URL at release time while keeping the
- * manifest itself replaceable as an operational escape hatch (asset moves, CDN migration).
- *
- * Mirrors the native derivation in `OtaManifestDefaults.defaultOtaVersionUrl()` (Kotlin) /
- * `BluetoothSdkDefaults` (Swift).
+ * Release CI embeds one immutable OTA manifest URL into every SDK distribution.
+ * Source builds remain unpinned and must opt in through the debug configuration API.
  */
 
-const SDK_OTA_RELEASE_BASE_URL = "https://github.com/Mentra-Community/MentraOS/releases/download/bluetooth-sdk-ota"
+import {BLUETOOTH_SDK_RELEASE_METADATA} from "../generated/releaseMetadata"
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const packageJson = require("../../package.json") as {version?: string}
@@ -20,12 +12,8 @@ const packageJson = require("../../package.json") as {version?: string}
 export const BLUETOOTH_SDK_VERSION: string = (packageJson.version ?? "").trim()
 
 /**
- * The immutable manifest URL pinning the ASG artifact paired with this SDK version, or null when
- * the package version is unavailable (malformed workspace state).
+ * The immutable manifest URL embedded by release CI, or null for an unpinned source build.
  */
 export function sdkPinnedOtaManifestUrl(): string | null {
-  if (!BLUETOOTH_SDK_VERSION) {
-    return null
-  }
-  return `${SDK_OTA_RELEASE_BASE_URL}/bluetooth-sdk-${BLUETOOTH_SDK_VERSION}-version.json`
+  return BLUETOOTH_SDK_RELEASE_METADATA.otaManifestUrl
 }