@domicile-desktop/system-bluetooth 0.0.0-alpha-44d0983a58ce → 0.0.0-alpha-56dd6c187f4e

package/README.md

@@ -2,22 +2,20 @@
 
 BlueZ for a Domicile shell: each adapter and whether it is powered or
 scanning, the devices it knows, and the requests that change them. Built on
-[`@domicile-desktop/sdk/system`](../chrome-sdk/README.md).
+the desktop's `dbus` namespace ([`@domicile-desktop/sdk`](../chrome-sdk/README.md)).
 
 ## Usage
 
 ```ts
-import { system } from "@domicile-desktop/sdk/system";
 import { setPowered, watchBluetooth } from "@domicile-desktop/system-bluetooth/bluetooth";
 
-const host = system(domicile);
-const stop = watchBluetooth(host, (bluetooth) => {
+const stop = watchBluetooth(domicile, (bluetooth) => {
   bluetooth.match({
     Err: () => hide(),
     Ok: ({ adapters, devices }) => show(adapters, devices),
   });
 });
-await setPowered(host, "/org/bluez/hci0", false);
+await setPowered(domicile, "/org/bluez/hci0", false);
 ```
 
 - Reads `GetManagedObjects` once, then again when an object comes or goes or

package/dist/bluetooth.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from "@cprussin/option-result";
-import type { System, SystemError } from "@domicile-desktop/sdk/system";
+import type { Dbus } from "@domicile-desktop/sdk/desktop/dbus";
+import type { SystemError } from "@domicile-desktop/sdk/system";
 /** A controller, such as `/org/bluez/hci0`. */
 export type Adapter = {
     path: string;
@@ -28,7 +29,9 @@ export type Bluetooth = {
     devices: Device[];
 };
 /** The calls this library makes. */
-export type BluetoothSystem = Pick<System, "dbusCall" | "dbusMatch">;
+export type BluetoothDesktop = {
+    readonly dbus: Pick<Dbus, "call" | "match">;
+};
 /**
  * Calls `onBluetooth` with the adapters and connected devices now and after
  * each change, and returns a function that stops watching.
@@ -36,19 +39,33 @@ export type BluetoothSystem = Pick<System, "dbusCall" | "dbusMatch">;
  * An `Err` is a D-Bus failure, such as BlueZ not running. The watch keeps
  * listening after one, so a later change reads again.
  */
-export declare const watchBluetooth: (system: BluetoothSystem, onBluetooth: (bluetooth: Result<Bluetooth, SystemError>) => void) => (() => void);
+export declare const watchBluetooth: (domicile: BluetoothDesktop, onBluetooth: (bluetooth: Result<Bluetooth, SystemError>) => void) => (() => void);
 /** Turn the adapter at `adapter` on or off. */
-export declare const setPowered: (system: Pick<System, "dbusCall">, adapter: string, powered: boolean) => Promise<Result<"set", SystemError>>;
+export declare const setPowered: (domicile: {
+    readonly dbus: Pick<Dbus, "call">;
+}, adapter: string, powered: boolean) => Promise<Result<"set", SystemError>>;
 /** Start scanning for devices. BlueZ stops when every scanner has asked. */
-export declare const startDiscovery: (system: Pick<System, "dbusCall">, adapter: string) => Promise<Result<"done", SystemError>>;
-export declare const stopDiscovery: (system: Pick<System, "dbusCall">, adapter: string) => Promise<Result<"done", SystemError>>;
+export declare const startDiscovery: (domicile: {
+    readonly dbus: Pick<Dbus, "call">;
+}, adapter: string) => Promise<Result<"done", SystemError>>;
+export declare const stopDiscovery: (domicile: {
+    readonly dbus: Pick<Dbus, "call">;
+}, adapter: string) => Promise<Result<"done", SystemError>>;
 /** Connect a paired device's profiles. */
-export declare const connect: (system: Pick<System, "dbusCall">, device: string) => Promise<Result<"done", SystemError>>;
-export declare const disconnect: (system: Pick<System, "dbusCall">, device: string) => Promise<Result<"done", SystemError>>;
+export declare const connect: (domicile: {
+    readonly dbus: Pick<Dbus, "call">;
+}, device: string) => Promise<Result<"done", SystemError>>;
+export declare const disconnect: (domicile: {
+    readonly dbus: Pick<Dbus, "call">;
+}, device: string) => Promise<Result<"done", SystemError>>;
 /**
  * Pair with a device, then trust it so it can reconnect on its own. With no
  * agent registered, BlueZ pairs only devices that need no code.
  */
-export declare const pair: (system: Pick<System, "dbusCall">, device: string) => Promise<Result<"done", SystemError>>;
+export declare const pair: (domicile: {
+    readonly dbus: Pick<Dbus, "call">;
+}, device: string) => Promise<Result<"done", SystemError>>;
 /** Remove a device and its pairing. */
-export declare const forget: (system: Pick<System, "dbusCall">, device: Pick<Device, "adapter" | "path">) => Promise<Result<"done", SystemError>>;
+export declare const forget: (domicile: {
+    readonly dbus: Pick<Dbus, "call">;
+}, device: Pick<Device, "adapter" | "path">) => Promise<Result<"done", SystemError>>;

package/dist/bluetooth.js

@@ -20,14 +20,14 @@ const WATCHED = {
  * An `Err` is a D-Bus failure, such as BlueZ not running. The watch keeps
  * listening after one, so a later change reads again.
  */
-export const watchBluetooth = (system, onBluetooth) => {
+export const watchBluetooth = (domicile, onBluetooth) => {
     const watch = { listening: undefined, stopped: false };
     const report = (bluetooth) => {
         if (!watch.stopped) {
             onBluetooth(bluetooth);
         }
     };
-    follow(system, watch, report).catch((error) => {
+    follow(domicile, watch, report).catch((error) => {
         // biome-ignore lint/suspicious/noConsole: surfacing a background failure
         console.error("Failed to watch Bluetooth", error);
     });
@@ -37,7 +37,7 @@ export const watchBluetooth = (system, onBluetooth) => {
     };
 };
 /** Turn the adapter at `adapter` on or off. */
-export const setPowered = async (system, adapter, powered) => (await system.dbusCall({
+export const setPowered = async (domicile, adapter, powered) => (await domicile.dbus.call({
     body: [ADAPTER, "Powered", { signature: "b", value: powered }],
     bus: Bus.System,
     destination: SERVICE,
@@ -47,16 +47,16 @@ export const setPowered = async (system, adapter, powered) => (await system.dbus
     signature: "ssv",
 })).map(() => "set");
 /** Start scanning for devices. BlueZ stops when every scanner has asked. */
-export const startDiscovery = (system, adapter) => call(system, adapter, ADAPTER, "StartDiscovery");
-export const stopDiscovery = (system, adapter) => call(system, adapter, ADAPTER, "StopDiscovery");
+export const startDiscovery = (domicile, adapter) => call(domicile, adapter, ADAPTER, "StartDiscovery");
+export const stopDiscovery = (domicile, adapter) => call(domicile, adapter, ADAPTER, "StopDiscovery");
 /** Connect a paired device's profiles. */
-export const connect = (system, device) => call(system, device, DEVICE, "Connect");
-export const disconnect = (system, device) => call(system, device, DEVICE, "Disconnect");
+export const connect = (domicile, device) => call(domicile, device, DEVICE, "Connect");
+export const disconnect = (domicile, device) => call(domicile, device, DEVICE, "Disconnect");
 /**
  * Pair with a device, then trust it so it can reconnect on its own. With no
  * agent registered, BlueZ pairs only devices that need no code.
  */
-export const pair = async (system, device) => (await call(system, device, DEVICE, "Pair")).andThenAsync(async () => (await system.dbusCall({
+export const pair = async (domicile, device) => (await call(domicile, device, DEVICE, "Pair")).andThenAsync(async () => (await domicile.dbus.call({
     body: [DEVICE, "Trusted", { signature: "b", value: true }],
     bus: Bus.System,
     destination: SERVICE,
@@ -66,7 +66,7 @@ export const pair = async (system, device) => (await call(system, device, DEVICE
     signature: "ssv",
 })).map(() => "done"));
 /** Remove a device and its pairing. */
-export const forget = async (system, device) => (await system.dbusCall({
+export const forget = async (domicile, device) => (await domicile.dbus.call({
     body: [device.path],
     bus: Bus.System,
     destination: SERVICE,
@@ -76,7 +76,7 @@ export const forget = async (system, device) => (await system.dbusCall({
     signature: "o",
 })).map(() => "done");
 /** A BlueZ method that takes no arguments. */
-const call = async (system, path, iface, member) => (await system.dbusCall({
+const call = async (domicile, path, iface, member) => (await domicile.dbus.call({
     bus: Bus.System,
     destination: SERVICE,
     interface: iface,
@@ -84,8 +84,11 @@ const call = async (system, path, iface, member) => (await system.dbusCall({
     path,
 })).map(() => "done");
 /** Listen, read, then read again on each change until the match ends. */
-const follow = async (system, watch, report) => {
-    const matched = await system.dbusMatch({ bus: Bus.System, sender: SERVICE });
+const follow = async (domicile, watch, report) => {
+    const matched = await domicile.dbus.match({
+        bus: Bus.System,
+        sender: SERVICE,
+    });
     await matched.match({
         Err: (error) => {
             report(Err(error));
@@ -96,7 +99,7 @@ const follow = async (system, watch, report) => {
             if (watch.stopped) {
                 listening.stop();
             }
-            await changes(system, listening, report);
+            await changes(domicile, listening, report);
             const ended = await listening.ended;
             ended.match({
                 Err: (error) => {
@@ -113,12 +116,12 @@ const follow = async (system, watch, report) => {
  * Read now, and again on each signal that changes what was read and after a
  * compositor restart.
  */
-const changes = async (system, listening, report) => {
+const changes = async (domicile, listening, report) => {
     const reader = listening.items.getReader();
-    report(await read(system));
+    report(await read(domicile));
     for (let next = await reader.read(); !next.done; next = await reader.read()) {
         if (next.value.kind === ListenedKind.Missed || matters(next.value.item)) {
-            report(await read(system));
+            report(await read(domicile));
         }
     }
 };
@@ -142,7 +145,7 @@ const matters = (signal) => {
         }
     }
 };
-const read = async (system) => (await system.dbusCall({
+const read = async (domicile) => (await domicile.dbus.call({
     bus: Bus.System,
     destination: SERVICE,
     interface: "org.freedesktop.DBus.ObjectManager",

package/dist/hardware.d.ts

@@ -1,10 +1,13 @@
 import type { Result } from "@cprussin/option-result";
-import type { System, SystemError } from "@domicile-desktop/sdk/system";
+import type { Files } from "@domicile-desktop/sdk/desktop/files";
+import type { SystemError } from "@domicile-desktop/sdk/system";
 /** The calls the check makes. Each works while the desktop is locked. */
-export type SysfsSystem = Pick<System, "readDir" | "readTextFile">;
+export type SysfsDesktop = {
+    readonly files: Pick<Files, "readDir" | "readText">;
+};
 /**
  * Whether there is a Bluetooth controller, or an rfkill switch for one. A
  * radio rfkill blocks can take its controller away with it, and its switch
  * stays.
  */
-export declare const hasBluetoothHardware: (system: SysfsSystem) => Promise<Result<boolean, SystemError>>;
+export declare const hasBluetoothHardware: (domicile: SysfsDesktop) => Promise<Result<boolean, SystemError>>;

package/dist/hardware.js

@@ -7,20 +7,20 @@ import { SystemErrorKind } from "@domicile-desktop/sdk/system";
  * radio rfkill blocks can take its controller away with it, and its switch
  * stays.
  */
-export const hasBluetoothHardware = async (system) => (await entriesOf(system, "/sys/class/bluetooth")).match({
+export const hasBluetoothHardware = async (domicile) => (await entriesOf(domicile, "/sys/class/bluetooth")).match({
     Err: (error) => Promise.resolve(Err(error)),
     Ok: async (controllers) => controllers.length > 0
         ? Ok(true)
-        : (await entriesOf(system, "/sys/class/rfkill")).match({
+        : (await entriesOf(domicile, "/sys/class/rfkill")).match({
             Err: (error) => Promise.resolve(Err(error)),
-            Ok: (switches) => anyOf(switches, async (name) => (await lineOf(system, `/sys/class/rfkill/${name}/type`)).map((type) => type.match({
+            Ok: (switches) => anyOf(switches, async (name) => (await lineOf(domicile, `/sys/class/rfkill/${name}/type`)).map((type) => type.match({
                 None: () => false,
                 Some: (is) => is === "bluetooth",
             }))),
         }),
 });
 /** The names in `dir`; none when it does not exist, as when no driver made it. */
-const entriesOf = async (system, dir) => (await system.readDir(dir)).match({
+const entriesOf = async (domicile, dir) => (await domicile.files.readDir(dir)).match({
     Err: (error) => error.kind === SystemErrorKind.NotFound ? Ok([]) : Err(error),
     Ok: (entries) => Ok(entries.map(({ name }) => name)),
 });
@@ -38,7 +38,7 @@ const anyOf = async (names, test) => {
     }
 };
 /** A one-line file under `/sys`, without its newline; `None` when missing. */
-const lineOf = async (system, path) => (await system.readTextFile(path)).match({
+const lineOf = async (domicile, path) => (await domicile.files.readText(path)).match({
     Err: (error) => error.kind === SystemErrorKind.NotFound ? Ok(None()) : Err(error),
     Ok: (text) => Ok(Some(text.trim())),
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
     "@cprussin/option-result": "^2.0.1",
-    "@domicile-desktop/sdk": "0.0.0-alpha-44d0983a58ce",
+    "@domicile-desktop/sdk": "0.0.0-alpha-56dd6c187f4e",
     "zod": "^4.5.4"
   },
   "description": "BlueZ for a Domicile shell: whether each adapter is powered and which devices are connected, kept current, and turning adapters on and off.",
@@ -45,5 +45,5 @@
     "test:unit": "bun test"
   },
   "type": "module",
-  "version": "0.0.0-alpha-44d0983a58ce"
+  "version": "0.0.0-alpha-56dd6c187f4e"
 }