yaver-feedback-react-native 0.8.12 → 0.9.0

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,4 @@
-import { CapabilitySnapshot, FeedbackBundle, IncidentEvent, OperationState, RunnerBrowserAuthSession, TestSession, VoiceCapability } from './types';
+import { CapabilitySnapshot, FeedbackBundle, IncidentEvent, OpenCodeConfigSummary, OperationState, RunnerBrowserAuthSession, RunnerAuthStatusRow, TestSession, VoiceCapability } from './types';
 export interface FeedbackEvent {
     type: string;
     timestamp: string;
@@ -12,6 +12,22 @@ export interface ReloadAck {
     nativeChangesDetected?: boolean;
     changeClass?: string;
 }
+/**
+ * Try to resolve `{projectName, bundleId}` for the running app so the
+ * agent can map the reload request to a MobileProject in its scan
+ * cache. Order: caller-supplied opts → Expo Constants → react-native
+ * NativeModules. None of the lookups throw — missing data just means
+ * the agent will fall back to its own dev-server resolution.
+ */
+export declare function resolveAppIdentity(opts?: {
+    projectName?: string;
+    bundleId?: string;
+    projectPath?: string;
+}): {
+    projectName?: string;
+    bundleId?: string;
+    projectPath?: string;
+};
 /**
  * Lightweight P2P HTTP client for communicating with a Yaver agent.
  *
@@ -35,6 +51,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;
     /**
@@ -53,6 +79,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;
@@ -227,5 +273,60 @@ export declare class P2PClient {
         timestamp?: number;
     }): Promise<boolean>;
     /** Internal helper for authenticated GET/POST requests. */
+    /**
+     * Convergence point for ALL feedback surfaces — Tasks tab, in-Yaver
+     * native pane, and this standalone SDK all POST the same shape to
+     * `/tasks`. Wraps the user's text with the shared prompt builder
+     * (see `_core/buildFeedbackPrompt`) so every surface conditions
+     * the AI the same way.
+     *
+     * Returns the agent's response payload (`taskId`, etc.) so callers
+     * can wire `streamTaskOutput()` next for live transcript.
+     *
+     * Inputs:
+     *   - userPrompt          what the user typed
+     *   - projectName / path  optional Hot-Reload project context
+     *   - runner / model      optional preferred coding agent + model
+     *   - screenshotBase64    optional JPEG base64 (no `data:` prefix)
+     *   - imageMimeType       defaults to "image/jpeg"
+     */
+    createFeedbackTask(input: {
+        userPrompt: string;
+        projectName?: string;
+        projectPath?: string;
+        runner?: string;
+        model?: string;
+        screenshotBase64?: string;
+        imageMimeType?: string;
+    }): Promise<{
+        taskId: string;
+        raw?: unknown;
+    }>;
+    /**
+     * Subscribe to a task's live stdout/stderr stream. Returns an abort
+     * function — call it to detach. The agent emits NDJSON lines on
+     * `/tasks/{id}/output`; we surface each line via `onLine`.
+     *
+     * `onComplete` fires when the agent reports the task entered a
+     * terminal status (completed / failed / stopped). After that the
+     * caller should stop calling abort().
+     *
+     * Robust to fetch streaming on Hermes (streams Body via Response.
+     * body.getReader on platforms that support it; falls back to
+     * polling `/tasks/{id}` every 750 ms if streaming isn't available).
+     */
+    streamTaskOutput(taskId: string, onLine: (line: string) => void, onComplete: (status: string) => void): () => void;
+    /**
+     * Send a follow-up message into an existing task — multi-turn vibe
+     * chat. The agent's `/tasks/{id}/resume` accepts the same shape as
+     * `/tasks` (description / userPrompt / images), and the existing
+     * task picks back up with the same runner + project context.
+     */
+    resumeTask(input: {
+        taskId: string;
+        userPrompt: string;
+        screenshotBase64?: string;
+        imageMimeType?: string;
+    }): Promise<void>;
     private request;
 }

package/dist/P2PClient.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.P2PClient = void 0;
+exports.resolveAppIdentity = resolveAppIdentity;
 const react_native_1 = require("react-native");
 /**
  * Try to resolve `{projectName, bundleId}` for the running app so the
@@ -109,6 +143,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 };
@@ -174,6 +224,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() });
@@ -356,6 +445,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,
         };
     }
     /**
@@ -670,6 +763,186 @@ class P2PClient {
         }
     }
     /** Internal helper for authenticated GET/POST requests. */
+    /**
+     * Convergence point for ALL feedback surfaces — Tasks tab, in-Yaver
+     * native pane, and this standalone SDK all POST the same shape to
+     * `/tasks`. Wraps the user's text with the shared prompt builder
+     * (see `_core/buildFeedbackPrompt`) so every surface conditions
+     * the AI the same way.
+     *
+     * Returns the agent's response payload (`taskId`, etc.) so callers
+     * can wire `streamTaskOutput()` next for live transcript.
+     *
+     * Inputs:
+     *   - userPrompt          what the user typed
+     *   - projectName / path  optional Hot-Reload project context
+     *   - runner / model      optional preferred coding agent + model
+     *   - screenshotBase64    optional JPEG base64 (no `data:` prefix)
+     *   - imageMimeType       defaults to "image/jpeg"
+     */
+    async createFeedbackTask(input) {
+        const { buildFeedbackPrompt } = await Promise.resolve().then(() => __importStar(require('./_core/buildFeedbackPrompt')));
+        const hasScreenshot = !!(input.screenshotBase64 && input.screenshotBase64.length > 0);
+        const description = buildFeedbackPrompt({
+            userPrompt: input.userPrompt,
+            projectName: input.projectName,
+            projectPath: input.projectPath,
+            hasScreenshot,
+        });
+        const images = [];
+        if (hasScreenshot && input.screenshotBase64) {
+            images.push({
+                base64: input.screenshotBase64,
+                mimeType: input.imageMimeType ?? 'image/jpeg',
+                filename: `yaver-feedback-${Math.floor(Date.now() / 1000)}.jpg`,
+            });
+        }
+        const body = {
+            title: input.userPrompt.slice(0, 80),
+            description,
+            userPrompt: input.userPrompt,
+            source: 'mobile-feedback',
+            images,
+        };
+        if (input.projectPath && input.projectPath.trim())
+            body.workDir = input.projectPath.trim();
+        if (input.projectName && input.projectName.trim())
+            body.projectName = input.projectName.trim();
+        if (input.runner && input.runner.trim())
+            body.runner = input.runner.trim();
+        if (input.model && input.model.trim())
+            body.model = input.model.trim();
+        const resp = await fetch(`${this.baseUrl}/tasks`, {
+            method: 'POST',
+            headers: this.authHeaders({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify(body),
+        });
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => '');
+            throw new Error(`createFeedbackTask HTTP ${resp.status}: ${text}`);
+        }
+        const json = (await resp.json().catch(() => ({})));
+        if (!json.taskId) {
+            throw new Error('createFeedbackTask: agent did not return taskId');
+        }
+        return { taskId: json.taskId, raw: json };
+    }
+    /**
+     * Subscribe to a task's live stdout/stderr stream. Returns an abort
+     * function — call it to detach. The agent emits NDJSON lines on
+     * `/tasks/{id}/output`; we surface each line via `onLine`.
+     *
+     * `onComplete` fires when the agent reports the task entered a
+     * terminal status (completed / failed / stopped). After that the
+     * caller should stop calling abort().
+     *
+     * Robust to fetch streaming on Hermes (streams Body via Response.
+     * body.getReader on platforms that support it; falls back to
+     * polling `/tasks/{id}` every 750 ms if streaming isn't available).
+     */
+    streamTaskOutput(taskId, onLine, onComplete) {
+        const ctrl = new AbortController();
+        let closed = false;
+        const close = () => {
+            if (closed)
+                return;
+            closed = true;
+            try {
+                ctrl.abort();
+            }
+            catch { /* ignore */ }
+        };
+        (async () => {
+            try {
+                const resp = await fetch(`${this.baseUrl}/tasks/${encodeURIComponent(taskId)}/output`, {
+                    method: 'GET',
+                    headers: this.authHeaders({ Accept: 'text/event-stream' }),
+                    signal: ctrl.signal,
+                });
+                if (!resp.ok) {
+                    throw new Error(`streamTaskOutput HTTP ${resp.status}`);
+                }
+                // RN Hermes: Response.body may be undefined. Fall back to
+                // polling final state.
+                const body = resp.body;
+                if (!body || typeof body.getReader !== 'function') {
+                    await pollTaskUntilDone(this, taskId, onLine, onComplete, () => closed);
+                    return;
+                }
+                const reader = body.getReader();
+                const decoder = new TextDecoder();
+                let buf = '';
+                while (!closed) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    buf += decoder.decode(value, { stream: true });
+                    // SSE frames are separated by \n\n; payloads are `data: <json>\n`.
+                    let idx = buf.indexOf('\n\n');
+                    while (idx >= 0) {
+                        const frame = buf.slice(0, idx);
+                        buf = buf.slice(idx + 2);
+                        for (const line of frame.split('\n')) {
+                            if (line.startsWith('data:')) {
+                                const payload = line.slice(5).trim();
+                                if (payload)
+                                    onLine(payload);
+                            }
+                        }
+                        idx = buf.indexOf('\n\n');
+                    }
+                }
+                // Stream closed cleanly — query final status.
+                try {
+                    const final = await fetch(`${this.baseUrl}/tasks/${encodeURIComponent(taskId)}`, { headers: this.authHeaders() });
+                    const j = (await final.json().catch(() => ({})));
+                    onComplete(j.status ?? 'completed');
+                }
+                catch {
+                    onComplete('completed');
+                }
+            }
+            catch (e) {
+                if (!closed) {
+                    // Surface the error via onLine so the UI shows it inline,
+                    // then mark complete so the caller stops waiting.
+                    onLine(`__error__: ${e instanceof Error ? e.message : String(e)}`);
+                    onComplete('failed');
+                }
+            }
+        })();
+        return close;
+    }
+    /**
+     * Send a follow-up message into an existing task — multi-turn vibe
+     * chat. The agent's `/tasks/{id}/resume` accepts the same shape as
+     * `/tasks` (description / userPrompt / images), and the existing
+     * task picks back up with the same runner + project context.
+     */
+    async resumeTask(input) {
+        const images = [];
+        if (input.screenshotBase64 && input.screenshotBase64.length > 0) {
+            images.push({
+                base64: input.screenshotBase64,
+                mimeType: input.imageMimeType ?? 'image/jpeg',
+                filename: `yaver-feedback-followup-${Math.floor(Date.now() / 1000)}.jpg`,
+            });
+        }
+        const resp = await fetch(`${this.baseUrl}/tasks/${encodeURIComponent(input.taskId)}/resume`, {
+            method: 'POST',
+            headers: this.authHeaders({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify({
+                description: input.userPrompt,
+                userPrompt: input.userPrompt,
+                source: 'mobile-feedback',
+                images,
+            }),
+        });
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => '');
+            throw new Error(`resumeTask HTTP ${resp.status}: ${text}`);
+        }
+    }
     async request(method, path) {
         const response = await fetch(`${this.baseUrl}${path}`, {
             method,
@@ -683,3 +956,43 @@ class P2PClient {
     }
 }
 exports.P2PClient = P2PClient;
+/**
+ * Fallback path used by streamTaskOutput when the platform's fetch
+ * returns a Response with no streaming body (older Hermes builds).
+ * Polls `/tasks/{id}` every 750 ms; surfaces newly-appended output
+ * lines via `onLine`, fires `onComplete` when status is terminal.
+ */
+async function pollTaskUntilDone(client, taskId, onLine, onComplete, isClosed) {
+    // Use bracket access to read the private baseUrl/authHeaders without
+    // making them public — confined to this file's scope.
+    const c = client;
+    let lastLen = 0;
+    for (;;) {
+        if (isClosed())
+            return;
+        try {
+            const r = await fetch(`${c.baseUrl}/tasks/${encodeURIComponent(taskId)}`, {
+                headers: c.authHeaders(),
+            });
+            const j = (await r.json().catch(() => ({})));
+            const all = Array.isArray(j.output) ? j.output : (j.output ? [j.output] : []);
+            const flat = all.join('\n');
+            if (flat.length > lastLen) {
+                const fresh = flat.slice(lastLen);
+                lastLen = flat.length;
+                for (const ln of fresh.split('\n')) {
+                    if (ln.length > 0)
+                        onLine(ln);
+                }
+            }
+            if (j.status && ['completed', 'failed', 'stopped'].includes(j.status)) {
+                onComplete(j.status);
+                return;
+            }
+        }
+        catch {
+            // Transient — keep polling.
+        }
+        await new Promise((res) => setTimeout(res, 750));
+    }
+}

package/dist/VibeChatScreen.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { P2PClient } from './P2PClient';
+export type VibeTurnRole = 'user' | 'assistant' | 'status';
+export interface VibeTurn {
+    id: string;
+    role: VibeTurnRole;
+    text: string;
+    timestamp: number;
+}
+interface Props {
+    client: P2PClient;
+    initialTaskId: string;
+    initialUserPrompt: string;
+    onClose?: () => void;
+    /** 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, project, model, runner, }: Props): React.JSX.Element;
+export {};