yaver-feedback-react-native 0.8.13 → 0.9.2

package/src/MachinePickerScreen.tsx

@@ -102,7 +102,14 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
       return;
     }
     const direct = await probeDeviceReachability(device);
-    if (!direct.reachable && !device.needsAuth) {
+    // Do not hard-block selection just because the LAN /health probe
+    // failed. The standalone SDK can still reach a healthy machine via
+    // the normal selected-device discovery path (including relay), and
+    // the Yaver host path may already be proving the machine works.
+    // Only treat the machine as unpickable when BOTH:
+    //   1. Convex says it is offline, and
+    //   2. the direct probe also failed.
+    if (!device.isOnline && !direct.reachable && !device.needsAuth) {
       setError('Selected machine is not responding. Start `yaver serve` on it and try again.');
       setReachability((prev) => ({ ...prev, [device.deviceId]: direct }));
       return;
@@ -130,7 +137,9 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
       ? '#f59e0b'
       : effectivelyReachable
         ? '#22c55e'
-        : explicitlyOffline || !device.isOnline
+        : device.isOnline
+          ? '#f59e0b'
+          : explicitlyOffline || !device.isOnline
           ? '#ef4444'
           : '#22c55e';
     // Derive a single short status phrase the user can act on.
@@ -145,7 +154,7 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
       statusLine =
         'Needs pairing — open the Yaver app to adopt this machine';
     } else if (explicitlyOffline) {
-      statusLine = 'Agent not responding on this machine';
+      statusLine = 'Online, but direct probe failed — relay / selected-machine path may still work';
     } else if (device.runnerDown) {
       statusLine = 'Runner down — restart the coding agent on the Mac';
     } else {

package/src/P2PClient.ts

@@ -1,13 +1,27 @@
 import { Platform } from 'react-native';
 import {
+  AppInfo,
   CapabilitySnapshot,
   FeedbackBundle,
+  FeedbackProjectRef,
   IncidentEvent,
+  OpenCodeConfigSummary,
   OperationState,
   RunnerBrowserAuthSession,
+  RunnerAuthStatusRow,
   TestSession,
   VoiceCapability,
 } from './types';
+import { AGENT_ENDPOINTS } from './_core/endpoints';
+import { RELOAD_PATH, describeReloadFailure } from './reloadActions';
+import type { DevServerSnapshot, ReloadWireMode } from './reloadActions';
+
+function unrefTimer(timer: ReturnType<typeof setTimeout>): void {
+  const maybeNodeTimer = timer as unknown as { unref?: () => void };
+  if (typeof maybeNodeTimer.unref === 'function') {
+    maybeNodeTimer.unref();
+  }
+}
 
 export interface FeedbackEvent {
   type: string;
@@ -74,6 +88,148 @@ export function resolveAppIdentity(opts?: {
   return out;
 }
 
+/**
+ * Is this JS running inside Yaver's own container as a pushed Hermes guest?
+ *
+ * The YaverInfo native module is registered only by Yaver's app, so its
+ * presence means the ambient runtime describes Yaver rather than the app
+ * whose code is executing. Mirrors the checks in YaverFeedback.ts,
+ * ShakeDetector.ts and QuickActionIcon.tsx.
+ */
+function isInsideYaverContainer(): boolean {
+  try {
+    const { NativeModules } = require('react-native');
+    return !!NativeModules?.YaverInfo;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Read the guest project Yaver's host shell pinned for this bundle.
+ *
+ * When an app's JS is pushed into Yaver's container as a Hermes guest, the
+ * ambient runtime describes the HOST — `expo-constants` and `SettingsManager`
+ * both answer `Yaver` / `io.yaver.mobile`. Auto-resolution would therefore
+ * file every guest report against Yaver's own repo, and the fix task would
+ * edit the SDK instead of the app under test.
+ *
+ * Yaver already knows the right answer: picking a project in the Hot Reload
+ * tab calls `YaverInfo.setInheritedGuestProject(name, path)`. Only the name
+ * is used here — the agent resolves the path itself and deliberately ignores
+ * client-supplied ones on feedback reports.
+ */
+function resolveInheritedGuestProjectName(): string | undefined {
+  try {
+    const { NativeModules } = require('react-native');
+    const name = String(NativeModules?.YaverInfo?.inheritedGuestProjectName || '').trim();
+    return name || undefined;
+  } catch {
+    // Not inside Yaver's container, or react-native unavailable (unit tests).
+    return undefined;
+  }
+}
+
+/**
+ * Build the app-identity half of a feedback report's metadata.
+ *
+ * `resolveAppIdentity()` has always fed /vibing/execute and /dev/reload-app,
+ * so the agent could route a "vibe on THIS app" request to the right repo —
+ * but nothing fed /feedback. Reports arrived with no identity at all, so the
+ * agent's fix router fell through to its own working directory and edited
+ * whichever repo it happened to be sitting in. This closes that gap by
+ * reusing the same resolver for the feedback path.
+ *
+ * Precedence, most to least trustworthy:
+ *   1. What the host app declared (`FeedbackConfig.projectName`/`bundleId`).
+ *      An app knows its own identity; nothing should override it.
+ *   2. The guest project Yaver's host shell pinned, when running as a Hermes
+ *      guest. Ambient lookups describe Yaver there, not the guest.
+ *   3. Ambient expo-constants / native modules — correct for a standalone
+ *      build, which is the common case.
+ *
+ * Every lookup is best-effort: a bare RN app with no expo-constants still
+ * produces a report, just one the agent resolves by its own means.
+ */
+export function resolveReportIdentity(opts?: {
+  projectName?: string;
+  bundleId?: string;
+  surface?: FeedbackProjectRef['surface'];
+  surfaces?: FeedbackProjectRef['surfaces'];
+  stack?: string;
+  stacks?: string[];
+  testSurfaces?: string[];
+  feedbackSdk?: string;
+  feedbackTransport?: string;
+  voiceCapabilities?: string[];
+  sttProvider?: string;
+  ttsProvider?: string;
+}): {
+  appName?: string;
+  app: AppInfo;
+  project?: FeedbackProjectRef;
+} {
+  let projectName = (opts?.projectName || '').trim() || undefined;
+  let bundleId = (opts?.bundleId || '').trim() || undefined;
+  let version: string | undefined;
+  let buildNumber: string | undefined;
+
+  if (isInsideYaverContainer()) {
+    // Every ambient lookup answers for the HOST here. Because the agent
+    // routes on bundle id first, letting Yaver's id through would resolve
+    // straight to Yaver's own repo and the guest's name would never be
+    // consulted — so nothing ambient is trusted in the container. The
+    // version is Yaver's too, and reporting it would only mislabel which
+    // build the report came from.
+    projectName = projectName || resolveInheritedGuestProjectName();
+  } else {
+    const ambient = resolveAppIdentity({ projectName, bundleId });
+    projectName = ambient.projectName;
+    bundleId = ambient.bundleId;
+    try {
+      const Constants = require('expo-constants').default ?? require('expo-constants');
+      const cfg = Constants?.expoConfig ?? Constants?.manifest ?? {};
+      version = Constants?.nativeAppVersion || cfg?.version;
+      buildNumber =
+        Constants?.nativeBuildVersion ||
+        cfg?.ios?.buildNumber ||
+        (cfg?.android?.versionCode != null ? String(cfg.android.versionCode) : undefined);
+    } catch {
+      // expo-constants not installed (bare RN). Version is cosmetic — the
+      // router keys off appName/bundleId, both of which survive without it.
+    }
+  }
+
+  const app: AppInfo = {};
+  if (bundleId) app.bundleId = bundleId;
+  if (version) app.version = version;
+  if (buildNumber) app.buildNumber = buildNumber;
+
+  if (!projectName && !bundleId) {
+    return { app };
+  }
+
+  const project: FeedbackProjectRef = { surface: opts?.surface ?? 'mobile' };
+  if (projectName) {
+    project.projectName = projectName;
+    project.appName = projectName;
+  }
+  // Note: projectPath is intentionally omitted — the agent ignores
+  // client-supplied paths on feedback reports and resolves them itself.
+  if (bundleId) project.bundleId = bundleId;
+  if (opts?.surfaces) project.surfaces = opts.surfaces;
+  if (opts?.stack) project.stack = opts.stack;
+  if (opts?.stacks) project.stacks = opts.stacks;
+  if (opts?.testSurfaces) project.testSurfaces = opts.testSurfaces;
+  if (opts?.feedbackSdk) project.feedbackSdk = opts.feedbackSdk;
+  if (opts?.feedbackTransport) project.feedbackTransport = opts.feedbackTransport;
+  if (opts?.voiceCapabilities) project.voiceCapabilities = opts.voiceCapabilities;
+  if (opts?.sttProvider) project.sttProvider = opts.sttProvider;
+  if (opts?.ttsProvider) project.ttsProvider = opts.ttsProvider;
+
+  return { appName: projectName, app, project };
+}
+
 /**
  * Translate a raw Go-agent error into something a user can act on.
  *
@@ -154,6 +310,25 @@ export class P2PClient {
     this.relayPassword = password;
   }
 
+  /** Read-only base URL — used by the voice vibe-coding path to probe
+   *  GET /voice/status before opening the stream. */
+  get agentBaseUrl(): string {
+    return this.baseUrl;
+  }
+
+  /** WebSocket URL for the agent's voice stream (WS /voice/stream). The
+   *  voice vibe-coding loop streams mic audio here and receives the
+   *  transcript + agent task + TTS frames back. */
+  voiceStreamUrl(): string {
+    return this.baseUrl.replace(/^http/, 'ws') + '/voice/stream';
+  }
+
+  /** Auth headers for the voice WS + status probe — same bearer (and
+   *  relay password) as every other agent request. */
+  voiceAuthHeaders(): Record<string, string> {
+    return this.authHeaders();
+  }
+
   /** Merge in Authorization + (optional) X-Relay-Password on top of a header block. */
   private authHeaders(extra: Record<string, string> = {}): Record<string, string> {
     const h: Record<string, string> = { ...extra };
@@ -222,6 +397,60 @@ export class P2PClient {
     return data.session as RunnerBrowserAuthSession;
   }
 
+  async getRunnerAuthStatus(): Promise<RunnerAuthStatusRow[]> {
+    const resp = await fetch(`${this.baseUrl}/runner-auth/status`, {
+      headers: this.authHeaders(),
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      throw new Error(`getRunnerAuthStatus HTTP ${resp.status}: ${text}`);
+    }
+    const data = await resp.json().catch(() => ({} as Record<string, unknown>));
+    return Array.isArray(data.runners) ? (data.runners as RunnerAuthStatusRow[]) : [];
+  }
+
+  async getOpenCodeConfig(): Promise<OpenCodeConfigSummary | null> {
+    const resp = await fetch(`${this.baseUrl}/runner/opencode/config`, {
+      headers: this.authHeaders(),
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      throw new Error(`getOpenCodeConfig HTTP ${resp.status}: ${text}`);
+    }
+    const data = await resp.json().catch(() => ({} as Record<string, unknown>));
+    return (data.config ?? null) as OpenCodeConfigSummary | null;
+  }
+
+  async saveOpenCodeConfig(patch: {
+    defaultAgent?: string;
+    model?: string;
+    smallModel?: string;
+    buildModel?: string;
+    planModel?: string;
+    providers?: Array<{
+      id: string;
+      name?: string;
+      baseUrl?: string;
+      apiKey?: string;
+      delete?: boolean;
+    }>;
+  }): Promise<{ ok: boolean; config?: OpenCodeConfigSummary; error?: string }> {
+    try {
+      const resp = await fetch(`${this.baseUrl}/runner/opencode/config`, {
+        method: 'POST',
+        headers: { ...this.authHeaders(), 'Content-Type': 'application/json' },
+        body: JSON.stringify(patch),
+      });
+      const data = await resp.json().catch(() => ({} as Record<string, unknown>));
+      if (!resp.ok) {
+        return { ok: false, error: (data.error as string | undefined) || `HTTP ${resp.status}` };
+      }
+      return { ok: true, config: data.config as OpenCodeConfigSummary | undefined };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
   async capabilitySnapshot(): Promise<CapabilitySnapshot | null> {
     try {
       const resp = await fetch(`${this.baseUrl}/capabilities/snapshot`, { headers: this.authHeaders() });
@@ -285,19 +514,22 @@ export class P2PClient {
 
   /** Health check — returns true if the agent is reachable. */
   async health(): Promise<boolean> {
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
     try {
       const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 3000);
+      timeoutId = setTimeout(() => controller.abort(), 3000);
+      unrefTimer(timeoutId);
 
       const response = await fetch(`${this.baseUrl}/health`, {
         method: 'GET',
         signal: controller.signal,
       });
 
-      clearTimeout(timeoutId);
       return response.ok;
     } catch {
       return false;
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
     }
   }
 
@@ -422,6 +654,10 @@ export class P2PClient {
       s2sReady: data.s2sReady ?? false,
       sttProvider: data.sttProvider ?? undefined,
       sttReady: data.sttReady ?? false,
+      ttsProvider: data.ttsProvider ?? undefined,
+      ttsReady: data.ttsReady ?? false,
+      enabled: data.enabled ?? false,
+      defaultProject: data.defaultProject ?? undefined,
     };
   }
 
@@ -466,6 +702,82 @@ export class P2PClient {
    * via the BlackBox command channel.
    * @param mode - "dev" for hot reload, "bundle" for native bundle rebuild
    */
+  /**
+   * Read the dev server's state so the overlay can decide WHICH reload
+   * actions to offer, and disable the rest with a reason.
+   *
+   * Returns null when the machine cannot be reached at all — which the
+   * caller must render as "not connected", never as "no dev server".
+   * Those are two different problems with two different fixes.
+   */
+  async getDevServerStatus(): Promise<DevServerSnapshot | null> {
+    try {
+      const resp = await fetch(`${this.baseUrl}${AGENT_ENDPOINTS.devStatus}`, {
+        headers: this.authHeaders(),
+      });
+      if (!resp.ok) return null;
+      const data = await resp.json().catch(() => ({} as Record<string, unknown>));
+      return {
+        running: data.running === true,
+        building: data.building === true,
+        framework: typeof data.framework === 'string' ? data.framework : undefined,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Trigger a reload with an EXPLICIT fast/full mode — no bundle fallback.
+   *
+   * `reloadApp('dev')` silently falls through to a bundle rebuild when the
+   * dev server is down, which is right for a one-button UX and wrong the
+   * moment the user picks between two named actions: someone who pressed
+   * "Full Reload" must not get a 60-second bundle rebuild without being
+   * told. So this method reports the failure instead, with a named cause.
+   *
+   * Auth: the SAME bearer used for the feedback POST. `/dev/reload` is
+   * registered under `authSDKOrGuest` in desktop/agent/httpserver.go and is
+   * already in the `guest-reload` SDK-token scope list — nothing widens.
+   */
+  async reloadWithMode(
+    mode: ReloadWireMode,
+    snapshot?: DevServerSnapshot | null,
+  ): Promise<ReloadAck> {
+    if (mode === 'bundle') return this.reloadApp('bundle');
+
+    let resp: Response;
+    try {
+      resp = await fetch(`${this.baseUrl}${RELOAD_PATH}`, {
+        method: 'POST',
+        headers: this.authHeaders({ 'Content-Type': 'application/json' }),
+        body: JSON.stringify({ mode }),
+      });
+    } catch (err) {
+      throw new Error(
+        describeReloadFailure(0, err instanceof Error ? err.message : '', snapshot),
+      );
+    }
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      throw new Error(describeReloadFailure(resp.status, text, snapshot));
+    }
+    const payload = await resp.json().catch(() => ({} as Record<string, unknown>));
+    const nativeChangesDetected = payload.nativeChangesDetected === true;
+    return {
+      ok: true,
+      mode: 'dev',
+      acknowledged: true,
+      nativeChangesDetected,
+      changeClass: typeof payload.changeClass === 'string' ? payload.changeClass : undefined,
+      message: nativeChangesDetected
+        ? 'Reload accepted, but native files changed — a rebuild is required.'
+        : mode === 'full'
+          ? 'Full reload requested.'
+          : 'Hot reload requested.',
+    };
+  }
+
   async reloadApp(
     mode: 'dev' | 'bundle' = 'bundle',
     opts?: { projectName?: string; bundleId?: string; projectPath?: string },

package/src/ShakeDetector.ts

@@ -83,6 +83,7 @@ export class ShakeDetector {
    * the `ShakeEvent` name a handful of third-party shake libraries emit.
    */
   private subscribeDevMenu(onShake: () => void): void {
+    if (typeof DeviceEventEmitter?.addListener !== 'function') return;
     const eventName = Platform.OS === 'ios' ? 'shakeEvent' : 'ShakeEvent';
     this.devMenuSub = DeviceEventEmitter.addListener(eventName, () => {
       this.fire(onShake);