yaver-feedback-react-native 0.5.2 → 0.5.4

package/dist/auth.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Authentication + device/agent discovery API used by the Yaver Feedback SDK.
+ *
+ * This module is a trimmed SDK-local port of mobile/src/lib/auth.ts. It only
+ * covers what the embedded login/machine-picker flow needs:
+ *
+ *   - Device-code login (`POST /auth/device-code` + `GET /auth/device-code/poll`)
+ *     so users can sign in via any OAuth provider (apple/google/github/gitlab/
+ *     microsoft) on yaver.io without requiring deep-link wiring in the host app.
+ *   - Email / password sign-up + login (no 2FA flow — for SDK simplicity).
+ *   - Token validation + refresh.
+ *   - `/devices/list` → owned + shared (guest) remote dev machines.
+ *
+ * All calls target the public Yaver Convex site URL by default; callers may
+ * override via `init()` config to point at staging.
+ *
+ * Token persistence uses `@react-native-async-storage/async-storage` (already
+ * a peer dep). SecureStore is intentionally avoided to keep the SDK portable
+ * to any RN host app.
+ */
+export declare const DEFAULT_CONVEX_SITE_URL = "https://shocking-echidna-394.eu-west-1.convex.site";
+export declare const DEFAULT_WEB_BASE_URL = "https://yaver.io";
+/** Override the Convex site URL + web base (staging vs prod). */
+export declare function configureAuthEndpoints(opts: {
+    convexSiteUrl?: string;
+    webBaseUrl?: string;
+}): void;
+export declare function getConvexSiteUrl(): string;
+export declare function getWebBaseUrl(): string;
+export type OAuthProvider = 'google' | 'microsoft' | 'apple' | 'github' | 'gitlab';
+export interface User {
+    id: string;
+    email: string;
+    name: string;
+    provider?: string;
+    avatarUrl?: string;
+}
+export declare function getToken(): Promise<string | null>;
+export declare function saveToken(token: string): Promise<void>;
+export declare function clearToken(): Promise<void>;
+export declare function getUser(): Promise<User | null>;
+export declare function saveUser(user: User): Promise<void>;
+export declare function getSelectedDeviceId(): Promise<string | null>;
+export declare function saveSelectedDeviceId(deviceId: string): Promise<void>;
+export declare function clearSelectedDeviceId(): Promise<void>;
+export declare function validateToken(token: string): Promise<User | null>;
+export interface DeviceCodeStart {
+    userCode: string;
+    deviceCode: string;
+    expiresAt: number;
+    verificationUrl: string;
+}
+/**
+ * Start a device-code flow. The user opens `verificationUrl`, signs in with
+ * any OAuth provider on yaver.io, and the SDK polls `pollDeviceCode` until
+ * a session token is issued.
+ */
+export declare function startDeviceCode(opts?: {
+    machineName?: string;
+    platform?: string;
+    preferredProvider?: OAuthProvider;
+}): Promise<DeviceCodeStart>;
+export type DeviceCodePoll = {
+    status: 'pending';
+} | {
+    status: 'authorized';
+    token: string;
+} | {
+    status: 'expired';
+};
+export declare function pollDeviceCode(deviceCode: string): Promise<DeviceCodePoll>;
+export declare function signupWithEmail(fullName: string, email: string, password: string): Promise<{
+    token: string;
+    userId: string;
+}>;
+export declare function loginWithEmail(email: string, password: string): Promise<{
+    token: string;
+    userId: string;
+    requires2fa?: boolean;
+}>;
+export interface RemoteDevice {
+    deviceId: string;
+    name: string;
+    platform: string;
+    isOnline: boolean;
+    needsAuth: boolean;
+    runnerDown: boolean;
+    lastHeartbeat: number;
+    isGuest: boolean;
+    hostName?: string;
+    hostEmail?: string;
+    accessScope: 'owner' | 'shared-scoped' | 'shared-legacy';
+    quicHost: string;
+    quicPort: number;
+    publicKey?: string;
+}
+export interface DeviceList {
+    owned: RemoteDevice[];
+    shared: RemoteDevice[];
+}
+/**
+ * Fetch the set of remote dev machines this user can reach. Splits into
+ * owned (user is the host) vs shared (host invited them as a guest).
+ */
+export declare function listReachableDevices(token: string): Promise<DeviceList>;

package/dist/auth.js

@@ -0,0 +1,282 @@
+"use strict";
+/**
+ * Authentication + device/agent discovery API used by the Yaver Feedback SDK.
+ *
+ * This module is a trimmed SDK-local port of mobile/src/lib/auth.ts. It only
+ * covers what the embedded login/machine-picker flow needs:
+ *
+ *   - Device-code login (`POST /auth/device-code` + `GET /auth/device-code/poll`)
+ *     so users can sign in via any OAuth provider (apple/google/github/gitlab/
+ *     microsoft) on yaver.io without requiring deep-link wiring in the host app.
+ *   - Email / password sign-up + login (no 2FA flow — for SDK simplicity).
+ *   - Token validation + refresh.
+ *   - `/devices/list` → owned + shared (guest) remote dev machines.
+ *
+ * All calls target the public Yaver Convex site URL by default; callers may
+ * override via `init()` config to point at staging.
+ *
+ * Token persistence uses `@react-native-async-storage/async-storage` (already
+ * a peer dep). SecureStore is intentionally avoided to keep the SDK portable
+ * to any RN host app.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_WEB_BASE_URL = exports.DEFAULT_CONVEX_SITE_URL = void 0;
+exports.configureAuthEndpoints = configureAuthEndpoints;
+exports.getConvexSiteUrl = getConvexSiteUrl;
+exports.getWebBaseUrl = getWebBaseUrl;
+exports.getToken = getToken;
+exports.saveToken = saveToken;
+exports.clearToken = clearToken;
+exports.getUser = getUser;
+exports.saveUser = saveUser;
+exports.getSelectedDeviceId = getSelectedDeviceId;
+exports.saveSelectedDeviceId = saveSelectedDeviceId;
+exports.clearSelectedDeviceId = clearSelectedDeviceId;
+exports.validateToken = validateToken;
+exports.startDeviceCode = startDeviceCode;
+exports.pollDeviceCode = pollDeviceCode;
+exports.signupWithEmail = signupWithEmail;
+exports.loginWithEmail = loginWithEmail;
+exports.listReachableDevices = listReachableDevices;
+// AsyncStorage is an optional peer dep — degrade gracefully if missing.
+let AsyncStorage = null;
+try {
+    AsyncStorage = require('@react-native-async-storage/async-storage').default;
+}
+catch {
+    // not installed — token persistence disabled, caller must pass authToken
+}
+const TOKEN_KEY = 'yaver_feedback_auth_token';
+const USER_KEY = 'yaver_feedback_user';
+const DEVICE_KEY = 'yaver_feedback_selected_device';
+exports.DEFAULT_CONVEX_SITE_URL = 'https://shocking-echidna-394.eu-west-1.convex.site';
+exports.DEFAULT_WEB_BASE_URL = 'https://yaver.io';
+let convexSiteUrl = exports.DEFAULT_CONVEX_SITE_URL;
+let webBaseUrl = exports.DEFAULT_WEB_BASE_URL;
+/** Override the Convex site URL + web base (staging vs prod). */
+function configureAuthEndpoints(opts) {
+    if (opts.convexSiteUrl)
+        convexSiteUrl = opts.convexSiteUrl;
+    if (opts.webBaseUrl)
+        webBaseUrl = opts.webBaseUrl;
+}
+function getConvexSiteUrl() {
+    return convexSiteUrl;
+}
+function getWebBaseUrl() {
+    return webBaseUrl;
+}
+// ─── Token persistence ────────────────────────────────────────────────
+async function getToken() {
+    if (!AsyncStorage)
+        return null;
+    try {
+        return await AsyncStorage.getItem(TOKEN_KEY);
+    }
+    catch {
+        return null;
+    }
+}
+async function saveToken(token) {
+    if (!AsyncStorage)
+        return;
+    try {
+        await AsyncStorage.setItem(TOKEN_KEY, token);
+    }
+    catch {
+        // best effort
+    }
+}
+async function clearToken() {
+    if (!AsyncStorage)
+        return;
+    try {
+        await AsyncStorage.removeItem(TOKEN_KEY);
+        await AsyncStorage.removeItem(USER_KEY);
+    }
+    catch {
+        // best effort
+    }
+}
+async function getUser() {
+    if (!AsyncStorage)
+        return null;
+    try {
+        const raw = await AsyncStorage.getItem(USER_KEY);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function saveUser(user) {
+    if (!AsyncStorage)
+        return;
+    try {
+        await AsyncStorage.setItem(USER_KEY, JSON.stringify(user));
+    }
+    catch {
+        // best effort
+    }
+}
+async function getSelectedDeviceId() {
+    if (!AsyncStorage)
+        return null;
+    try {
+        return await AsyncStorage.getItem(DEVICE_KEY);
+    }
+    catch {
+        return null;
+    }
+}
+async function saveSelectedDeviceId(deviceId) {
+    if (!AsyncStorage)
+        return;
+    try {
+        await AsyncStorage.setItem(DEVICE_KEY, deviceId);
+    }
+    catch {
+        // best effort
+    }
+}
+async function clearSelectedDeviceId() {
+    if (!AsyncStorage)
+        return;
+    try {
+        await AsyncStorage.removeItem(DEVICE_KEY);
+    }
+    catch {
+        // best effort
+    }
+}
+// ─── Token validation ──────────────────────────────────────────────────
+async function validateToken(token) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const res = await fetch(`${convexSiteUrl}/auth/validate`, {
+            method: 'GET',
+            headers: { Authorization: `Bearer ${token}` },
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        const u = data.user;
+        return {
+            id: u.userId ?? u.id,
+            email: u.email,
+            name: u.fullName ?? u.name,
+            provider: u.provider,
+            avatarUrl: u.avatarUrl,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Start a device-code flow. The user opens `verificationUrl`, signs in with
+ * any OAuth provider on yaver.io, and the SDK polls `pollDeviceCode` until
+ * a session token is issued.
+ */
+async function startDeviceCode(opts) {
+    const res = await fetch(`${convexSiteUrl}/auth/device-code`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            machineName: opts?.machineName,
+            platform: opts?.platform,
+            preferredProvider: opts?.preferredProvider,
+            environment: 'feedback-sdk',
+        }),
+    });
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        throw new Error(data.error ?? 'Failed to start device-code');
+    }
+    const data = await res.json();
+    const params = new URLSearchParams({ code: data.userCode });
+    if (opts?.preferredProvider) {
+        params.set('preferredProvider', opts.preferredProvider);
+    }
+    return {
+        userCode: data.userCode,
+        deviceCode: data.deviceCode,
+        expiresAt: data.expiresAt,
+        verificationUrl: `${webBaseUrl}/auth/device?${params.toString()}`,
+    };
+}
+async function pollDeviceCode(deviceCode) {
+    try {
+        const res = await fetch(`${convexSiteUrl}/auth/device-code/poll?device_code=${encodeURIComponent(deviceCode)}`);
+        if (!res.ok)
+            return { status: 'expired' };
+        const data = await res.json();
+        if (data.status === 'authorized' && typeof data.token === 'string') {
+            return { status: 'authorized', token: data.token };
+        }
+        if (data.status === 'pending')
+            return { status: 'pending' };
+        return { status: 'expired' };
+    }
+    catch {
+        return { status: 'pending' }; // network blip — let caller keep polling
+    }
+}
+// ─── Email / password (no 2FA) ────────────────────────────────────────
+async function signupWithEmail(fullName, email, password) {
+    const res = await fetch(`${convexSiteUrl}/auth/signup`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ fullName, email, password }),
+    });
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        throw new Error(data.error ?? 'Signup failed');
+    }
+    return res.json();
+}
+async function loginWithEmail(email, password) {
+    const res = await fetch(`${convexSiteUrl}/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password }),
+    });
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        throw new Error(data.error ?? 'Login failed');
+    }
+    const data = await res.json();
+    if (data?.requires2fa) {
+        // SDK login surface does not handle 2FA — direct the user to complete
+        // sign-in through the web flow (device-code) which supports it.
+        throw new Error('2FA is enabled on this account. Sign in via the device-code flow instead.');
+    }
+    return { token: data.token, userId: data.userId };
+}
+/**
+ * Fetch the set of remote dev machines this user can reach. Splits into
+ * owned (user is the host) vs shared (host invited them as a guest).
+ */
+async function listReachableDevices(token) {
+    try {
+        const res = await fetch(`${convexSiteUrl}/devices/list`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return { owned: [], shared: [] };
+        const data = await res.json();
+        const all = (data.devices ?? []);
+        return {
+            owned: all.filter((d) => !d.isGuest),
+            shared: all.filter((d) => d.isGuest),
+        };
+    }
+    catch {
+        return { owned: [], shared: [] };
+    }
+}

package/dist/capture.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Screen capture and audio recording helpers.
+ *
+ * Screenshot capture requires `react-native-view-shot` as a peer dependency.
+ * Audio recording requires `react-native-audio-recorder-player` or a
+ * similar library — the implementation below uses a minimal approach
+ * that works when one of those is available.
+ */
+/**
+ * Capture the current screen as a PNG image.
+ * Requires `react-native-view-shot` to be installed.
+ * @returns File path of the captured screenshot.
+ */
+export declare function captureScreenshot(): Promise<string>;
+/**
+ * Start recording an audio voice note.
+ * Requires `react-native-audio-recorder-player` to be installed.
+ */
+export declare function startAudioRecording(): Promise<void>;
+/**
+ * Stop the current audio recording.
+ * @returns Object with the file path and duration in seconds.
+ */
+export declare function stopAudioRecording(): Promise<{
+    path: string;
+    duration: number;
+}>;

package/dist/capture.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Screen capture and audio recording helpers.
+ *
+ * Screenshot capture requires `react-native-view-shot` as a peer dependency.
+ * Audio recording requires `react-native-audio-recorder-player` or a
+ * similar library — the implementation below uses a minimal approach
+ * that works when one of those is available.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureScreenshot = captureScreenshot;
+exports.startAudioRecording = startAudioRecording;
+exports.stopAudioRecording = stopAudioRecording;
+let audioRecorderModule = null;
+/**
+ * Capture the current screen as a PNG image.
+ * Requires `react-native-view-shot` to be installed.
+ * @returns File path of the captured screenshot.
+ */
+async function captureScreenshot() {
+    try {
+        const ViewShot = require('react-native-view-shot');
+        const uri = await ViewShot.captureScreen({
+            format: 'png',
+            quality: 0.9,
+        });
+        return uri;
+    }
+    catch (err) {
+        throw new Error('[YaverFeedback] Screenshot capture failed. Make sure react-native-view-shot is installed. ' +
+            String(err));
+    }
+}
+/**
+ * Start recording an audio voice note.
+ * Requires `react-native-audio-recorder-player` to be installed.
+ */
+async function startAudioRecording() {
+    try {
+        const AudioRecorderPlayer = require('react-native-audio-recorder-player').default;
+        audioRecorderModule = new AudioRecorderPlayer();
+        await audioRecorderModule.startRecorder();
+    }
+    catch (err) {
+        audioRecorderModule = null;
+        throw new Error('[YaverFeedback] Audio recording failed to start. Make sure react-native-audio-recorder-player is installed. ' +
+            String(err));
+    }
+}
+/**
+ * Stop the current audio recording.
+ * @returns Object with the file path and duration in seconds.
+ */
+async function stopAudioRecording() {
+    if (!audioRecorderModule) {
+        throw new Error('[YaverFeedback] No audio recording in progress.');
+    }
+    try {
+        const result = await audioRecorderModule.stopRecorder();
+        const recorder = audioRecorderModule;
+        audioRecorderModule = null;
+        // result is the file path on most implementations
+        const path = typeof result === 'string' ? result : result?.uri ?? '';
+        // Duration tracking — recorder-player provides currentPosition in ms
+        const durationMs = typeof recorder.currentPosition === 'number'
+            ? recorder.currentPosition
+            : 0;
+        return { path, duration: durationMs / 1000 };
+    }
+    catch (err) {
+        audioRecorderModule = null;
+        throw new Error('[YaverFeedback] Failed to stop audio recording. ' + String(err));
+    }
+}

package/dist/expo.d.ts

@@ -0,0 +1,15 @@
+import type { FeedbackConfig } from './types';
+/**
+ * Initialize the Yaver Feedback SDK for Expo projects.
+ *
+ * Attempts to read the agent URL from Expo Constants (`expo.extra.yaverAgentUrl`
+ * in app.json). If not set, the SDK auto-discovers agents on the local network.
+ *
+ * Defaults:
+ * - trigger: 'shake'
+ * - feedbackMode: 'batch'
+ * - enabled: __DEV__ (only active in development)
+ *
+ * @param overrides - Optional partial config to override defaults
+ */
+export declare function initExpo(overrides?: Partial<FeedbackConfig>): void;

package/dist/expo.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initExpo = initExpo;
+/**
+ * Expo-specific auto-initialization for the Yaver Feedback SDK.
+ *
+ * Reads agent URL from Expo Constants manifest extra if available,
+ * otherwise falls back to LAN auto-discovery.
+ *
+ * @example
+ * ```tsx
+ * import { initExpo, FeedbackModal } from '@yaver/feedback-react-native';
+ *
+ * initExpo(); // auto-discovers your dev machine
+ *
+ * function App() {
+ *   return (
+ *     <>
+ *       <YourApp />
+ *       <FeedbackModal />
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+const YaverFeedback_1 = require("./YaverFeedback");
+/**
+ * Initialize the Yaver Feedback SDK for Expo projects.
+ *
+ * Attempts to read the agent URL from Expo Constants (`expo.extra.yaverAgentUrl`
+ * in app.json). If not set, the SDK auto-discovers agents on the local network.
+ *
+ * Defaults:
+ * - trigger: 'shake'
+ * - feedbackMode: 'batch'
+ * - enabled: __DEV__ (only active in development)
+ *
+ * @param overrides - Optional partial config to override defaults
+ */
+function initExpo(overrides) {
+    let agentUrl;
+    // Try reading agent URL from Expo Constants manifest extra
+    try {
+        // Dynamic require so this doesn't hard-fail if expo-constants isn't installed
+        const Constants = require('expo-constants').default;
+        agentUrl =
+            Constants.expoConfig?.extra?.yaverAgentUrl ??
+                Constants.manifest?.extra?.yaverAgentUrl ??
+                Constants.manifest2?.extra?.expoClient?.extra?.yaverAgentUrl;
+    }
+    catch {
+        // expo-constants not available — auto-discovery will be used
+    }
+    YaverFeedback_1.YaverFeedback.init({
+        authToken: '', // LAN auto-discovery doesn't require a token
+        trigger: 'shake',
+        feedbackMode: 'batch',
+        enabled: __DEV__,
+        ...overrides,
+        ...(agentUrl ? { agentUrl } : {}),
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @yaver/feedback-react-native — Visual feedback SDK for Yaver.
+ *
+ * Shake-to-report, screenshots, voice annotations, P2P connection,
+ * device discovery, and live/narrated/batch feedback modes for vibe coding.
+ *
+ * @example
+ * ```tsx
+ * import { YaverFeedback, FeedbackProvider } from '@yaver/feedback-react-native';
+ *
+ * YaverFeedback.init({
+ *   agentUrl: 'http://192.168.1.10:18080',
+ *   authToken: 'your-token',
+ *   trigger: 'shake',
+ *   feedbackMode: 'live',
+ * });
+ *
+ * // Wrap your app root:
+ * <FeedbackProvider>
+ *   <App />
+ * </FeedbackProvider>
+ * ```
+ */
+export { YaverFeedback } from './YaverFeedback';
+export { BlackBox } from './BlackBox';
+export { YaverUpdates } from './YaverUpdates';
+export type { YaverUpdatesConfig, PendingUpdate } from './YaverUpdates';
+export { initExpo } from './expo';
+export { YaverDiscovery } from './Discovery';
+export { P2PClient } from './P2PClient';
+export { YaverConnectionScreen } from './ConnectionScreen';
+export { YaverLoginScreen } from './LoginScreen';
+export type { YaverLoginScreenProps } from './LoginScreen';
+export { YaverMachinePickerScreen } from './MachinePickerScreen';
+export type { YaverMachinePickerProps } from './MachinePickerScreen';
+export { AuthOverlay } from './AuthOverlay';
+export { ShakeDetector } from './ShakeDetector';
+export { FloatingButton } from './FloatingButton';
+export { FeedbackModal } from './FeedbackModal';
+export { FixReport } from './FixReport';
+export { configureAuthEndpoints, getConvexSiteUrl, getWebBaseUrl, getToken, saveToken, clearToken, getUser, saveUser, getSelectedDeviceId, saveSelectedDeviceId, clearSelectedDeviceId, validateToken, startDeviceCode, pollDeviceCode, signupWithEmail, loginWithEmail, listReachableDevices, DEFAULT_CONVEX_SITE_URL, DEFAULT_WEB_BASE_URL, } from './auth';
+export type { OAuthProvider, User, DeviceCodeStart, DeviceCodePoll, RemoteDevice, DeviceList, } from './auth';
+export { captureScreenshot, startAudioRecording, stopAudioRecording } from './capture';
+export { uploadFeedback } from './upload';
+export type { FeedbackConfig, FeedbackBundle, FeedbackMetadata, DeviceInfo, AppInfo, TimelineEvent, FeedbackReport, AgentCommentary, FeedbackStreamEvent, VoiceCapability, CapturedError, TestFix, TestSession, } from './types';
+export type { BlackBoxEvent, BlackBoxConfig, BlackBoxCommand, CommandHandler } from './BlackBox';
+export type { DiscoveryResult } from './Discovery';
+export type { FeedbackEvent } from './P2PClient';