yaver-feedback-react-native 0.9.2 → 0.9.3

package/dist/YaverFeedback.js

@@ -9,6 +9,8 @@ const ShakeDetector_1 = require("./ShakeDetector");
 const storeShots_1 = require("./storeShots");
 const auth_1 = require("./auth");
 const preferences_1 = require("./preferences");
+const dogfoodPolicy_1 = require("./dogfoodPolicy");
+const deviceDogfood_1 = require("./deviceDogfood");
 function unrefTimer(timer) {
     const maybeNodeTimer = timer;
     if (typeof maybeNodeTimer.unref === 'function') {
@@ -140,6 +142,7 @@ if (IS_HOST_MODE) {
 let config = null;
 let enabled = false;
 let p2pClient = null;
+let renderP2PClient = null;
 let shakeDetector = null;
 /** Unsubscribe for the BlackBox command handler registered by init(). Held so
  *  a re-init (or destroy) can drop the old one instead of stacking. */
@@ -151,6 +154,7 @@ let p2pRelayPassword = '';
 let autoStartTimer = null;
 let reportLaunchInFlight = false;
 let crashReportInFlight = false;
+let dogfoodOnboarding = null;
 /** Resolve the user's relay password by validating their auth token
  *  against Convex. Used whenever we (re)build the P2PClient so a
  *  relay-routed agentUrl carries a valid X-Relay-Password — without
@@ -218,40 +222,37 @@ const flagCache = new Map();
  */
 class YaverFeedback {
     static async resolveP2PAuthToken() {
-        if (!config?.authToken)
-            return null;
-        if (!config.preferredDeviceId)
-            return config.authToken;
-        const devices = await (0, auth_1.listReachableDevices)(config.authToken);
-        const all = [...devices.owned, ...devices.shared];
-        const selected = all.find((device) => device.deviceId === config?.preferredDeviceId);
-        if (!selected || !selected.isGuest || selected.accessScope !== 'shared-scoped') {
-            return config.authToken;
-        }
-        if (!selected.hostUserId) {
-            return config.authToken;
-        }
-        const delegated = await (0, auth_1.mintGuestSdkToken)(config.authToken, selected.hostUserId, selected.deviceId);
-        return delegated.token;
+        return config?.authToken ?? null;
     }
     static async rebuildP2PClient(agentUrl) {
-        if (!config)
+        const currentConfig = config;
+        if (!currentConfig)
             return;
-        const effectiveUrl = agentUrl ?? config.agentUrl;
+        const effectiveUrl = agentUrl ?? currentConfig.agentUrl;
         if (!effectiveUrl) {
             p2pClient = null;
+            renderP2PClient = null;
             p2pAuthToken = null;
             return;
         }
         const token = await YaverFeedback.resolveP2PAuthToken();
+        // reset() can clear config while relay-password resolution is awaiting.
+        // Do not resurrect a client from that stale init generation.
+        if (config !== currentConfig)
+            return;
         if (!token) {
             p2pClient = null;
+            renderP2PClient = null;
             p2pAuthToken = null;
             return;
         }
         p2pAuthToken = token;
         const rp = await resolveRelayPassword(token);
+        if (config !== currentConfig)
+            return;
         p2pClient = new P2PClient_1.P2PClient(effectiveUrl, token, rp);
+        const renderUrl = currentConfig.renderAgentUrl || effectiveUrl;
+        renderP2PClient = renderUrl === effectiveUrl ? p2pClient : new P2PClient_1.P2PClient(renderUrl, token, rp);
     }
     /**
      * Initialize the feedback SDK with the given configuration.
@@ -378,6 +379,9 @@ class YaverFeedback {
             maxRecordingDuration: 120,
             autoLogin: true,
             ...cfg,
+            agentUrl: cfg.codingAgentUrl || cfg.agentUrl,
+            codingDeviceId: cfg.codingDeviceId || cfg.preferredDeviceId,
+            renderDeviceId: cfg.renderDeviceId || cfg.codingDeviceId || cfg.preferredDeviceId,
         };
         if (IS_HOST_MODE) {
             // sfmg / talos / etc. running inside Yaver mobile (compile-time
@@ -451,12 +455,17 @@ class YaverFeedback {
             // is set, so set a placeholder header here that won't 401 a
             // direct-LAN url and will be overwritten before any relay hop.
             p2pClient = new P2PClient_1.P2PClient(config.agentUrl, config.authToken ?? '', p2pRelayPassword);
+            const renderUrl = config.renderAgentUrl || config.agentUrl;
+            renderP2PClient = renderUrl === config.agentUrl
+                ? p2pClient
+                : new P2PClient_1.P2PClient(renderUrl, config.authToken ?? '', p2pRelayPassword);
             if (config.authToken) {
                 void YaverFeedback.rebuildP2PClient(config.agentUrl);
             }
         }
         else {
             p2pClient = null;
+            renderP2PClient = null;
             // Auto-discover agent in the background when convexUrl or LAN is available
             if (enabled && (config.authToken || config.preferredDeviceId)) {
                 YaverFeedback.discoverAgent();
@@ -803,6 +812,25 @@ class YaverFeedback {
         const { DeviceEventEmitter } = require('react-native');
         DeviceEventEmitter.emit('yaverFeedback:startMachinePicker');
     }
+    /** Begin the reusable host-app Dogfood wizard. Owner OAuth and machine
+     * selection intentionally happen before installation enrollment/runtime
+     * controls because starting builds or runners is owner-level authority. */
+    static beginDogfoodOnboarding(options) {
+        dogfoodOnboarding = options;
+        if (!config)
+            YaverFeedback.init({ autoLogin: true });
+        if (!YaverFeedback.isAuthed()) {
+            YaverFeedback.showLogin();
+            return;
+        }
+        YaverFeedback.showMachinePicker();
+    }
+    static getDogfoodOnboarding() {
+        return dogfoodOnboarding;
+    }
+    static clearDogfoodOnboarding() {
+        dogfoodOnboarding = null;
+    }
     /**
      * Update the selected remote device. Resets the cached agent URL so the
      * next `startReport()` (or FloatingButton press) rediscovers against the
@@ -811,9 +839,19 @@ class YaverFeedback {
     static async setPreferredDevice(deviceId) {
         if (!config)
             return;
+        const wasUnified = !config.renderDeviceId
+            || config.renderDeviceId === config.codingDeviceId
+            || config.renderDeviceId === config.preferredDeviceId;
         config.preferredDeviceId = deviceId;
+        config.codingDeviceId = deviceId;
+        if (wasUnified)
+            config.renderDeviceId = deviceId;
         config.agentUrl = undefined;
+        config.codingAgentUrl = undefined;
+        if (wasUnified)
+            config.renderAgentUrl = undefined;
         p2pClient = null;
+        renderP2PClient = null;
         p2pAuthToken = null;
         await YaverFeedback.discoverAgent();
     }
@@ -823,8 +861,7 @@ class YaverFeedback {
             return null;
         const preferredDeviceId = config.preferredDeviceId;
         const devices = await (0, auth_1.listReachableDevices)(config.authToken);
-        const all = [...devices.owned, ...devices.shared];
-        return all.find((device) => device.deviceId === preferredDeviceId) ?? null;
+        return devices.owned.find((device) => device.deviceId === preferredDeviceId) ?? null;
     }
     /**
      * Trigger remote device-auth for a CLI runner on the selected agent
@@ -874,6 +911,7 @@ class YaverFeedback {
             config.agentUrl = undefined;
         }
         p2pClient = null;
+        renderP2PClient = null;
         p2pAuthToken = null;
     }
     /**
@@ -1119,6 +1157,61 @@ class YaverFeedback {
     static getConfig() {
         return config;
     }
+    /** Current third-party SDK mode. Fails closed unless enabled + account match. */
+    static getDogfoodStatus() {
+        return (0, dogfoodPolicy_1.resolveSDKDogfood)(config?.dogfood);
+    }
+    /** One-call, account-free Dogfood bootstrap for third-party apps. On first
+     * launch it creates/proves the installation key and returns pending; after
+     * owner approval the same call obtains a short-lived scoped Yaver session
+     * and enables Dogfood UX without the host app implementing OAuth. */
+    static async enableDeviceDogfood(options) {
+        const client = new deviceDogfood_1.YaverDeviceDogfood(options);
+        let status = await client.status();
+        if (status === 'unregistered' || status === 'pending' || status === 'cancelled' || status === 'revoked' || status === 'superseded') {
+            const enrolled = status === 'unregistered' || status === 'pending'
+                ? await client.enroll(react_native_1.Platform.OS)
+                : await client.reRegister(react_native_1.Platform.OS);
+            status = enrolled.status;
+        }
+        const info = await client.enrollmentInfo();
+        const session = status === 'active' ? await client.session() : null;
+        if (!config)
+            YaverFeedback.init({ autoLogin: false });
+        if (config) {
+            config.dogfood = {
+                enabled: status === 'active' && !!session,
+                appId: options.appId,
+                installationId: info.installationId,
+                installationStatus: status === 'active' && session ? 'active' : status === 'unregistered' ? 'pending' : status,
+                label: options.label,
+            };
+            // A normal Yaver OAuth session remains authoritative for the runtime
+            // wizard. Only account-free hosts adopt the narrow installation token.
+            if (session && !config.authToken)
+                await YaverFeedback.setAuthToken(session.token);
+        }
+        try {
+            const { DeviceEventEmitter } = require('react-native');
+            DeviceEventEmitter.emit('yaverFeedback:dogfoodChanged', { active: !!session, status });
+        }
+        catch { /* noop */ }
+        return { status, installationId: info.installationId, session };
+    }
+    /** Confirmed by the Y badge/UI before this is called. Reverts this SDK to
+     * normal Feedback mode for the remainder of the app run. */
+    static async exitDogfoodMode() {
+        const cfg = config?.dogfood;
+        if (!cfg)
+            return;
+        cfg.enabled = false;
+        await cfg.onExit?.();
+        try {
+            const { DeviceEventEmitter } = require('react-native');
+            DeviceEventEmitter.emit('yaverFeedback:dogfoodChanged', { active: false, exited: true });
+        }
+        catch { /* noop */ }
+    }
     /** Returns the resolved relay password the SDK is currently using.
      *  Empty string when no relay routing is in play (direct LAN agent
      *  URLs need no password). Callers attaching it to relay-routed
@@ -1286,6 +1379,16 @@ class YaverFeedback {
     static getP2PClient() {
         return p2pClient;
     }
+    /** Renderer/reload route; intentionally distinct from the coding client. */
+    static getRenderP2PClient() {
+        return renderP2PClient ?? p2pClient;
+    }
+    static getMachineRouting() {
+        return {
+            codingDeviceId: config?.codingDeviceId || config?.preferredDeviceId,
+            renderDeviceId: config?.renderDeviceId || config?.codingDeviceId || config?.preferredDeviceId,
+        };
+    }
     // ─── One-stop SaaS replacement methods ─────────────────────────
     //
     // These are the three solo-dev SaaS-replacement entry points
@@ -1396,6 +1499,7 @@ class YaverFeedback {
                     config.agentUrl = result.url;
                     const rp = await resolveRelayPassword(config.authToken ?? '');
                     p2pClient = new P2PClient_1.P2PClient(result.url, config.authToken ?? '', rp);
+                    renderP2PClient = p2pClient;
                 }
             }
             catch { }
@@ -1610,6 +1714,7 @@ class YaverFeedback {
         enabled = false;
         config = null;
         p2pClient = null;
+        renderP2PClient = null;
         errorBuffer = [];
     }
 }

package/dist/YaverModeBadge.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+/** Hide the mark for the rest of this run. Exposed on YaverFeedback so a host
+ *  can wire its own "hide" control, and used by the sheet's own button. */
+export declare function hideYaverModeBadge(): void;
+/** Bring it back — e.g. when a NEW guest bundle loads and the context changed. */
+export declare function showYaverModeBadge(): void;
+export declare function isYaverModeBadgeHidden(): boolean;
+export interface YaverModeBadgeProps {
+    /** Corner to sit in. Default bottom-left: bottom-right is where most apps
+     *  put a FAB, and the badge must never compete with the app's own action. */
+    position?: 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+    /** Render even outside Yaver. Development aid only — the badge is meaningless
+     *  in a standalone build and would be wallpaper. */
+    force?: boolean;
+    /** Account-scoped third-party Dogfood mode. Keeps the same Yaver Y mark but
+     * changes the explanation and offers a confirmed exit to normal Feedback. */
+    dogfood?: boolean;
+    dogfoodLabel?: string;
+    onExitDogfood?: () => void | Promise<void>;
+}
+export declare function YaverModeBadge({ position, force, dogfood, dogfoodLabel, onExitDogfood, }: YaverModeBadgeProps): React.JSX.Element | null;
+export default YaverModeBadge;

package/dist/YaverModeBadge.js

@@ -0,0 +1,219 @@
+"use strict";
+// YaverModeBadge.tsx — the polite "you're running inside Yaver" mark, for
+// THIRD-PARTY apps.
+//
+// ── Why a third-party app needs this ────────────────────────────────────────
+//
+// When your app is pushed into Yaver's container as a Hermes bundle, it looks
+// exactly like your installed build. Same icon, same launch, same everything —
+// except it is a development bundle from someone's branch. Testers have chased
+// "bugs" that were only unbuilt work, and have been unable to find their way
+// back to the real app because nothing on screen said there was anywhere to go.
+//
+// So the SDK shows one small Y, low contrast, in a corner. Tapping it says what
+// you're in and how to leave. Nothing else.
+//
+// ── Defaults, and why ───────────────────────────────────────────────────────
+//
+// DEFAULT ENABLED (`modeBadge: true`), because the failure it prevents is
+// silent and lands on a tester rather than the developer — exactly the class
+// that should not be opt-in. Turn it off with `modeBadge: false` when your app
+// has its own in-container indicator, or when a screenshot-perfect surface
+// genuinely cannot afford 22 points in a corner.
+//
+// ── What it is NOT ──────────────────────────────────────────────────────────
+//
+// It is NOT the escape. Yaver's container owns that: shake opens Yaver's own
+// overlay with "Back to Yaver". This badge only tells you the gesture exists.
+// Making it the exit would put the way out inside the previewed app, which is
+// the trap the container's escape-ownership rules exist to prevent — the guest
+// could style over it, or unmount it, and the tester would be stuck.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hideYaverModeBadge = hideYaverModeBadge;
+exports.showYaverModeBadge = showYaverModeBadge;
+exports.isYaverModeBadgeHidden = isYaverModeBadgeHidden;
+exports.YaverModeBadge = YaverModeBadge;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+/** True only inside Yaver's container: the YaverInfo native module is
+ *  registered by Yaver's app and by nothing else. Same probe ShakeDetector
+ *  and P2PClient use — one answer, not three. */
+function isInsideYaver() {
+    try {
+        return !!react_native_1.NativeModules?.YaverInfo;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Per-RUN dismissal, shared by every mounted badge.
+ *
+ * Deliberately in memory, not storage. A permanently hidden badge recreates
+ * exactly the problem the badge exists to prevent: a tester who cannot tell an
+ * unbuilt branch from the installed app, and cannot find the way back. Polite
+ * means not nagging within a session — it does not mean permanent amnesia
+ * about which build you are looking at. A relaunch is a new context.
+ *
+ * An APP that wants it gone for good passes `modeBadge: false` at init. That is
+ * a developer making an informed choice, which is a different thing from a
+ * tester clearing their screen for a minute.
+ */
+let hiddenThisRun = false;
+const hideListeners = new Set();
+/** Hide the mark for the rest of this run. Exposed on YaverFeedback so a host
+ *  can wire its own "hide" control, and used by the sheet's own button. */
+function hideYaverModeBadge() {
+    hiddenThisRun = true;
+    hideListeners.forEach((l) => {
+        try {
+            l();
+        }
+        catch {
+            /* one bad listener mustn't block the others */
+        }
+    });
+}
+/** Bring it back — e.g. when a NEW guest bundle loads and the context changed. */
+function showYaverModeBadge() {
+    hiddenThisRun = false;
+    hideListeners.forEach((l) => {
+        try {
+            l();
+        }
+        catch {
+            /* noop */
+        }
+    });
+}
+function isYaverModeBadgeHidden() {
+    return hiddenThisRun;
+}
+function YaverModeBadge({ position = 'bottom-left', force = false, dogfood = false, dogfoodLabel = 'Dogfood', onExitDogfood, }) {
+    const [open, setOpen] = (0, react_1.useState)(false);
+    const [, bump] = (0, react_1.useState)(0);
+    (0, react_1.useEffect)(() => {
+        const listener = () => bump((n) => n + 1);
+        hideListeners.add(listener);
+        return () => {
+            hideListeners.delete(listener);
+        };
+    }, []);
+    // Standalone builds render nothing at all — zero cost, zero pixels.
+    if (!force && !dogfood && !isInsideYaver())
+        return null;
+    if (hiddenThisRun)
+        return null;
+    const vertical = position.startsWith('top') ? { top: 44 } : { bottom: 28 };
+    const horizontal = position.endsWith('left') ? { left: 12 } : { right: 12 };
+    return (<>
+      <react_native_1.View 
+    // The wrapper never intercepts touches; only the 22pt mark does. A
+    // full-screen overlay that swallowed taps would break the app it is
+    // supposed to be politely annotating.
+    pointerEvents="box-none" style={{ position: 'absolute', ...vertical, ...horizontal, zIndex: 9998 }}>
+        <react_native_1.Pressable onPress={() => setOpen(true)} accessibilityRole="button" accessibilityLabel={dogfood ? `Exit ${dogfoodLabel} Dogfood mode` : 'Running inside Yaver'} hitSlop={10} style={({ pressed }) => ({
+            width: 22,
+            height: 22,
+            borderRadius: 11,
+            alignItems: 'center',
+            justifyContent: 'center',
+            borderWidth: 1,
+            borderColor: 'rgba(124,92,255,0.45)',
+            backgroundColor: 'rgba(124,92,255,0.14)',
+            opacity: pressed ? 0.6 : 0.9,
+        })}>
+          <react_native_1.Text style={{ color: '#7C5CFF', fontSize: 12, fontWeight: '700', lineHeight: 14 }}>Y</react_native_1.Text>
+        </react_native_1.Pressable>
+      </react_native_1.View>
+
+      <react_native_1.Modal visible={open} transparent animationType="fade" onRequestClose={() => setOpen(false)}>
+        <react_native_1.Pressable style={{ flex: 1, backgroundColor: '#0008' }} onPress={() => setOpen(false)}>
+          <react_native_1.Pressable onPress={(e) => e.stopPropagation()} style={{
+            margin: 24,
+            marginTop: 'auto',
+            marginBottom: 48,
+            borderRadius: 16,
+            padding: 18,
+            backgroundColor: '#151519',
+            borderWidth: 1,
+            borderColor: '#2a2a32',
+            gap: 10,
+        }}>
+            <react_native_1.View style={{ flexDirection: 'row', alignItems: 'center', gap: 8 }}>
+              <react_native_1.Text style={{ color: '#7C5CFF', fontSize: 15, fontWeight: '800' }}>Y</react_native_1.Text>
+              <react_native_1.Text style={{ color: '#fff', fontSize: 15, fontWeight: '700' }}>
+                {dogfood ? `${dogfoodLabel} Dogfood mode` : 'Running inside Yaver'}
+              </react_native_1.Text>
+            </react_native_1.View>
+            <react_native_1.Text style={{ color: '#b6b6c0', fontSize: 13, lineHeight: 19 }}>
+              {dogfood
+            ? 'This approved account is improving the app directly through Yaver. Tasks and re-render actions target this app instead of creating a feedback report.'
+            : 'This is a development build loaded into Yaver — not the version installed on this device. Anything unfinished here is work in progress, not a released bug.'}
+            </react_native_1.Text>
+            {dogfood ? (<react_native_1.Pressable onPress={() => react_native_1.Alert.alert('Exit Dogfood mode?', 'Return this SDK to normal Feedback mode. Your coding tasks and source changes are untouched.', [
+                { text: 'Keep Dogfooding', style: 'cancel' },
+                { text: 'Exit Dogfood', style: 'destructive', onPress: () => {
+                        void onExitDogfood?.();
+                        setOpen(false);
+                    } },
+            ])} style={{ paddingVertical: 10, alignItems: 'center' }}>
+                <react_native_1.Text style={{ color: '#fca5a5', fontSize: 13, fontWeight: '700' }}>Exit Dogfood mode</react_native_1.Text>
+              </react_native_1.Pressable>) : (<react_native_1.Text style={{ color: '#b6b6c0', fontSize: 13, lineHeight: 19 }}>
+                Shake the device to open Yaver's overlay, where "Back to Yaver" returns you to the installed app.
+              </react_native_1.Text>)}
+            {/* Polite means closeable. "for now", never "don't show again":
+            the badge returns next launch so nobody forgets which build
+            they're testing. */}
+            <react_native_1.Pressable onPress={() => {
+            hideYaverModeBadge();
+            setOpen(false);
+        }} style={{ paddingVertical: 10, alignItems: 'center' }}>
+              <react_native_1.Text style={{ color: '#8a8a96', fontSize: 13 }}>Hide for now</react_native_1.Text>
+            </react_native_1.Pressable>
+            <react_native_1.Text style={{ color: '#6b6b76', fontSize: 11, textAlign: 'center', lineHeight: 15 }}>
+              Hidden until you next launch this build.
+            </react_native_1.Text>
+
+            <react_native_1.Pressable onPress={() => setOpen(false)} style={{ paddingVertical: 10, alignItems: 'center' }}>
+              <react_native_1.Text style={{ color: '#8a8a96', fontSize: 13 }}>Close</react_native_1.Text>
+            </react_native_1.Pressable>
+          </react_native_1.Pressable>
+        </react_native_1.Pressable>
+      </react_native_1.Modal>
+    </>);
+}
+exports.default = YaverModeBadge;

package/dist/__tests__/AuthDevices.test.js

@@ -8,7 +8,7 @@ describe('auth device listing', () => {
         jest.clearAllMocks();
         mockFetch.mockReset();
     });
-    it('keeps guest-shared devices in the shared bucket', async () => {
+    it('returns the owner devices emitted by /devices/list', async () => {
         mockFetch.mockResolvedValue({
             ok: true,
             json: () => Promise.resolve({
@@ -18,24 +18,10 @@ describe('auth device listing', () => {
                         name: 'My Mac',
                         platform: 'macos',
                         isOnline: true,
-                        isGuest: false,
                         quicHost: '10.0.0.10',
                         quicPort: 18080,
                         lastHeartbeat: 123,
                     },
-                    {
-                        deviceId: 'guest-1',
-                        name: 'yaver-test-ephemeral',
-                        platform: 'linux',
-                        isOnline: true,
-                        isGuest: true,
-                        hostName: 'Host User',
-                        hostEmail: 'host@example.com',
-                        accessScope: 'shared-scoped',
-                        quicHost: '198.51.100.20',
-                        quicPort: 18080,
-                        lastHeartbeat: 456,
-                    },
                 ],
             }),
         });
@@ -44,39 +30,6 @@ describe('auth device listing', () => {
             headers: { Authorization: 'Bearer sdk-user-token' },
         }));
         expect(result.owned).toHaveLength(1);
-        expect(result.shared).toHaveLength(1);
         expect(result.owned[0].deviceId).toBe('own-1');
-        expect(result.shared[0]).toMatchObject({
-            deviceId: 'guest-1',
-            isGuest: true,
-            hostEmail: 'host@example.com',
-            accessScope: 'shared-scoped',
-        });
-    });
-    it('shows shared devices even when the guest owns no machines', async () => {
-        mockFetch.mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({
-                devices: [
-                    {
-                        deviceId: 'guest-only',
-                        name: 'yaver-test-ephemeral',
-                        platform: 'linux',
-                        isOnline: true,
-                        isGuest: true,
-                        hostName: 'Host User',
-                        hostEmail: 'host@example.com',
-                        accessScope: 'shared-scoped',
-                        quicHost: '198.51.100.20',
-                        quicPort: 18080,
-                        lastHeartbeat: 789,
-                    },
-                ],
-            }),
-        });
-        const result = await (0, auth_1.listReachableDevices)('guest-only-token');
-        expect(result.owned).toEqual([]);
-        expect(result.shared).toHaveLength(1);
-        expect(result.shared[0].deviceId).toBe('guest-only');
     });
 });

package/dist/__tests__/DogfoodRuntime.test.d.ts

@@ -0,0 +1 @@
+export {};