yaver-feedback-react-native 0.8.13 → 0.9.2

package/dist/MachinePickerScreen.js

@@ -104,7 +104,14 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
             return;
         }
         const direct = await (0, auth_1.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;
@@ -131,9 +138,11 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
             ? '#f59e0b'
             : effectivelyReachable
                 ? '#22c55e'
-                : explicitlyOffline || !device.isOnline
-                    ? '#ef4444'
-                    : '#22c55e';
+                : device.isOnline
+                    ? '#f59e0b'
+                    : explicitlyOffline || !device.isOnline
+                        ? '#ef4444'
+                        : '#22c55e';
         // Derive a single short status phrase the user can act on.
         let statusLine = device.platform;
         if (probe === undefined) {
@@ -150,7 +159,7 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
                 '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';

package/dist/P2PClient.d.ts

@@ -1,4 +1,5 @@
-import { CapabilitySnapshot, FeedbackBundle, IncidentEvent, OperationState, RunnerBrowserAuthSession, TestSession, VoiceCapability } from './types';
+import { AppInfo, CapabilitySnapshot, FeedbackBundle, FeedbackProjectRef, IncidentEvent, OpenCodeConfigSummary, OperationState, RunnerBrowserAuthSession, RunnerAuthStatusRow, TestSession, VoiceCapability } from './types';
+import type { DevServerSnapshot, ReloadWireMode } from './reloadActions';
 export interface FeedbackEvent {
     type: string;
     timestamp: string;
@@ -28,6 +29,45 @@ export declare function resolveAppIdentity(opts?: {
     bundleId?: string;
     projectPath?: string;
 };
+/**
+ * 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 declare 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;
+};
 /**
  * Lightweight P2P HTTP client for communicating with a Yaver agent.
  *
@@ -51,6 +91,16 @@ export declare class P2PClient {
     setAuthToken(token: string): void;
     /** Update the relay password (used for managed-relay baseUrls). */
     setRelayPassword(password: string): void;
+    /** Read-only base URL — used by the voice vibe-coding path to probe
+     *  GET /voice/status before opening the stream. */
+    get agentBaseUrl(): string;
+    /** 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;
+    /** Auth headers for the voice WS + status probe — same bearer (and
+     *  relay password) as every other agent request. */
+    voiceAuthHeaders(): Record<string, string>;
     /** Merge in Authorization + (optional) X-Relay-Password on top of a header block. */
     private authHeaders;
     /**
@@ -69,6 +119,26 @@ export declare class P2PClient {
      *  the SDK still exposes it for symmetry with mobile/src/components/
      *  RunnerAuthModal.tsx and the Swift YaverRunnerAuthFlowPane. */
     submitRunnerBrowserAuthCode(sessionId: string, code: string): Promise<RunnerBrowserAuthSession>;
+    getRunnerAuthStatus(): Promise<RunnerAuthStatusRow[]>;
+    getOpenCodeConfig(): Promise<OpenCodeConfigSummary | null>;
+    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;
+    }>;
     capabilitySnapshot(): Promise<CapabilitySnapshot | null>;
     incidents(opts?: {
         category?: string;
@@ -133,6 +203,29 @@ export declare 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.
+     */
+    getDevServerStatus(): Promise<DevServerSnapshot | 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.
+     */
+    reloadWithMode(mode: ReloadWireMode, snapshot?: DevServerSnapshot | null): Promise<ReloadAck>;
     reloadApp(mode?: 'dev' | 'bundle', opts?: {
         projectName?: string;
         bundleId?: string;

package/dist/P2PClient.js

@@ -35,7 +35,16 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.P2PClient = void 0;
 exports.resolveAppIdentity = resolveAppIdentity;
+exports.resolveReportIdentity = resolveReportIdentity;
 const react_native_1 = require("react-native");
+const endpoints_1 = require("./_core/endpoints");
+const reloadActions_1 = require("./reloadActions");
+function unrefTimer(timer) {
+    const maybeNodeTimer = timer;
+    if (typeof maybeNodeTimer.unref === 'function') {
+        maybeNodeTimer.unref();
+    }
+}
 /**
  * Try to resolve `{projectName, bundleId}` for the running app so the
  * agent can map the reload request to a MobileProject in its scan
@@ -84,6 +93,140 @@ function resolveAppIdentity(opts) {
         out.projectPath = projectPath;
     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() {
+    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() {
+    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.
+ */
+function resolveReportIdentity(opts) {
+    let projectName = (opts?.projectName || '').trim() || undefined;
+    let bundleId = (opts?.bundleId || '').trim() || undefined;
+    let version;
+    let buildNumber;
+    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 = {};
+    if (bundleId)
+        app.bundleId = bundleId;
+    if (version)
+        app.version = version;
+    if (buildNumber)
+        app.buildNumber = buildNumber;
+    if (!projectName && !bundleId) {
+        return { app };
+    }
+    const project = { 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.
  *
@@ -143,6 +286,22 @@ class P2PClient {
     setRelayPassword(password) {
         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() {
+        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() {
+        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() {
+        return this.authHeaders();
+    }
     /** Merge in Authorization + (optional) X-Relay-Password on top of a header block. */
     authHeaders(extra = {}) {
         const h = { ...extra };
@@ -208,6 +367,45 @@ class P2PClient {
         const data = await resp.json();
         return data.session;
     }
+    async getRunnerAuthStatus() {
+        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(() => ({}));
+        return Array.isArray(data.runners) ? data.runners : [];
+    }
+    async getOpenCodeConfig() {
+        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(() => ({}));
+        return (data.config ?? null);
+    }
+    async saveOpenCodeConfig(patch) {
+        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(() => ({}));
+            if (!resp.ok) {
+                return { ok: false, error: data.error || `HTTP ${resp.status}` };
+            }
+            return { ok: true, config: data.config };
+        }
+        catch (err) {
+            return { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
     async capabilitySnapshot() {
         try {
             const resp = await fetch(`${this.baseUrl}/capabilities/snapshot`, { headers: this.authHeaders() });
@@ -272,19 +470,24 @@ class P2PClient {
     }
     /** Health check — returns true if the agent is reachable. */
     async health() {
+        let timeoutId = 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);
+        }
     }
     /** Get agent info (hostname, version, platform). */
     async info() {
@@ -390,6 +593,10 @@ 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,
         };
     }
     /**
@@ -429,6 +636,78 @@ 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() {
+        try {
+            const resp = await fetch(`${this.baseUrl}${endpoints_1.AGENT_ENDPOINTS.devStatus}`, {
+                headers: this.authHeaders(),
+            });
+            if (!resp.ok)
+                return null;
+            const data = await resp.json().catch(() => ({}));
+            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, snapshot) {
+        if (mode === 'bundle')
+            return this.reloadApp('bundle');
+        let resp;
+        try {
+            resp = await fetch(`${this.baseUrl}${reloadActions_1.RELOAD_PATH}`, {
+                method: 'POST',
+                headers: this.authHeaders({ 'Content-Type': 'application/json' }),
+                body: JSON.stringify({ mode }),
+            });
+        }
+        catch (err) {
+            throw new Error((0, reloadActions_1.describeReloadFailure)(0, err instanceof Error ? err.message : '', snapshot));
+        }
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => '');
+            throw new Error((0, reloadActions_1.describeReloadFailure)(resp.status, text, snapshot));
+        }
+        const payload = await resp.json().catch(() => ({}));
+        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 = 'bundle', opts) {
         // Default path: always rebuild a fresh Hermes bundle.
         //

package/dist/ShakeDetector.js

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

package/dist/VibeChatScreen.d.ts

@@ -15,6 +15,11 @@ interface Props {
     /** Called when the user taps Reload after a task completes — uses
      *  P2PClient.reloadApp() with the active project context. */
     onReload?: () => Promise<void>;
+    /** Optional context forwarded to the voice stream so the agent runs
+     *  the task against the right project / runner / model. */
+    project?: string;
+    model?: string;
+    runner?: string;
 }
-export declare function VibeChatScreen({ client, initialTaskId, initialUserPrompt, onClose, onReload, }: Props): React.JSX.Element;
+export declare function VibeChatScreen({ client, initialTaskId, initialUserPrompt, onClose, onReload, project, model, runner, }: Props): React.JSX.Element;
 export {};