yaver-feedback-react-native 0.7.7 → 0.7.9

package/src/Discovery.ts

@@ -256,36 +256,19 @@ export class YaverDiscovery {
    * does on same-LAN.
    */
   static async raceProbe(urls: string[]): Promise<DiscoveryResult | null> {
-    if (!urls || urls.length === 0) return null;
-    const attempts = urls.map((url) =>
-      YaverDiscovery.probe(url).then((r) => {
-        if (!r) throw new Error('no-200');
-        return r;
-      }),
-    );
-    try {
-      // `Promise.any` isn't on every RN runtime yet (older Hermes).
-      // Hand-roll the same behaviour so we don't need a polyfill.
-      return await new Promise<DiscoveryResult | null>((resolve) => {
-        let remaining = attempts.length;
-        let settled = false;
-        attempts.forEach((p) => {
-          p.then((r) => {
-            if (settled) return;
-            settled = true;
-            resolve(r);
-          }).catch(() => {
-            remaining -= 1;
-            if (remaining <= 0 && !settled) {
-              settled = true;
-              resolve(null);
-            }
-          });
-        });
-      });
-    } catch {
-      return null;
-    }
+    // Delegate to the canonical client-core implementation so mobile +
+    // SDK run the same race logic. Returned shape is `ProbeResult` —
+    // structurally compatible with DiscoveryResult minus the required
+    // hostname/version fields, which we backfill with sane defaults.
+    const { raceHealthProbes } = await import('./_core/device');
+    const res = await raceHealthProbes(urls, { timeoutMs: PROBE_TIMEOUT_MS });
+    if (!res) return null;
+    return {
+      url: res.url,
+      hostname: res.hostname ?? 'Unknown',
+      version: res.version ?? 'unknown',
+      latency: res.latency ?? 0,
+    };
   }
 
   /**

package/src/MachinePickerScreen.tsx

@@ -15,6 +15,7 @@ import {
   listReachableDevices,
   saveSelectedDeviceId,
 } from './auth';
+import { PairDeviceModal } from './PairDeviceModal';
 
 export interface YaverMachinePickerProps {
   token: string;
@@ -43,6 +44,7 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
   const [refreshing, setRefreshing] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [list, setList] = useState<DeviceList>({ owned: [], shared: [] });
+  const [pairingDevice, setPairingDevice] = useState<RemoteDevice | null>(null);
 
   const load = useCallback(async (silent = false) => {
     if (!silent) setLoading(true);
@@ -66,6 +68,15 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
   }, [load]);
 
   const handlePick = async (device: RemoteDevice) => {
+    // Needs-auth device — show the in-SDK pair modal instead of
+    // treating the tap as a "pick". The user enters the 6-char code
+    // from their Mac terminal; the SDK POSTs it to /auth/pair/submit
+    // on the agent directly. Once the device flips out of bootstrap
+    // mode, the next load() picks up the fresh state.
+    if (device.isOnline && device.needsAuth) {
+      setPairingDevice(device);
+      return;
+    }
     await saveSelectedDeviceId(device.deviceId);
     onPick(device);
   };
@@ -165,6 +176,17 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
           </>
         )}
       </ScrollView>
+
+      <PairDeviceModal
+        device={pairingDevice}
+        onClose={() => setPairingDevice(null)}
+        onPaired={() => {
+          // Give the agent a moment to flip bootstrap → owner mode,
+          // then reload the list so the now-authenticated device shows
+          // up with a green dot and can be selected normally.
+          setTimeout(() => void load(true), 1500);
+        }}
+      />
     </SafeAreaView>
   );
 };

package/src/PairDeviceModal.tsx

@@ -0,0 +1,228 @@
+import React, { useEffect, useState } from 'react';
+import {
+  ActivityIndicator,
+  Modal,
+  Platform,
+  Pressable,
+  StyleSheet,
+  Text,
+  TextInput,
+  View,
+} from 'react-native';
+import type { RemoteDevice } from './auth';
+import { getConvexSiteUrl, getToken } from './auth';
+
+/**
+ * In-SDK remote-pair modal. Shown when the user taps a device in the
+ * machine picker that's in `needsAuth` state.
+ *
+ * Flow:
+ *   1. User types the 6-char bootstrap passkey printed in the
+ *      `yaver serve` terminal on the Mac (also shown in Yaver mobile
+ *      app when pairing interactively).
+ *   2. SDK POSTs to `http://<device.quicHost>:<device.httpPort>/auth/pair/submit?code=XXXXXX`
+ *      with the user's Convex session token (same one the SDK already
+ *      has after Apple / Google / email sign-in).
+ *   3. Agent validates the token against Convex, persists it, flips
+ *      out of bootstrap mode — within a couple of seconds it'll
+ *      report `needsAuth=false` in /devices/list.
+ *
+ * This avoids making the user bounce to the Yaver mobile app just to
+ * adopt a machine. Works for owners and shared-scope guests since the
+ * pair endpoint accepts any valid Convex session that matches the
+ * expected account type.
+ */
+export interface PairDeviceModalProps {
+  device: RemoteDevice | null;
+  onClose: () => void;
+  onPaired?: (device: RemoteDevice) => void;
+}
+
+export const PairDeviceModal: React.FC<PairDeviceModalProps> = ({
+  device,
+  onClose,
+  onPaired,
+}) => {
+  const [code, setCode] = useState('');
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [success, setSuccess] = useState(false);
+
+  useEffect(() => {
+    if (device) {
+      setCode('');
+      setError(null);
+      setSuccess(false);
+    }
+  }, [device?.deviceId]);
+
+  const handleSubmit = async () => {
+    if (!device) return;
+    const trimmed = code.trim().toUpperCase();
+    if (trimmed.length !== 6) {
+      setError('Code must be 6 characters.');
+      return;
+    }
+    const token = await getToken();
+    if (!token) {
+      setError('Not signed in.');
+      return;
+    }
+    const host = (device.quicHost || '').trim();
+    const port = device.httpPort || device.quicPort || 18080;
+    if (!host) {
+      setError('No reachable address for this machine.');
+      return;
+    }
+    setBusy(true);
+    setError(null);
+    try {
+      const url = `http://${host}:${port}/auth/pair/submit?code=${encodeURIComponent(
+        trimmed,
+      )}`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          token,
+          convexSiteUrl: getConvexSiteUrl(),
+          // Backend reads userId from the session, but older agents
+          // expect it in the body. Pass empty string if unknown.
+          userId: '',
+        }),
+      });
+      if (!res.ok) {
+        let msg = `Agent rejected pair (HTTP ${res.status}).`;
+        try {
+          const body = await res.json();
+          if (body?.error) msg = String(body.error);
+        } catch {
+          // body not JSON
+        }
+        throw new Error(msg);
+      }
+      setSuccess(true);
+      onPaired?.(device);
+      setTimeout(() => {
+        onClose();
+      }, 1200);
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <Modal
+      visible={!!device}
+      animationType="slide"
+      transparent
+      onRequestClose={onClose}
+    >
+      <Pressable style={styles.overlay} onPress={onClose}>
+        <Pressable style={styles.card} onPress={(e) => e.stopPropagation()}>
+          <View style={styles.header}>
+            <Text style={styles.title}>Pair this Mac</Text>
+            <Pressable onPress={onClose} hitSlop={12} style={styles.closeBtn}>
+              <Text style={styles.closeIcon}>×</Text>
+            </Pressable>
+          </View>
+
+          <Text style={styles.deviceName}>{device?.name || device?.deviceId}</Text>
+          <Text style={styles.body}>
+            On the Mac where `yaver serve` is running, look for the 6-character code in the terminal output. Enter it here to adopt this machine.
+          </Text>
+
+          <TextInput
+            style={styles.codeInput}
+            value={code}
+            onChangeText={(v) => setCode(v.toUpperCase().replace(/[^A-Z0-9]/g, '').slice(0, 6))}
+            placeholder="ABCDEF"
+            placeholderTextColor="#555"
+            autoCapitalize="characters"
+            autoCorrect={false}
+            maxLength={6}
+            keyboardType={Platform.OS === 'ios' ? 'ascii-capable' : 'visible-password'}
+          />
+
+          {error && <Text style={styles.error}>{error}</Text>}
+          {success && <Text style={styles.success}>Paired ✓</Text>}
+
+          <Pressable
+            onPress={handleSubmit}
+            disabled={busy || success || code.length !== 6}
+            style={({ pressed }) => [
+              styles.submit,
+              (busy || success || code.length !== 6) && styles.submitDisabled,
+              pressed && { opacity: 0.7 },
+            ]}
+          >
+            {busy ? (
+              <ActivityIndicator color="#fff" />
+            ) : (
+              <Text style={styles.submitText}>{success ? 'Paired' : 'Pair'}</Text>
+            )}
+          </Pressable>
+        </Pressable>
+      </Pressable>
+    </Modal>
+  );
+};
+
+const styles = StyleSheet.create({
+  overlay: {
+    flex: 1,
+    backgroundColor: 'rgba(0,0,0,0.55)',
+    justifyContent: 'flex-end',
+  },
+  card: {
+    backgroundColor: '#141422',
+    borderTopLeftRadius: 22,
+    borderTopRightRadius: 22,
+    padding: 24,
+    paddingBottom: 36,
+    gap: 14,
+  },
+  header: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+  },
+  title: { fontSize: 20, fontWeight: '700', color: '#fff' },
+  closeBtn: {
+    width: 36,
+    height: 36,
+    borderRadius: 18,
+    alignItems: 'center',
+    justifyContent: 'center',
+    backgroundColor: 'rgba(255,255,255,0.08)',
+  },
+  closeIcon: { color: '#fff', fontSize: 22, lineHeight: 24 },
+  deviceName: { fontSize: 15, fontWeight: '600', color: '#c7c8ff' },
+  body: { fontSize: 13, color: '#9ca3af', lineHeight: 18 },
+  codeInput: {
+    backgroundColor: 'rgba(255,255,255,0.06)',
+    borderWidth: 1,
+    borderColor: 'rgba(255,255,255,0.14)',
+    borderRadius: 12,
+    paddingHorizontal: 16,
+    paddingVertical: 16,
+    fontSize: 22,
+    fontWeight: '700',
+    letterSpacing: 4,
+    textAlign: 'center',
+    color: '#fff',
+    fontFamily: Platform.OS === 'ios' ? 'Menlo' : 'monospace',
+  },
+  error: { color: '#ef4444', fontSize: 13 },
+  success: { color: '#22c55e', fontSize: 14, fontWeight: '600' },
+  submit: {
+    backgroundColor: '#818cf8',
+    borderRadius: 12,
+    paddingVertical: 14,
+    alignItems: 'center',
+  },
+  submitDisabled: { opacity: 0.35 },
+  submitText: { color: '#fff', fontSize: 16, fontWeight: '700' },
+});

package/src/_core/device.ts

@@ -0,0 +1,352 @@
+// AUTO-SYNCED from shared/client-core/src/device.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+
+/**
+ * Device dedup, merging, freshness, and target-picking.
+ *
+ * Phase-2 extract of the Yaver-mobile logic that lives at
+ * mobile/src/context/DeviceContext.tsx:193-413. Ported faithfully —
+ * mobile's collapseAliasDevices has been battle-tested through
+ * multiple Convex schema changes and the re-pair edge cases; this
+ * file is byte-identical in behaviour, only renamed for the shared
+ * RemoteDevice shape. The Feedback SDK used to carry its own copy
+ * (sdk/feedback/react-native/src/deviceDedup.ts) that drifted on
+ * `hwid` strong-identity and `runners`/`local` field preservation.
+ *
+ * Canonical device shape shared across every surface:
+ *   - Mobile app:  mobile/src/context/DeviceContext.tsx::Device (adapts
+ *                  into this shape at the Convex /devices/list fetch
+ *                  site).
+ *   - Feedback SDK: src/auth.ts::RemoteDevice re-exports this type.
+ *   - Web / Desktop: same.
+ *
+ * The mobile app may have extra view-model fields it wants to keep on
+ * its own Device interface (edgeProfile, sessionBinding, etc.) — those
+ * stay as local extensions; the core operates only on the fields
+ * declared here.
+ */
+
+import { HEARTBEAT_STALE_MS } from './constants';
+
+export interface CoreDevice {
+  /** Convex-issued device id. */
+  deviceId: string;
+  /** Display name — usually hostname. */
+  name: string;
+  /** OS family — "darwin", "linux", "windows". */
+  platform: string;
+  isOnline: boolean;
+  needsAuth: boolean;
+  runnerDown: boolean;
+  /** Unix ms of the latest heartbeat the agent sent to Convex. */
+  lastHeartbeat: number;
+  isGuest: boolean;
+  hostName?: string;
+  hostEmail?: string;
+  accessScope?: 'owner' | 'shared-scoped' | 'shared-legacy';
+  /** Primary LAN IP (or tunnel host) the agent advertised. */
+  quicHost: string;
+  quicPort: number;
+  /** HTTP port the agent listens on (usually 18080). */
+  httpPort?: number;
+  publicKey?: string;
+  /** Stable hardware identifier — dedup key for re-pair events. */
+  hwid?: string;
+  /**
+   * Every LAN IP the agent reported in its last heartbeat. Used by
+   * Discovery.raceProbe to try all interfaces in parallel.
+   */
+  localIps?: string[];
+}
+
+// ── Normalisers ───────────────────────────────────────────────────────
+
+function normName(name: string | undefined): string {
+  return String(name || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+
+function normHost(host: string | undefined): string {
+  return String(host || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+
+// ── Keys ──────────────────────────────────────────────────────────────
+
+export function deviceIdentityKey(d: CoreDevice): string {
+  if (d.hwid) return `hwid:${d.hwid}`;
+  if (d.publicKey) return `pub:${d.publicKey}`;
+  if (d.isGuest) {
+    const scope = d.hostEmail || d.hostName || 'guest';
+    return `guest:${scope}:${d.deviceId || d.name}`;
+  }
+  const n = normName(d.name);
+  const os = String(d.platform || '').trim().toLowerCase();
+  if (n && os) return `host:${os}:${n}`;
+  if (d.deviceId) return `id:${d.deviceId}`;
+  return `name:${d.name}`;
+}
+
+export function deviceAliasKey(d: CoreDevice): string | null {
+  if (d.isGuest) return null;
+  const n = normName(d.name);
+  const os = String(d.platform || '').trim().toLowerCase();
+  if (!n || !os) return null;
+  return `${os}:${n}`;
+}
+
+export function deviceEndpointKey(d: CoreDevice): string | null {
+  if (d.isGuest) return null;
+  const h = normHost(d.quicHost);
+  if (!h) return null;
+  return `${h}:${d.quicPort || 0}`;
+}
+
+// ── Merge rules ───────────────────────────────────────────────────────
+
+export function mergeDeviceEntries(a: CoreDevice, b: CoreDevice): CoreDevice {
+  const incomingWins =
+    (!!a.needsAuth && !b.needsAuth) ||
+    (b.lastHeartbeat || 0) > (a.lastHeartbeat || 0) ||
+    (!!b.isOnline && !a.isOnline);
+  const base = incomingWins ? b : a;
+  const other = incomingWins ? a : b;
+  return {
+    ...other,
+    ...base,
+    quicHost: base.quicHost || other.quicHost,
+    quicPort: base.quicPort || other.quicPort,
+    httpPort: base.httpPort || other.httpPort,
+    isOnline: base.isOnline || other.isOnline,
+    runnerDown: base.runnerDown && other.runnerDown,
+    publicKey: base.publicKey || other.publicKey,
+    hwid: base.hwid || other.hwid,
+    lastHeartbeat: Math.max(a.lastHeartbeat || 0, b.lastHeartbeat || 0),
+    localIps: (() => {
+      const set = new Set<string>();
+      for (const ip of a.localIps || []) if (ip) set.add(ip);
+      for (const ip of b.localIps || []) if (ip) set.add(ip);
+      return set.size > 0 ? [...set] : undefined;
+    })(),
+  };
+}
+
+// When two rows share the same alias (hostname + OS) but differ on
+// hwid / publicKey, prefer the authenticated + online row over a
+// stale "needsAuth + offline" leftover. That leftover pattern is
+// what re-pair / wipe-and-reinstall produces on Convex.
+function pickActiveOverStaleNeedsAuth(
+  a: CoreDevice,
+  b: CoreDevice,
+): CoreDevice | null {
+  const aDead = a.needsAuth && !a.isOnline;
+  const bDead = b.needsAuth && !b.isOnline;
+  const aLive = !a.needsAuth && a.isOnline;
+  const bLive = !b.needsAuth && b.isOnline;
+  if (aDead && bLive) return b;
+  if (bDead && aLive) return a;
+  return null;
+}
+
+// ── Collapse (three-pass dedup) ───────────────────────────────────────
+
+/**
+ * Collapse duplicate Convex rows so each physical machine appears
+ * exactly once. Three passes — identity key → alias key → endpoint key.
+ * Safe on empty lists; idempotent on already-deduped input.
+ */
+export function collapseDevices(devices: CoreDevice[]): CoreDevice[] {
+  if (!Array.isArray(devices) || devices.length === 0) return [];
+
+  // Pass 1: identity key (hwid / publicKey / name+os).
+  const byIdentity = new Map<string, CoreDevice>();
+  for (const d of devices) {
+    const k = deviceIdentityKey(d);
+    const prev = byIdentity.get(k);
+    byIdentity.set(k, prev ? mergeDeviceEntries(prev, d) : d);
+  }
+
+  // Pass 2: alias key (os + normalised hostname), with strong-identity
+  // conflict resolution so two genuinely-different machines sharing a
+  // hostname don't silently merge.
+  const byAlias = new Map<string, CoreDevice>();
+  for (const d of byIdentity.values()) {
+    const k = deviceAliasKey(d);
+    if (!k) {
+      byAlias.set(`id:${d.deviceId}`, d);
+      continue;
+    }
+    const prev = byAlias.get(k);
+    if (!prev) {
+      byAlias.set(k, d);
+      continue;
+    }
+    const strongConflict =
+      (!!prev.hwid && !!d.hwid && prev.hwid !== d.hwid) ||
+      (!!prev.publicKey && !!d.publicKey && prev.publicKey !== d.publicKey);
+    if (strongConflict) {
+      const winner = pickActiveOverStaleNeedsAuth(prev, d);
+      if (winner) {
+        byAlias.set(k, winner);
+        continue;
+      }
+    }
+    byAlias.set(k, mergeDeviceEntries(prev, d));
+  }
+
+  // Pass 3: endpoint key (host:port) — last-chance dedup for rows
+  // that share a LAN address but slipped through identity + alias.
+  const byEndpoint = new Map<string, CoreDevice>();
+  for (const d of byAlias.values()) {
+    const k = deviceEndpointKey(d);
+    if (!k) {
+      byEndpoint.set(`id:${d.deviceId}`, d);
+      continue;
+    }
+    const prev = byEndpoint.get(k);
+    byEndpoint.set(k, prev ? mergeDeviceEntries(prev, d) : d);
+  }
+
+  return [...byEndpoint.values()];
+}
+
+// ── Freshness + target pick ───────────────────────────────────────────
+
+/**
+ * "Fresh" matches the mobile app: online + heartbeat < 90 s. Clients
+ * read Convex's `isOnline` first (backend already applies its own 90 s
+ * gate from the server clock), then use this helper when they need the
+ * phone-side freshness opinion too — e.g. for auto-connect picks.
+ */
+export function isDeviceFresh(d: CoreDevice, now = Date.now()): boolean {
+  if (!d.isOnline) return false;
+  if (!d.lastHeartbeat) return true;
+  return now - d.lastHeartbeat < HEARTBEAT_STALE_MS;
+}
+
+/**
+ * Choose the best candidate for an auto-connect attempt. Preference:
+ *   1. explicit `preferredDeviceId` that's still fresh
+ *   2. fresh (online + recent heartbeat) + has a quicHost
+ *   3. online + has a quicHost
+ *   4. first with a quicHost
+ */
+export function pickTargetDevice(
+  devices: CoreDevice[],
+  preferredDeviceId?: string,
+): CoreDevice | null {
+  if (!devices.length) return null;
+  if (preferredDeviceId) {
+    const preferred = devices.find(
+      (d) => d.deviceId === preferredDeviceId && d.quicHost,
+    );
+    if (preferred && isDeviceFresh(preferred)) return preferred;
+    if (preferred) return preferred;
+  }
+  const fresh = devices.find((d) => isDeviceFresh(d) && d.quicHost);
+  if (fresh) return fresh;
+  const online = devices.find((d) => d.isOnline && d.quicHost);
+  if (online) return online;
+  return devices.find((d) => d.quicHost) || devices[0] || null;
+}
+
+// ── Probe candidate assembly ──────────────────────────────────────────
+
+/**
+ * Build the set of `/health` candidate URLs for a target device —
+ * `quicHost` plus every LAN IP the agent reported in `localIps`,
+ * uniqued and formatted. This is the thing that makes direct LAN
+ * reloads "just work" on multi-homed hosts (en0 + utun tailscale +
+ * docker0 etc.) — the mobile app races them in parallel via
+ * Promise.any.
+ */
+export function buildProbeCandidates(
+  target: CoreDevice,
+  defaultHttpPort = 18080,
+): string[] {
+  const port = target.httpPort ?? target.quicPort ?? defaultHttpPort;
+  const ips = new Set<string>();
+  if (target.quicHost) ips.add(target.quicHost);
+  for (const ip of target.localIps ?? []) {
+    if (ip) ips.add(ip);
+  }
+  return [...ips].map((ip) => `http://${ip}:${port}`);
+}
+
+// ── Parallel /health race (Promise.any polyfill baked in) ─────────────
+
+export interface ProbeResult {
+  url: string;
+  hostname?: string;
+  version?: string;
+  latency?: number;
+}
+
+/**
+ * Race `/health` probes across N URLs. First 200 wins; everything else
+ * is abandoned. Older Hermes doesn't have Promise.any, so we hand-roll
+ * the same semantic.
+ */
+export async function raceHealthProbes(
+  urls: string[],
+  opts: { timeoutMs?: number; headers?: Record<string, string> } = {},
+): Promise<ProbeResult | null> {
+  if (!urls || urls.length === 0) return null;
+  const timeoutMs = opts.timeoutMs ?? 2500;
+
+  const probeOne = async (url: string): Promise<ProbeResult | null> => {
+    const base = url.replace(/\/$/, '');
+    const start = Date.now();
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      const res = await fetch(`${base}/health`, {
+        method: 'GET',
+        headers: opts.headers,
+        signal: controller.signal,
+      });
+      clearTimeout(timer);
+      if (!res.ok) return null;
+      const latency = Date.now() - start;
+      let hostname: string | undefined;
+      let version: string | undefined;
+      try {
+        const data = await res.json();
+        hostname = data?.hostname ?? data?.name;
+        version = data?.version;
+      } catch {
+        // /health may return plain text
+      }
+      return { url: base, hostname, version, latency };
+    } catch {
+      return null;
+    }
+  };
+
+  return new Promise<ProbeResult | null>((resolve) => {
+    let remaining = urls.length;
+    let settled = false;
+    for (const url of urls) {
+      probeOne(url)
+        .then((r) => {
+          if (settled) return;
+          if (r) {
+            settled = true;
+            resolve(r);
+            return;
+          }
+          remaining -= 1;
+          if (remaining <= 0 && !settled) {
+            settled = true;
+            resolve(null);
+          }
+        })
+        .catch(() => {
+          remaining -= 1;
+          if (remaining <= 0 && !settled) {
+            settled = true;
+            resolve(null);
+          }
+        });
+    }
+  });
+}

package/src/_core/index.ts

@@ -17,3 +17,4 @@
 
 export * from './constants';
 export * from './endpoints';
+export * from './device';