yaver-feedback-react-native 0.9.0 → 0.9.3

package/dist/storeShots.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * On-device App Store screenshot capture (Engine 2).
+ *
+ * The desktop `yaver shots` flow drives a simulator with Maestro. This is
+ * the in-app counterpart: the SDK, living inside the real running app,
+ * walks the app's own routes and screenshots each one with
+ * `react-native-view-shot`, then uploads the frames to the Yaver agent
+ * (POST /shots/upload). The agent normalizes them and runs the same App
+ * Store Connect backend (upload → metadata → submit).
+ *
+ * Why this exists alongside the simulator path: it captures *real device*
+ * pixels, knows the exact route map (no heuristics), and the user is
+ * already authenticated — so it sidesteps the i18n / no-testID fragility
+ * that makes a blind simulator walk hard.
+ *
+ * The host wires it once by handing us a navigation ref (react-navigation
+ * or expo-router router) plus the ordered list of routes to visit.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureStoreScreenshots = captureStoreScreenshots;
+const capture_1 = require("./capture");
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function navigateTo(navRef, route) {
+    if (!navRef)
+        return;
+    // react-navigation ref
+    if (typeof navRef.navigate === 'function') {
+        navRef.navigate(route);
+        return;
+    }
+    // expo-router router
+    if (typeof navRef.push === 'function') {
+        navRef.push(route);
+        return;
+    }
+    if (navRef.current && typeof navRef.current.navigate === 'function') {
+        navRef.current.navigate(route);
+        return;
+    }
+}
+function shotName(route, index, override) {
+    if (override)
+        return override;
+    const clean = route
+        .replace(/^\/+/, '')
+        .replace(/[()[\]/]+/g, '_')
+        .replace(/[^a-zA-Z0-9_]+/g, '')
+        .replace(/^_+|_+$/g, '');
+    const n = String(index + 1).padStart(2, '0');
+    return `${n}_${clean || 'screen'}`;
+}
+/**
+ * Walk the app's routes, screenshot each, and upload the batch to the
+ * agent. Returns a summary; never throws for a single missed route —
+ * it captures what it can and reports the count.
+ */
+async function captureStoreScreenshots(opts) {
+    if (!opts.agentUrl || !opts.authToken) {
+        return { ok: false, captured: 0, uploaded: 0, message: 'agentUrl + authToken required' };
+    }
+    if (!opts.routes?.length) {
+        return { ok: false, captured: 0, uploaded: 0, message: 'no routes to capture' };
+    }
+    const settleMs = opts.settleMs ?? 900;
+    const frames = [];
+    for (let i = 0; i < opts.routes.length; i++) {
+        const route = opts.routes[i];
+        try {
+            navigateTo(opts.navigationRef, route);
+            await sleep(settleMs);
+            if (opts.onBeforeCapture)
+                await opts.onBeforeCapture(route, i);
+            const shot = await (0, capture_1.captureScreenshotBase64)();
+            if (shot?.base64) {
+                frames.push({
+                    route: shotName(route, i, opts.screens?.[i]),
+                    base64: shot.base64,
+                    mimeType: shot.mimeType,
+                });
+            }
+        }
+        catch {
+            // Skip a route that failed to render — keep walking.
+        }
+    }
+    if (frames.length === 0) {
+        return { ok: false, captured: 0, uploaded: 0, message: 'captured no frames' };
+    }
+    const headers = {
+        Authorization: `Bearer ${opts.authToken}`,
+        'Content-Type': 'application/json',
+    };
+    if (opts.relayPassword)
+        headers['X-Relay-Password'] = opts.relayPassword;
+    const base = opts.agentUrl.replace(/\/$/, '');
+    try {
+        const resp = await fetch(`${base}/shots/upload`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                app: opts.app,
+                bundleId: opts.bundleId ?? '',
+                locale: opts.locale ?? 'en-US',
+                submit: !!opts.submit,
+                frames,
+            }),
+        });
+        const j = await resp.json().catch(() => ({}));
+        if (!resp.ok || j?.ok === false) {
+            return {
+                ok: false,
+                captured: frames.length,
+                uploaded: 0,
+                message: j?.error || `agent /shots/upload HTTP ${resp.status}`,
+            };
+        }
+        return {
+            ok: true,
+            captured: frames.length,
+            uploaded: typeof j?.uploaded === 'number' ? j.uploaded : frames.length,
+            submitted: j?.submitted,
+            staged: j?.staged,
+            message: j?.message,
+        };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            captured: frames.length,
+            uploaded: 0,
+            message: `upload failed: ${e?.message ?? 'network error'}`,
+        };
+    }
+}

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import type { BlackBoxConfig } from './BlackBox';
+import type { SDKDogfoodConfig } from './dogfoodPolicy';
 /**
  * Remote browser-style sign-in session for a coding-agent CLI on the
  * connected yaver host. Mirrors runnerBrowserAuthSession on the agent
@@ -31,6 +33,13 @@ export interface RunnerAuthStatusRow {
     path?: string;
     detail?: string;
     version?: string;
+    isDefault?: boolean;
+    models?: Array<{
+        id: string;
+        name?: string;
+        provider?: string;
+        isDefault?: boolean;
+    }>;
 }
 export interface OpenCodeProviderSummary {
     id: string;
@@ -121,9 +130,66 @@ export interface CapabilitySnapshot {
     };
     targets: Record<string, CapabilityTargetReadiness>;
 }
+/**
+ * Opt-in config for the overlay's "App Store screenshots" action and the
+ * `capture_store_shots` remote command. When set, the SDK can walk the
+ * app's routes on-device, screenshot each, and upload them to the agent
+ * (which runs the App Store Connect backend).
+ */
+export interface StoreShotsConfig {
+    /** Ordered routes to visit + screenshot (e.g. ['/(tabs)/home', ...]). */
+    routes: string[];
+    /** Navigation handle: a react-navigation ref or expo-router `router`. */
+    navigationRef?: any;
+    /** Also set metadata + attempt submit-for-review after upload. */
+    submit?: boolean;
+    /** Optional per-route screenshot names (defaults to NN_<route>). */
+    screens?: string[];
+}
 export interface FeedbackConfig {
     /** URL of the Yaver agent (e.g. "http://192.168.1.10:18080"). If omitted, auto-discovery is used. */
     agentUrl?: string;
+    /** Optional coding route. Defaults to agentUrl. */
+    codingAgentUrl?: string;
+    /** Optional render/reload route. Defaults to codingAgentUrl/agentUrl. */
+    renderAgentUrl?: string;
+    /** Device identities shown in the unified Settings card when routes differ. */
+    codingDeviceId?: string;
+    renderDeviceId?: string;
+    /**
+     * Show the small "Y" mark while this app is running INSIDE Yaver's container
+     * (a Hermes-pushed development bundle), so a tester can tell it apart from
+     * the build they installed — and can find the way back.
+     *
+     * DEFAULT TRUE. The failure it prevents is silent and lands on a tester
+     * rather than a developer: an app that looks installed but is someone's
+     * branch produces "bug reports" against unfinished work, and a tester with
+     * no visible way out is simply stuck. That class should not be opt-in.
+     *
+     * Costs nothing in a standalone build — outside Yaver's container the badge
+     * renders null (the YaverInfo native module is absent), so shipping with it
+     * enabled has no effect on what your users see.
+     *
+     * Set false if your app already shows its own in-container indicator, or if
+     * a pixel-exact surface cannot spare 22 points in a corner.
+     */
+    modeBadge?: boolean;
+    /** Corner for the mode badge. Default 'bottom-left' — bottom-right is where
+     *  most apps put a FAB, and the badge must never compete with the app's own
+     *  primary action. */
+    modeBadgePosition?: 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+    /** Account-scoped direct Dogfood UX for an approved third-party app.
+     * When the current app account is allowlisted, the small Y opens Vibing
+     * directly instead of the normal feedback actions. This is a client UX gate,
+     * never an authentication mechanism; agent calls still require Yaver auth. */
+    dogfood?: SDKDogfoodConfig;
+    /**
+     * Enables the overlay's "App Store screenshots" action + the
+     * `capture_store_shots` remote command. The host supplies the route
+     * list (and a navigation ref) once; the SDK captures the real running
+     * app — no simulator needed.
+     */
+    storeShots?: StoreShotsConfig;
     /**
      * Auth token for the Yaver agent. Optional in 0.5+: if omitted, the SDK
      * will hydrate one from AsyncStorage or show its in-app login screen
@@ -163,6 +229,47 @@ export interface FeedbackConfig {
      * If omitted with convexUrl, connects to the first online device.
      */
     preferredDeviceId?: string;
+    /**
+     * Identity of the app this SDK instance reports for. Both fields are
+     * resolved automatically from expo-constants / native modules when
+     * omitted, so most apps never set them.
+     *
+     * Set them when the ambient answer would be wrong — above all when the
+     * app's JS is pushed into Yaver's container as a Hermes guest. There the
+     * runtime IS Yaver: `expo-constants` and `SettingsManager` describe the
+     * host (`Yaver` / `io.yaver.mobile`), not the guest, so auto-resolution
+     * would file every report against Yaver's own repo and the fix task would
+     * edit the SDK instead of the app. Declaring identity here is the only
+     * answer that holds in both a standalone build and a guest bundle.
+     *
+     * `bundleId` is the key that actually routes: the agent matches it against
+     * each project's pbxproj / build.gradle / app.json. `projectName` is a
+     * fallback for platforms with no bundle id.
+     */
+    projectName?: string;
+    bundleId?: string;
+    /** Primary Yaver product surface for this app/package. */
+    surface?: YaverSurface;
+    /** All product surfaces this app/package owns. */
+    surfaces?: YaverSurface[];
+    /** Canonical development stack labels, e.g. react-native-expo, yaver-xml. */
+    stack?: string;
+    stacks?: string[];
+    /** Yaver preview/runtime targets that can exercise this app. */
+    testSurfaces?: string[];
+    feedbackSdk?: string;
+    feedbackTransport?: string;
+    voiceCapabilities?: string[];
+    sttProvider?: string;
+    ttsProvider?: string;
+    /**
+     * Opt in to the microphone/STT controls in the feedback Vibing card.
+     *
+     * This is deliberately false unless explicitly enabled: ordinary phone
+     * and tablet surfaces stay keyboard-first. Car/watch-style hosts that are
+     * inherently voice-driven may set this to true.
+     */
+    voiceInputEnabled?: boolean;
     /** How feedback collection is triggered */
     trigger?: 'shake' | 'floating-button' | 'manual';
     /**
@@ -203,6 +310,22 @@ export interface FeedbackConfig {
      * Calling `BlackBox.start()` manually is still safe — it's idempotent.
      */
     autoStartBlackBox?: boolean;
+    /**
+     * Config handed to BlackBox when the SDK auto-starts it.
+     *
+     * Without this there was no way to configure the flight recorder at all.
+     * The obvious move — and the one the README's own snippet makes — is:
+     *
+     *     YaverFeedback.init({ trigger: 'shake' });
+     *     BlackBox.start({ appName: 'my-app' });
+     *
+     * but that start() early-returns, because a zero-config init has no
+     * agentUrl yet (discovery resolves it asynchronously). The auto-start then
+     * fires ~500ms later once the agent and token exist and calls `start()`
+     * with NO arguments — so the host's config is silently dropped and appName
+     * is ''. Pass it here instead and the auto-start will honour it.
+     */
+    blackBox?: BlackBoxConfig;
     /**
      * Small tap-to-open icon that floats above the app so the user
      * doesn't have to shake every time they want to open feedback.
@@ -291,6 +414,26 @@ export interface FeedbackConfig {
      * Bugsnag, or any other error tracking tool.
      */
     maxCapturedErrors?: number;
+    /**
+     * Crash-aware reporting/fixing. Defaults to disabled.
+     *
+     * - enabled: records fatal errors into the SDK error buffer and enables
+     *   explicit `YaverFeedback.reportCrash(error)`.
+     * - installGlobalHandler: opt-in only. Wraps React Native's global ErrorUtils
+     *   handler without suppressing the existing handler. Leave false when Sentry,
+     *   Crashlytics, Bugsnag, or another crash tool owns the global handler.
+     * - autoFix: after uploading a crash report, ask the connected Yaver agent to
+     *   create a fix task. The normal BlackBox command stream can then deliver a
+     *   reload/reload_bundle command after the agent rebuilds.
+     * - captureScreenshot: attach a best-effort screenshot to the crash report.
+     */
+    crashReporting?: {
+        enabled?: boolean;
+        installGlobalHandler?: boolean;
+        autoFix?: boolean;
+        captureScreenshot?: boolean;
+        metadata?: Record<string, unknown>;
+    };
     /**
      * Which platforms the Build button targets.
      * - 'ios' — build iOS only
@@ -370,13 +513,6 @@ export interface FeedbackConfig {
      * Default: false (preserve historical behavior).
      */
     strictNativeAuth?: boolean;
-    /**
-     * Optional host invite code to prefill into the in-SDK guest onboarding
-     * flow. Useful when your app receives the code from a deep link, QR flow,
-     * or an out-of-band host handoff and you want the user to redeem it
-     * without typing.
-     */
-    guestInviteCode?: string;
 }
 export interface FeedbackBundle {
     metadata: FeedbackMetadata;
@@ -403,9 +539,36 @@ export interface CapturedError {
 }
 export interface FeedbackMetadata {
     timestamp: string;
-    device: DeviceInfo;
+    /**
+     * Wire key is `deviceInfo`, matching the Flutter + web SDKs and the
+     * agent's `FeedbackReport.DeviceInfo` (`json:"deviceInfo"`). This was
+     * `device` until 0.9.2 — a key the agent never read, so the whole block
+     * (platform, model, and the app name the fix router needs) was silently
+     * dropped on every React Native report. The agent still accepts the old
+     * key so builds already in the field keep working.
+     */
+    deviceInfo: DeviceInfo;
     app: AppInfo;
+    /**
+     * Which of the host's projects this report is about. The agent resolves
+     * a feedback→fix task's working directory from this; without it the task
+     * falls back to whatever directory the agent happens to be sitting in.
+     * Populated automatically by `resolveReportIdentity()`.
+     */
+    project?: FeedbackProjectRef;
     userNote?: string;
+    reportKind?: 'feedback' | 'auto-report' | 'crash';
+    crash?: {
+        message: string;
+        isFatal: boolean;
+        source: 'manual' | 'global-handler';
+        autoFixRequested?: boolean;
+    };
+    twin?: {
+        sessionId?: string;
+        surface?: string;
+        artifactDir?: string;
+    };
 }
 export interface DeviceInfo {
     platform: string;
@@ -413,12 +576,49 @@ export interface DeviceInfo {
     model: string;
     screenWidth: number;
     screenHeight: number;
+    /** Host app name. First key the agent's fix router checks. */
+    appName?: string;
 }
 export interface AppInfo {
     bundleId?: string;
     version?: string;
     buildNumber?: string;
 }
+/**
+ * Identifies the host project a report belongs to. Mirrors the web SDK's
+ * `FeedbackProjectRef` and the agent's `FeedbackProject`.
+ */
+export interface FeedbackProjectRef {
+    appName?: string;
+    projectName?: string;
+    /**
+     * Bundle identifier / applicationId. The only unambiguous key: an app's
+     * display name ("Talos") does not match the agent's registry name for it
+     * ("talos / mobile"), and one repo can hold several mobile projects that
+     * all share a name prefix. The agent matches this against the project's
+     * pbxproj, build.gradle, and app.json.
+     */
+    bundleId?: string;
+    /**
+     * Deliberately never set by this SDK. The agent ignores client-supplied
+     * paths for feedback reports (an untrusted guest could otherwise point the
+     * fix task's CWD at ~/.ssh) and resolves the path server-side. Present only
+     * so the type matches the wire format the agent parses.
+     */
+    projectPath?: string;
+    surface?: YaverSurface;
+    surfaces?: YaverSurface[];
+    stack?: string;
+    stacks?: string[];
+    testSurfaces?: string[];
+    feedbackSdk?: string;
+    feedbackTransport?: string;
+    voiceCapabilities?: string[];
+    sttProvider?: string;
+    ttsProvider?: string;
+    releaseChannel?: 'production' | 'candidate' | 'development';
+}
+export type YaverSurface = 'web' | 'mobile' | 'backend' | 'watch' | 'tv' | 'car' | 'vision' | 'desktop' | 'cli';
 export interface TimelineEvent {
     type: 'screenshot' | 'audio' | 'video';
     path: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "yaver-feedback-react-native",
-  "version": "0.9.0",
-  "description": "Visual feedback SDK for Yaver \u2014 bug reports, screen recording, voice vibe coding, and local-first developer workflows",
+  "version": "0.9.3",
+  "description": "Visual feedback SDK for Yaver — bug reports, screen recording, voice vibe coding, and local-first developer workflows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -28,10 +28,13 @@
     "react-native-record-screen": ">=0.0.10",
     "expo-av": ">=14.0.0",
     "expo-file-system": ">=16.0.0",
-    "expo-speech": ">=12.0.0"
+    "expo-speech": ">=12.0.0",
+    "expo-secure-store": ">=13.0.0",
+    "expo-crypto": ">=13.0.0"
   },
   "dependencies": {
-    "buffer": "^6.0.3"
+    "buffer": "^6.0.3",
+    "tweetnacl": "^1.0.3"
   },
   "peerDependenciesMeta": {
     "expo-file-system": {
@@ -40,6 +43,12 @@
     "expo-speech": {
       "optional": true
     },
+    "expo-secure-store": {
+      "optional": true
+    },
+    "expo-crypto": {
+      "optional": true
+    },
     "@expo/config-plugins": {
       "optional": true
     },

package/src/AuthOverlay.tsx

@@ -2,83 +2,50 @@ import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { DeviceEventEmitter, Modal } from 'react-native';
 import { YaverLoginScreen } from './LoginScreen';
 import { YaverMachinePickerScreen } from './MachinePickerScreen';
-import { YaverGuestOnboardingScreen } from './GuestOnboardingScreen';
 import { YaverFeedback } from './YaverFeedback';
-import { getToken, RemoteDevice, listReachableDevices } from './auth';
+import { getToken, RemoteDevice } from './auth';
 
-/**
- * Presentation layer for the SDK's auth + machine-picker modals.
- *
- * Mounts automatically inside `<FeedbackModal />`, so consumers of the SDK
- * get in-app login with no extra wiring. It listens for events emitted by
- * `YaverFeedback.showLogin()` / `showMachinePicker()`:
- *
- *   yaverFeedback:startLogin          → show login modal
- *   yaverFeedback:startMachinePicker  → show machine picker
- *
- * The overlay closes itself once login/pick succeeds, then re-emits
- * `yaverFeedback:startReport` so the user continues straight into the
- * feedback flow they originally triggered.
- */
+/** Owner sign-in and owner-machine selection for the Feedback SDK. */
 export const AuthOverlay: React.FC = () => {
   const [loginVisible, setLoginVisible] = useState(false);
-  const [guestVisible, setGuestVisible] = useState(false);
   const [pickerVisible, setPickerVisible] = useState(false);
   const [token, setToken] = useState<string | null>(null);
-  const [pendingInviteCode, setPendingInviteCode] = useState<string | null>(null);
-  const activeOverlayRef = useRef<'none' | 'login' | 'guest' | 'picker'>('none');
+  const activeOverlayRef = useRef<'none' | 'login' | 'picker'>('none');
 
   const openLogin = useCallback(() => {
     activeOverlayRef.current = 'login';
-    setGuestVisible(false);
     setPickerVisible(false);
     setLoginVisible(true);
   }, []);
 
-  const openGuest = useCallback(() => {
-    activeOverlayRef.current = 'guest';
-    setLoginVisible(false);
-    setPickerVisible(false);
-    setGuestVisible(true);
-  }, []);
-
   const openPicker = useCallback(() => {
     activeOverlayRef.current = 'picker';
     setLoginVisible(false);
-    setGuestVisible(false);
     setPickerVisible(true);
   }, []);
 
   const closeAll = useCallback(() => {
     activeOverlayRef.current = 'none';
     setLoginVisible(false);
-    setGuestVisible(false);
     setPickerVisible(false);
   }, []);
 
   useEffect(() => {
     let mounted = true;
-    (async () => {
-      const cached = await getToken();
+    void getToken().then((cached) => {
       if (mounted && cached) setToken(cached);
-    })();
-
-    const loginSub = DeviceEventEmitter.addListener(
-      'yaverFeedback:startLogin',
-      () => {
-        if (activeOverlayRef.current !== 'none') return;
-        openLogin();
-      },
-    );
-    const pickerSub = DeviceEventEmitter.addListener(
-      'yaverFeedback:startMachinePicker',
-      async () => {
-        if (activeOverlayRef.current !== 'none') return;
-        const cached = await getToken();
-        if (cached) setToken(cached);
-        if (cached) openPicker();
-      },
-    );
+    });
+    const loginSub = DeviceEventEmitter.addListener('yaverFeedback:startLogin', () => {
+      if (activeOverlayRef.current === 'none') openLogin();
+    });
+    const pickerSub = DeviceEventEmitter.addListener('yaverFeedback:startMachinePicker', async () => {
+      if (activeOverlayRef.current !== 'none') return;
+      const cached = await getToken();
+      if (cached) {
+        setToken(cached);
+        openPicker();
+      }
+    });
     return () => {
       mounted = false;
       loginSub.remove();
@@ -86,55 +53,24 @@ export const AuthOverlay: React.FC = () => {
     };
   }, [openLogin, openPicker]);
 
-  const continueAfterAuth = async (newToken: string, inviteCode?: string) => {
+  const handleLoggedIn = async (newToken: string) => {
     setToken(newToken);
     await YaverFeedback.setAuthToken(newToken);
-    const devices = await listReachableDevices(newToken).catch(() => ({ owned: [], shared: [] }));
-    const cleanedInviteCode = (inviteCode ?? '').trim().toUpperCase();
-    if (cleanedInviteCode) {
-      setPendingInviteCode(cleanedInviteCode);
-      openGuest();
-      return;
-    }
-    if (devices.owned.length === 0 && devices.shared.length === 0) {
-      openGuest();
-      return;
-    }
     openPicker();
   };
 
-  const handleLoggedIn = async (newToken: string, opts?: { inviteCode?: string }) => {
-    await continueAfterAuth(newToken, opts?.inviteCode);
-  };
-
   const handleDevicePicked = async (device: RemoteDevice) => {
     await YaverFeedback.setPreferredDevice(device.deviceId);
     closeAll();
-    // Continue straight into the feedback flow the user originally triggered.
     DeviceEventEmitter.emit('yaverFeedback:startReport');
   };
 
   return (
     <>
-      <Modal
-        visible={loginVisible}
-        animationType="slide"
-        presentationStyle="fullScreen"
-        onRequestClose={closeAll}
-      >
-        <YaverLoginScreen
-          onLoggedIn={handleLoggedIn}
-          onCancel={closeAll}
-          initialInviteCode={pendingInviteCode ?? YaverFeedback.getConfig()?.guestInviteCode}
-        />
+      <Modal visible={loginVisible} animationType="slide" presentationStyle="fullScreen" onRequestClose={closeAll}>
+        <YaverLoginScreen onLoggedIn={handleLoggedIn} onCancel={closeAll} />
       </Modal>
-
-      <Modal
-        visible={pickerVisible && !!token}
-        animationType="slide"
-        presentationStyle="fullScreen"
-        onRequestClose={closeAll}
-      >
+      <Modal visible={pickerVisible && !!token} animationType="slide" presentationStyle="fullScreen" onRequestClose={closeAll}>
         {token && (
           <YaverMachinePickerScreen
             token={token}
@@ -144,28 +80,6 @@ export const AuthOverlay: React.FC = () => {
           />
         )}
       </Modal>
-
-      <Modal
-        visible={guestVisible && !!token}
-        animationType="slide"
-        presentationStyle="fullScreen"
-        onRequestClose={closeAll}
-      >
-        {token && (
-          <YaverGuestOnboardingScreen
-            token={token}
-            initialInviteCode={pendingInviteCode ?? YaverFeedback.getConfig()?.guestInviteCode}
-            onContinue={() => {
-              setPendingInviteCode(null);
-              openPicker();
-            }}
-            onCancel={() => {
-              setPendingInviteCode(null);
-              openPicker();
-            }}
-          />
-        )}
-      </Modal>
     </>
   );
 };

package/src/BlackBox.ts

@@ -66,6 +66,13 @@ export interface BlackBoxCommand {
 /** Callback type for handling agent commands. */
 export type CommandHandler = (cmd: BlackBoxCommand) => void;
 
+function unrefTimer(timer: ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>): void {
+  const maybeNodeTimer = timer as unknown as { unref?: () => void };
+  if (typeof maybeNodeTimer.unref === 'function') {
+    maybeNodeTimer.unref();
+  }
+}
+
 export class BlackBox {
   private static baseUrl: string | null = null;
   private static authToken: string | null = null;
@@ -109,7 +116,7 @@ export class BlackBox {
 
     BlackBox.baseUrl = feedbackConfig.agentUrl.replace(/\/$/, '');
     BlackBox.authToken = feedbackConfig.authToken ?? null;
-    BlackBox.relayPassword = (feedbackConfig as { relayPassword?: string }).relayPassword ?? '';
+    BlackBox.relayPassword = YaverFeedback.getRelayPassword();
     BlackBox.deviceId = config?.deviceId ?? BlackBox.generateDeviceId();
     BlackBox.appName = config?.appName ?? '';
     BlackBox.flushInterval = config?.flushInterval ?? 2000;
@@ -120,6 +127,7 @@ export class BlackBox {
     // Start periodic flush
     if (BlackBox.flushTimer) clearInterval(BlackBox.flushTimer);
     BlackBox.flushTimer = setInterval(() => BlackBox.flush(), BlackBox.flushInterval);
+    unrefTimer(BlackBox.flushTimer);
 
     // Log the session start
     BlackBox.push({
@@ -471,6 +479,7 @@ export class BlackBox {
       BlackBox.sseReconnectTimer = null;
       if (BlackBox.started) BlackBox.connectSSE();
     }, 5000);
+    unrefTimer(BlackBox.sseReconnectTimer);
   }
 
   // ─── Internal ────────────────────────────────────────────────────