yaver-feedback-react-native 0.9.2 → 0.9.4

package/src/deviceDogfood.ts

@@ -0,0 +1,171 @@
+import nacl from 'tweetnacl';
+import { Buffer } from 'buffer';
+import { DEFAULT_CONVEX_SITE_URL } from './auth';
+
+type SecureStoreLike = {
+  getItemAsync(key: string): Promise<string | null>;
+  setItemAsync(key: string, value: string): Promise<void>;
+  deleteItemAsync(key: string): Promise<void>;
+};
+
+export type DeviceDogfoodState = 'unregistered' | 'pending' | 'active' | 'cancelled' | 'revoked' | 'superseded';
+
+export interface DeviceDogfoodOptions {
+  /** Public identifier registered by the app owner in Yaver Settings. */
+  appId: string;
+  label?: string;
+  backendUrl?: string;
+  /** Advanced bare-RN integration. Expo apps use SecureStore automatically. */
+  secureStore?: SecureStoreLike;
+}
+
+export interface DeviceDogfoodSession {
+  active: true;
+  appId: string;
+  installationId: string;
+  token: string;
+  expiresAt: number;
+  scopes: string[];
+  projectSlug?: string;
+  targetDeviceId?: string;
+}
+
+interface StoredIdentity {
+  installationId: string;
+  registrationSlot: string;
+  publicKey: string;
+  secretKey: string;
+}
+
+function b64(bytes: Uint8Array): string { return Buffer.from(bytes).toString('base64'); }
+function fromB64(value: string): Uint8Array { return new Uint8Array(Buffer.from(value, 'base64')); }
+function b64url(bytes: Uint8Array): string {
+  return Buffer.from(bytes).toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+}
+
+function randomBytes(length: number): Uint8Array {
+  const cryptoObject = (globalThis as any)?.crypto;
+  if (cryptoObject?.getRandomValues) {
+    const out = new Uint8Array(length);
+    cryptoObject.getRandomValues(out);
+    return out;
+  }
+  try {
+    return require('expo-crypto').getRandomBytes(length);
+  } catch {
+    throw new Error('Secure randomness is unavailable. Install expo-crypto or provide global crypto.getRandomValues.');
+  }
+}
+
+function defaultSecureStore(): SecureStoreLike {
+  try {
+    const store = require('expo-secure-store');
+    if (store?.getItemAsync && store?.setItemAsync) return store;
+  } catch { /* named error below */ }
+  throw new Error('Secure Dogfood identity storage is unavailable. Install expo-secure-store or pass secureStore.');
+}
+
+async function responseJSON(response: Response): Promise<any> {
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(body?.error || `Yaver Dogfood request failed (HTTP ${response.status})`);
+  return body;
+}
+
+function enrollmentMessage(appId: string, installationId: string, challenge: string): Uint8Array {
+  return new TextEncoder().encode(`yaver-dogfood-enroll-v1\n${appId}\n${installationId}\n${challenge}`);
+}
+
+function sessionMessage(appId: string, installationId: string, challenge: string): Uint8Array {
+  return new TextEncoder().encode(`yaver-dogfood-session-v1\n${appId}\n${installationId}\n${challenge}`);
+}
+
+/** Account-free third-party Dogfood enrollment. The UUID is a public lookup
+ * handle; possession is proven by the private key retained in this app. */
+export class YaverDeviceDogfood {
+  private readonly backendUrl: string;
+  private readonly store: SecureStoreLike;
+  private readonly storageKey: string;
+
+  constructor(private readonly options: DeviceDogfoodOptions) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{2,127}$/.test(options.appId)) throw new Error('A valid Dogfood appId is required');
+    this.backendUrl = (options.backendUrl || DEFAULT_CONVEX_SITE_URL).replace(/\/$/, '');
+    this.store = options.secureStore || defaultSecureStore();
+    this.storageKey = `yaver_feedback_dogfood_v1_${options.appId}`;
+  }
+
+  private async identity(): Promise<StoredIdentity> {
+    const raw = await this.store.getItemAsync(this.storageKey);
+    if (raw) {
+      try {
+        const saved = JSON.parse(raw) as StoredIdentity;
+        if (fromB64(saved.publicKey).length === nacl.sign.publicKeyLength && fromB64(saved.secretKey).length === nacl.sign.secretKeyLength) return saved;
+      } catch { /* rotate corrupt identity below */ }
+    }
+    const seed = randomBytes(32);
+    const pair = nacl.sign.keyPair.fromSeed(seed);
+    seed.fill(0);
+    const identity: StoredIdentity = {
+      installationId: b64url(randomBytes(18)), registrationSlot: b64url(randomBytes(18)),
+      publicKey: b64(pair.publicKey), secretKey: b64(pair.secretKey),
+    };
+    await this.store.setItemAsync(this.storageKey, JSON.stringify(identity));
+    return identity;
+  }
+
+  async enrollmentInfo(): Promise<{ appId: string; installationId: string; registrationSlot: string; publicKey: string }> {
+    const identity = await this.identity();
+    return { appId: this.options.appId, installationId: identity.installationId, registrationSlot: identity.registrationSlot, publicKey: identity.publicKey };
+  }
+
+  async enroll(platform = 'unknown'): Promise<{ status: DeviceDogfoodState; installationId: string }> {
+    const identity = await this.identity();
+    const started = await responseJSON(await fetch(`${this.backendUrl}/dogfood/enroll/start`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ appId: this.options.appId, installationId: identity.installationId, registrationSlot: identity.registrationSlot, publicKey: identity.publicKey, platform, label: this.options.label }),
+    }));
+    if (started.status === 'active') return { status: 'active', installationId: identity.installationId };
+    const signature = b64(nacl.sign.detached(enrollmentMessage(this.options.appId, identity.installationId, started.challenge), fromB64(identity.secretKey)));
+    await responseJSON(await fetch(`${this.backendUrl}/dogfood/enroll/prove`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ appId: this.options.appId, installationId: identity.installationId, signature }),
+    }));
+    return { status: 'pending', installationId: identity.installationId };
+  }
+
+  async status(): Promise<DeviceDogfoodState> {
+    const identity = await this.identity();
+    const response = await fetch(`${this.backendUrl}/dogfood/enroll/status?appId=${encodeURIComponent(this.options.appId)}&installationId=${encodeURIComponent(identity.installationId)}`);
+    if (response.status === 404) return 'unregistered';
+    return (await responseJSON(response)).status as DeviceDogfoodState;
+  }
+
+  async session(): Promise<DeviceDogfoodSession | null> {
+    const identity = await this.identity();
+    if (await this.status() !== 'active') return null;
+    const challenge = await responseJSON(await fetch(`${this.backendUrl}/dogfood/session/challenge`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ appId: this.options.appId, installationId: identity.installationId }),
+    }));
+    const signature = b64(nacl.sign.detached(sessionMessage(this.options.appId, identity.installationId, challenge.challenge), fromB64(identity.secretKey)));
+    const result = await responseJSON(await fetch(`${this.backendUrl}/dogfood/session`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ appId: this.options.appId, installationId: identity.installationId, signature }),
+    }));
+    return { active: true, appId: this.options.appId, installationId: identity.installationId, token: result.token, expiresAt: result.expiresAt, scopes: result.scopes || [], projectSlug: result.projectSlug, targetDeviceId: result.targetDeviceId };
+  }
+
+  /** Rotate the key but keep the logical slot. Approval supersedes the prior
+   * generation, making its already-issued sessions fail immediately. */
+  async reRegister(platform = 'unknown'): Promise<{ status: DeviceDogfoodState; installationId: string }> {
+    const previous = await this.identity();
+    const seed = randomBytes(32);
+    const pair = nacl.sign.keyPair.fromSeed(seed);
+    seed.fill(0);
+    const next: StoredIdentity = {
+      installationId: b64url(randomBytes(18)), registrationSlot: previous.registrationSlot,
+      publicKey: b64(pair.publicKey), secretKey: b64(pair.secretKey),
+    };
+    await this.store.setItemAsync(this.storageKey, JSON.stringify(next));
+    return this.enroll(platform);
+  }
+}

package/src/dogfoodPolicy.ts

@@ -0,0 +1,40 @@
+export interface SDKDogfoodConfig {
+  /** Explicit opt-in. Omitted/false keeps the normal Feedback SDK. */
+  enabled?: boolean;
+  /** App-account IDs allowed to enter Dogfood. Public identifiers, not secrets. */
+  accountIds?: string[];
+  /** The third-party app's currently authenticated account ID. */
+  currentAccountId?: string;
+  /** Account-free installation identity resolved by YaverDeviceDogfood. */
+  appId?: string;
+  installationId?: string;
+  installationStatus?: 'pending' | 'active' | 'cancelled' | 'revoked' | 'superseded';
+  /** Called after the user confirms Exit Dogfood mode. */
+  onExit?: () => void | Promise<void>;
+  /** Optional app label shown beside Dogfood mode. */
+  label?: string;
+}
+
+export interface SDKDogfoodStatus {
+  active: boolean;
+  code: 'SDK_DOGFOOD_ACTIVE' | 'SDK_DOGFOOD_DISABLED' | 'SDK_DOGFOOD_ACCOUNT_REQUIRED' | 'SDK_DOGFOOD_ACCOUNT_NOT_ALLOWED' | 'SDK_DOGFOOD_INSTALLATION_REQUIRED' | 'SDK_DOGFOOD_INSTALLATION_NOT_ACTIVE';
+  accountId?: string;
+  label: string;
+}
+
+/** Pure, fail-closed account gate shared by init, the Y badge and tests.
+ * This controls SDK UX only; every task/reload still requires Yaver auth. */
+export function resolveSDKDogfood(config?: SDKDogfoodConfig | null): SDKDogfoodStatus {
+  const label = String(config?.label || 'Dogfood').trim() || 'Dogfood';
+  if (config?.enabled !== true) return { active: false, code: 'SDK_DOGFOOD_DISABLED', label };
+  if (config.appId) {
+    if (!config.installationId) return { active: false, code: 'SDK_DOGFOOD_INSTALLATION_REQUIRED', label };
+    if (config.installationStatus !== 'active') return { active: false, code: 'SDK_DOGFOOD_INSTALLATION_NOT_ACTIVE', label };
+    return { active: true, code: 'SDK_DOGFOOD_ACTIVE', accountId: config.installationId, label };
+  }
+  const accountId = String(config.currentAccountId || '').trim();
+  if (!accountId) return { active: false, code: 'SDK_DOGFOOD_ACCOUNT_REQUIRED', label };
+  const allowed = new Set((config.accountIds || []).map((id) => String(id).trim()).filter(Boolean));
+  if (!allowed.has(accountId)) return { active: false, code: 'SDK_DOGFOOD_ACCOUNT_NOT_ALLOWED', accountId, label };
+  return { active: true, code: 'SDK_DOGFOOD_ACTIVE', accountId, label };
+}

package/src/index.ts

@@ -29,6 +29,7 @@
  */
 
 export { YaverFeedback } from './YaverFeedback';
+export type { DogfoodOnboardingOptions } from './YaverFeedback';
 export { captureStoreScreenshots } from './storeShots';
 export type {
   CaptureStoreScreenshotsOptions,
@@ -41,6 +42,14 @@ export type { YaverUpdatesConfig, PendingUpdate } from './YaverUpdates';
 export { initExpo } from './expo';
 export { YaverDiscovery } from './Discovery';
 export { P2PClient } from './P2PClient';
+export type {
+  DogfoodDevEvent,
+  DogfoodDevServerStatus,
+  DogfoodRemoteRuntimeCapabilities,
+  DogfoodRemoteRuntimeSession,
+  DogfoodRemoteRuntimeTarget,
+} from './P2PClient';
+export { createP2PDogfoodDriver, type P2PDogfoodDriverOptions } from './P2PDogfoodDriver';
 export {
   reloadActions,
   reloadRequest,
@@ -61,13 +70,42 @@ export { YaverLoginScreen } from './LoginScreen';
 export type { YaverLoginScreenProps } from './LoginScreen';
 export { YaverMachinePickerScreen } from './MachinePickerScreen';
 export type { YaverMachinePickerProps } from './MachinePickerScreen';
-export { YaverGuestOnboardingScreen } from './GuestOnboardingScreen';
-export type { YaverGuestOnboardingScreenProps } from './GuestOnboardingScreen';
 export { PairDeviceModal } from './PairDeviceModal';
 export type { PairDeviceModalProps } from './PairDeviceModal';
 export { AuthOverlay } from './AuthOverlay';
 export { ShakeDetector } from './ShakeDetector';
 export { FloatingButton } from './FloatingButton';
+// The polite "you're inside Yaver" mark. Rendered automatically by the SDK's
+// overlay host when config.modeBadge !== false; exported so an app that manages
+// its own overlay tree can place it itself.
+export { YaverModeBadge, hideYaverModeBadge, showYaverModeBadge, isYaverModeBadgeHidden } from './YaverModeBadge';
+export type { YaverModeBadgeProps } from './YaverModeBadge';
+export { resolveSDKDogfood } from './dogfoodPolicy';
+export type { SDKDogfoodConfig, SDKDogfoodStatus } from './dogfoodPolicy';
+export { YaverDeviceDogfood } from './deviceDogfood';
+export type { DeviceDogfoodOptions, DeviceDogfoodSession, DeviceDogfoodState } from './deviceDogfood';
+export {
+  DogfoodController,
+  DogfoodRuntimeError,
+  defaultDogfoodLane,
+  dogfoodLaneOptions,
+  dogfoodLogLinesFromDevEvent,
+  runtimeLogLinesFromDevEvent,
+  validateDogfoodProject,
+} from './DogfoodRuntime';
+export type {
+  DogfoodControllerOptions,
+  DogfoodDriver,
+  DogfoodFailure,
+  DogfoodLane,
+  DogfoodLaneOption,
+  DogfoodLogLine,
+  DogfoodPhase,
+  DogfoodProject,
+  DogfoodResult,
+  DogfoodRunContext,
+  DogfoodSnapshot,
+} from './DogfoodRuntime';
 export { FeedbackModal } from './FeedbackModal';
 export { QuickActionIcon } from './QuickActionIcon';
 export type { QuickActionIconProps } from './QuickActionIcon';
@@ -95,10 +133,6 @@ export {
   signupWithEmail,
   loginWithEmail,
   listReachableDevices,
-  fetchGuestHosts,
-  findInviteByCode,
-  acceptGuestByCode,
-  acceptGuestInvitation,
   DEFAULT_CONVEX_SITE_URL,
   DEFAULT_WEB_BASE_URL,
   DEFAULT_OAUTH_REDIRECT,
@@ -108,11 +142,6 @@ export type {
   User,
   RemoteDevice,
   DeviceList,
-  GuestInvitation,
-  ActiveGuestHost,
-  GuestHostsResponse,
-  InvitationHostDevice,
-  InvitationPreview,
 } from './auth';
 export {
   captureScreenshot,

package/src/reloadActions.ts

@@ -33,9 +33,9 @@
 // ── Auth ─────────────────────────────────────────────────────────────────────
 //
 // None of this needs a new secret. `/dev/reload` and `/dev/reload-app` are
-// registered under `authSDKOrGuest` (desktop/agent/httpserver.go), the same
+// registered under `authSDK` (desktop/agent/httpserver.go), the same
 // middleware that already admits the bearer this SDK sends with its feedback
-// POST. A scope-limited SDK token needs the existing `guest-reload` scope,
+// POST. A scope-limited SDK token needs the existing `reload` scope,
 // whose path list already contains both routes — no widening, no new gate.
 
 /** Stable identifier for each action the overlay can render. */

package/src/types.ts

@@ -1,6 +1,7 @@
 // Type-only: BlackBox.ts already imports from this module, so a value import
 // would close a cycle. `import type` is erased at compile time.
 import type { BlackBoxConfig } from './BlackBox';
+import type { SDKDogfoodConfig } from './dogfoodPolicy';
 
 /**
  * Remote browser-style sign-in session for a coding-agent CLI on the
@@ -36,6 +37,8 @@ export interface RunnerAuthStatusRow {
   path?: string;
   detail?: string;
   version?: string;
+  isDefault?: boolean;
+  models?: Array<{ id: string; name?: string; provider?: string; isDefault?: boolean }>;
 }
 
 export interface OpenCodeProviderSummary {
@@ -146,6 +149,40 @@ export interface StoreShotsConfig {
 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
@@ -225,6 +262,14 @@ export interface FeedbackConfig {
   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';
   /**
@@ -465,13 +510,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 {

package/dist/GuestOnboardingScreen.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-export interface YaverGuestOnboardingScreenProps {
-    token: string;
-    initialInviteCode?: string;
-    onContinue: () => void;
-    onCancel?: () => void;
-}
-export declare const YaverGuestOnboardingScreen: React.FC<YaverGuestOnboardingScreenProps>;