yaver-feedback-react-native 0.8.11 → 0.8.13

package/dist/FloatingButton.js

@@ -41,6 +41,14 @@ const FixReport_1 = require("./FixReport");
 const BlackBox_1 = require("./BlackBox");
 const DEFAULT_SIZE = 40;
 const DEFAULT_COLOR = '#6366f1';
+// Tablet detection — short-edge dp >= 600 means iPad / 7"+ Android
+// tablet / Z Fold open. The SDK has no app-side responsive context
+// to lean on (it's a guest in third-party apps), so we infer
+// locally and bump the button + panel to tablet sizes.
+const TABLET_SHORT_EDGE = 600;
+function isTabletWindow(width, height) {
+    return Math.min(width, height) >= TABLET_SHORT_EDGE;
+}
 const DEFAULT_PANEL_BG = '#2d2d2d';
 /**
  * Draggable debug console button for the Yaver Feedback SDK.
@@ -71,7 +79,16 @@ const DEFAULT_PANEL_BG = '#2d2d2d';
  * - **"quit"** → disable the SDK
  */
 const FloatingButton = ({ onPress, initialPosition, size = DEFAULT_SIZE, color = DEFAULT_COLOR, showStatusDot = true, style: stylePreset = 'terminal', icon, agentUrl: agentUrlProp, authToken: authTokenProp, healthCheckInterval = 5000, panelBackgroundColor, }) => {
-    const { width: screenWidth } = react_native_1.Dimensions.get('window');
+    // Read window size live so the SDK overlay re-pins itself when
+    // the host app rotates or splits. The legacy snapshot via
+    // Dimensions.get only ran once and parked the button off-screen
+    // after orientation changes on iPad.
+    const { width: screenWidth, height: screenHeight } = (0, react_native_1.useWindowDimensions)();
+    const isTablet = isTabletWindow(screenWidth, screenHeight);
+    // Tablets get a larger touch target and a wider panel — phones
+    // keep the existing 40 / 280 defaults so guest apps aren't
+    // disrupted on small screens.
+    const effectiveSize = isTablet ? Math.max(size, 52) : size;
     const defaultX = initialPosition?.x ?? 10;
     const defaultY = initialPosition?.y ?? 90;
     const pan = (0, react_1.useRef)(new react_native_1.Animated.ValueXY({ x: defaultX, y: defaultY })).current;
@@ -516,7 +533,12 @@ const FloatingButton = ({ onPress, initialPosition, size = DEFAULT_SIZE, color =
     const isTerminal = stylePreset === 'terminal';
     const buttonIcon = icon ?? 'y';
     const btnBg = isConnected ? color : `${color}88`;
-    const panelWidth = fullSize ? screenWidth - 24 : 280;
+    // Panel sizing — tablets get a wider compact panel (420) and a
+    // capped full-size panel (max 720 instead of full window) so the
+    // overlay doesn't dwarf the host app on a 12.9" iPad.
+    const compactPanelWidth = isTablet ? 420 : 280;
+    const fullPanelWidth = isTablet ? Math.min(screenWidth - 24, 720) : screenWidth - 24;
+    const panelWidth = fullSize ? fullPanelWidth : compactPanelWidth;
     return (<react_native_1.Animated.View style={[s.root, { transform: [{ translateX: pan.x }, { translateY: pan.y }] }]} {...panResponder.panHandlers}>
       {/* Console panel */}
       {chatOpen && (<react_native_1.View style={[
@@ -642,7 +664,7 @@ const FloatingButton = ({ onPress, initialPosition, size = DEFAULT_SIZE, color =
       <react_native_1.TouchableOpacity style={[
             s.button,
             isTerminal ? s.buttonTerminal : s.buttonMinimal,
-            { backgroundColor: btnBg, width: size, height: size },
+            { backgroundColor: btnBg, width: effectiveSize, height: effectiveSize },
             !isTerminal && { borderRadius: size / 2 },
         ]} activeOpacity={0.7} onPress={handleTap}>
         <react_native_1.Text style={[s.buttonIcon, isTerminal && s.mono, { fontSize: 22 }]}>

package/dist/P2PClient.d.ts

@@ -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.
  *
@@ -227,5 +243,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
@@ -670,6 +704,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 +897,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,20 @@
+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>;
+}
+export declare function VibeChatScreen({ client, initialTaskId, initialUserPrompt, onClose, onReload, }: Props): React.JSX.Element;
+export {};