@agent-native/core 0.90.1 → 0.90.2

package/corpus/templates/slides/app/components/editor/EditorToolbar.tsx

@@ -64,6 +64,7 @@ import {
   type AspectRatio,
   DEFAULT_ASPECT_RATIO,
 } from "@/lib/aspect-ratios";
+import { parseUploadResponse } from "@/lib/upload-response";
 import { shortcutLabel } from "@/lib/utils";
 
 import { ExportMenu } from "./ExportMenu";
@@ -331,7 +332,15 @@ export default function EditorToolbar({
         method: "POST",
         body: formData,
       });
-      const uploadData = await uploadRes.json();
+      // R83 — guard the parse: a failed upload can come back as a non-JSON
+      // body (upstream proxy/platform error page, plaintext "Internal
+      // Error", etc.). Parsing before the ok check used to throw a raw
+      // "Unexpected token ... is not valid JSON" SyntaxError into this
+      // toast instead of the clean message below.
+      const uploadData = await parseUploadResponse(
+        uploadRes,
+        t("editorToolbar.uploadFailed"),
+      );
       if (!uploadRes.ok) {
         throw new Error(uploadData?.error || t("editorToolbar.uploadFailed"));
       }
@@ -352,7 +361,11 @@ export default function EditorToolbar({
           }),
         },
       );
-      const importData = await importRes.json();
+      // R83 — same parse guard as the upload response above.
+      const importData = await parseUploadResponse(
+        importRes,
+        t("editorToolbar.importFailed"),
+      );
       if (!importRes.ok || importData?.error) {
         throw new Error(importData?.error || t("editorToolbar.importFailed"));
       }

package/corpus/templates/slides/app/components/editor/ImportButton.tsx

@@ -7,6 +7,7 @@ import {
   TooltipContent,
   TooltipTrigger,
 } from "@/components/ui/tooltip";
+import { parseUploadResponse } from "@/lib/upload-response";
 
 interface ImportButtonProps {
   deckId?: string;
@@ -29,7 +30,15 @@ export function ImportButton({ deckId, onImportComplete }: ImportButtonProps) {
         method: "POST",
         body: formData,
       });
-      const uploadData = await uploadRes.json();
+      // R83 — guard the parse: a failed upload can come back as a non-JSON
+      // body (upstream proxy/platform error page, plaintext "Internal
+      // Error", etc.). Calling uploadRes.json() unconditionally used to
+      // throw a raw "Unexpected token ... is not valid JSON" SyntaxError
+      // here instead of a clean, catchable failure.
+      const uploadData = await parseUploadResponse(uploadRes, "Upload failed");
+      if (!uploadRes.ok) {
+        throw new Error(uploadData.error || "Upload failed");
+      }
 
       await fetch(agentNativePath("/_agent-native/actions/import-file"), {
         method: "POST",

package/corpus/templates/slides/app/lib/upload-response.ts

@@ -0,0 +1,71 @@
+// R83 — safe fetch-response parsing for file upload flows.
+//
+// A failed upload can come back as a non-JSON body (an upstream proxy or
+// platform crash page, a plaintext "Internal Error", etc.). Calling
+// `response.json()` unconditionally on a body like that throws a raw
+// `SyntaxError` ("Unexpected token 'I', "Internal E"... is not valid JSON"),
+// which then surfaces verbatim in an import/upload toast instead of a clean
+// message. Route every parse through this helper so a non-JSON body always
+// degrades to a readable message instead of leaking a raw parser error.
+
+export interface UploadResponseEnvelope {
+  error?: string;
+  [key: string]: unknown;
+}
+
+/** Minimal shape `parseUploadResponse` needs — a subset of the real `Response`. */
+export interface JsonParsableResponse {
+  ok: boolean;
+  status: number;
+  text(): Promise<string>;
+}
+
+const MAX_TOAST_BODY_CHARS = 160;
+
+function truncateForToast(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.length <= MAX_TOAST_BODY_CHARS) return trimmed;
+  return `${trimmed.slice(0, MAX_TOAST_BODY_CHARS)}…`;
+}
+
+/**
+ * Parses a fetch `Response` as JSON only when it is actually JSON, and
+ * always resolves rather than throwing a parse error for a failure
+ * response — the fallback branch folds an unparsable failure body into the
+ * same `{ error }` shape a well-behaved server route would have sent,
+ * truncating an overlong body so a raw HTML/proxy error page doesn't blow up
+ * the toast description.
+ *
+ * Success responses are still expected to be real JSON: a genuinely broken
+ * 200 throws the underlying SyntaxError rather than silently returning `{}`,
+ * so that failure mode stays loud instead of masquerading as an empty
+ * successful import.
+ */
+export async function parseUploadResponse<
+  T extends UploadResponseEnvelope = UploadResponseEnvelope,
+>(response: JsonParsableResponse, fallbackErrorMessage: string): Promise<T> {
+  const raw = await response.text();
+  const looksJson = /^\s*[{[]/.test(raw);
+  if (!looksJson) {
+    if (response.ok) {
+      throw new SyntaxError(
+        `Expected a JSON response but received: ${truncateForToast(raw)}`,
+      );
+    }
+    return {
+      error: raw.trim()
+        ? `${fallbackErrorMessage}: ${truncateForToast(raw)}`
+        : fallbackErrorMessage,
+    } as T;
+  }
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    if (response.ok) {
+      throw new SyntaxError(
+        `Expected a JSON response but received: ${truncateForToast(raw)}`,
+      );
+    }
+    return { error: fallbackErrorMessage } as T;
+  }
+}

package/dist/client/AgentPanel.js

@@ -1004,7 +1004,7 @@ function URLSync({ browserTabId }) {
             // Replace rather than push so repeated agent URL updates don't
             // clutter the history stack and can't trigger extra remounts from
             // router navigation lifecycle.
-            navigate(url, { replace: true, flushSync: true });
+            window.setTimeout(() => navigate(url, { replace: true }), 0);
         }
         catch {
             // Malformed command — ignore.