yaver-feedback-react-native 0.8.4 → 0.8.7

package/src/YaverFeedback.ts

@@ -51,6 +51,7 @@ let enabled = false;
 let p2pClient: P2PClient | null = null;
 let shakeDetector: ShakeDetector | null = null;
 let p2pAuthToken: string | null = null;
+let reportLaunchInFlight = false;
 
 /** Ring buffer of captured errors. */
 let errorBuffer: CapturedError[] = [];
@@ -420,6 +421,37 @@ export class YaverFeedback {
     return all.find((device) => device.deviceId === preferredDeviceId) ?? null;
   }
 
+  /**
+   * Trigger remote device-auth for a CLI runner on the selected agent
+   * (codex login --device-auth / claude auth login --console). Returns
+   * the session so the host UI can render the verification URL + code.
+   *
+   * RN UI layer owns the modal (see FeedbackModal's runner sign-in
+   * buttons). This method just proxies into P2PClient — no browser
+   * launch, no API keys, works through the relay with an SDK token
+   * that carries the runner-auth scope.
+   */
+  static async startRunnerBrowserAuth(
+    runner: string,
+  ): Promise<import('./types').RunnerBrowserAuthSession> {
+    if (!p2pClient) {
+      throw new Error('Not connected to any agent. Select a machine first.');
+    }
+    return p2pClient.startRunnerBrowserAuth(runner);
+  }
+
+  static async getRunnerBrowserAuthStatus(
+    sessionId: string,
+  ): Promise<import('./types').RunnerBrowserAuthSession> {
+    if (!p2pClient) throw new Error('Not connected to any agent.');
+    return p2pClient.getRunnerBrowserAuthStatus(sessionId);
+  }
+
+  static async cancelRunnerBrowserAuth(sessionId: string): Promise<void> {
+    if (!p2pClient) return;
+    await p2pClient.cancelRunnerBrowserAuth(sessionId);
+  }
+
   /**
    * Sign out: clear cached token + device, tear down the P2P client. The
    * SDK stays enabled; the next feedback trigger will re-prompt for login.
@@ -450,47 +482,64 @@ export class YaverFeedback {
     if (!enabled) {
       return;
     }
+    if (reportLaunchInFlight) {
+      return;
+    }
 
-    // If the caller has autoLogin enabled and we have no session yet, show
-    // the in-SDK login flow instead of a failing discovery + warning spam.
-    if (!config.authToken) {
-      if (config.autoLogin !== false) {
-        await YaverFeedback.hydrateSession();
-      }
+    reportLaunchInFlight = true;
+    const { DeviceEventEmitter } = require('react-native');
+    DeviceEventEmitter.emit('yaverFeedback:reportLaunch', {
+      state: 'starting',
+      at: Date.now(),
+    });
+    try {
+
+      // If the caller has autoLogin enabled and we have no session yet, show
+      // the in-SDK login flow instead of a failing discovery + warning spam.
       if (!config.authToken) {
-        YaverFeedback.showLogin();
-        return;
+        if (config.autoLogin !== false) {
+          await YaverFeedback.hydrateSession();
+        }
+        if (!config.authToken) {
+          YaverFeedback.showLogin();
+          return;
+        }
       }
-    }
 
-    // Auto-discover if no agent URL was provided
-    if (!config.agentUrl) {
-      try {
-        const result = await YaverDiscovery.discover({
-          convexUrl: config.convexUrl,
-          authToken: config.authToken,
-          preferredDeviceId: config.preferredDeviceId,
-        });
-        if (result) {
-          config.agentUrl = result.url;
-          await YaverFeedback.rebuildP2PClient(result.url);
-        } else if (config.autoLogin !== false && !config.preferredDeviceId) {
-          // No agent discovered and no device picked yet — prompt the user
-          // to pick one of their machines (handles the non-LAN case where
-          // relay discovery requires knowing which deviceId to target).
-          YaverFeedback.showMachinePicker();
-          return;
-        } else {
-          console.warn('[YaverFeedback] No agent found. Check that `yaver serve` is running on the selected machine.');
+      // Auto-discover if no agent URL was provided
+      if (!config.agentUrl) {
+        try {
+          const result = await YaverDiscovery.discover({
+            convexUrl: config.convexUrl,
+            authToken: config.authToken,
+            preferredDeviceId: config.preferredDeviceId,
+          });
+          if (result) {
+            config.agentUrl = result.url;
+            await YaverFeedback.rebuildP2PClient(result.url);
+          } else if (config.autoLogin !== false && !config.preferredDeviceId) {
+            // No agent discovered and no device picked yet — prompt the user
+            // to pick one of their machines (handles the non-LAN case where
+            // relay discovery requires knowing which deviceId to target).
+            YaverFeedback.showMachinePicker();
+            return;
+          } else {
+            console.warn('[YaverFeedback] No agent found. Check that `yaver serve` is running on the selected machine.');
+          }
+        } catch (err) {
+          console.warn('[YaverFeedback] Auto-discovery failed:', err);
         }
-      } catch (err) {
-        console.warn('[YaverFeedback] Auto-discovery failed:', err);
       }
-    }
 
-    // Emit event that the FeedbackModal listens for
-    const { DeviceEventEmitter } = require('react-native');
-    DeviceEventEmitter.emit('yaverFeedback:startReport');
+      // Emit event that the FeedbackModal listens for
+      DeviceEventEmitter.emit('yaverFeedback:startReport');
+    } finally {
+      reportLaunchInFlight = false;
+      DeviceEventEmitter.emit('yaverFeedback:reportLaunch', {
+        state: 'settled',
+        at: Date.now(),
+      });
+    }
   }
 
   /** Returns true if the SDK has been initialized. */

package/src/__tests__/AuthDevices.test.ts

@@ -0,0 +1,93 @@
+import { listReachableDevices } from '../auth';
+
+const mockFetch = jest.fn();
+global.fetch = mockFetch as any;
+
+describe('auth device listing', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockFetch.mockReset();
+  });
+
+  it('keeps guest-shared devices in the shared bucket', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          devices: [
+            {
+              deviceId: 'own-1',
+              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: 'Kivanc Cakmak',
+              hostEmail: 'kivanc.cakmak@icloud.com',
+              accessScope: 'shared-scoped',
+              quicHost: '157.180.114.179',
+              quicPort: 18080,
+              lastHeartbeat: 456,
+            },
+          ],
+        }),
+    });
+
+    const result = await listReachableDevices('sdk-user-token');
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      expect.stringContaining('/devices/list'),
+      expect.objectContaining({
+        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: 'kivanc.cakmak@icloud.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: 'Kivanc Cakmak',
+              hostEmail: 'kivanc.cakmak@icloud.com',
+              accessScope: 'shared-scoped',
+              quicHost: '157.180.114.179',
+              quicPort: 18080,
+              lastHeartbeat: 789,
+            },
+          ],
+        }),
+    });
+
+    const result = await listReachableDevices('guest-only-token');
+
+    expect(result.owned).toEqual([]);
+    expect(result.shared).toHaveLength(1);
+    expect(result.shared[0].deviceId).toBe('guest-only');
+  });
+});

package/src/types.ts

@@ -1,3 +1,84 @@
+/**
+ * Remote browser-style sign-in session for a coding-agent CLI on the
+ * connected yaver host. Mirrors runnerBrowserAuthSession on the agent
+ * Go side. Progression: starting → awaiting_browser (openUrl + code
+ * filled) → completed | failed | cancelled.
+ */
+export interface RunnerBrowserAuthSession {
+  id: string;
+  runner: string;
+  method: string;
+  status: 'starting' | 'awaiting_browser' | 'completed' | 'failed' | 'cancelled';
+  openUrl?: string;
+  code?: string;
+  detail?: string;
+  authConfigured?: boolean;
+  authSource?: string;
+  error?: string;
+  startedAt: number;
+  updatedAt: number;
+  completedAt?: number;
+}
+
+export interface IncidentEvent {
+  id: string;
+  timestamp: number;
+  severity: 'info' | 'warn' | 'error' | 'fatal';
+  category: string;
+  code: string;
+  source: string;
+  title: string;
+  userMessage: string;
+  technicalInfo?: string;
+  suggestedAction?: string;
+  operationId?: string;
+  deviceId?: string;
+  projectPath?: string;
+  target?: string;
+  logsAvailable: boolean;
+  logRefs?: string[];
+  correlationId?: string;
+  recoverable: boolean;
+  metadata?: Record<string, unknown>;
+  resolved?: boolean;
+}
+
+export interface OperationState {
+  id: string;
+  kind: string;
+  status: string;
+  phase?: string;
+  message?: string;
+  progress?: number;
+  deviceId?: string;
+  projectPath?: string;
+  startedAt: number;
+  updatedAt: number;
+  incidentIds?: string[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface CapabilityTargetReadiness {
+  enabled: boolean;
+  reasonCode?: string;
+  reason?: string;
+  suggestedAction?: string;
+  notes?: string[];
+}
+
+export interface CapabilitySnapshot {
+  generatedAt: string;
+  machine?: Record<string, unknown>;
+  infra?: Record<string, unknown>;
+  connectivity?: {
+    directAvailable?: boolean;
+    relayConfigured?: boolean;
+    tunnelConfigured?: boolean;
+    tailscaleAvailable?: boolean;
+  };
+  targets: Record<string, CapabilityTargetReadiness>;
+}
+
 export interface FeedbackConfig {
   /** URL of the Yaver agent (e.g. "http://192.168.1.10:18080"). If omitted, auto-discovery is used. */
   agentUrl?: string;