shadok-ai 0.13.15 → 0.14.1

package/README.md

@@ -345,12 +345,21 @@ location / {
     proxy_set_header Upgrade $http_upgrade;
     proxy_set_header Connection "upgrade";
     proxy_set_header Host $host;
+    client_max_body_size 50m;   # match the server's paste limit
 }
 ```
 
 The client picks `wss://` on its own when the page is HTTPS, so there is nothing
 to configure on that side.
 
+**Upload size.** The server accepts a pasted/dropped file up to 50 MB, but
+nginx's default `client_max_body_size` is **1 MB** — a full-page screenshot
+sails past that, and nginx answers its OWN `413` HTML page **before** the request
+reaches the cockpit. Raise the limit to match (`client_max_body_size 50m;`),
+or a paste larger than 1 MB fails at the proxy. The cockpit now shows a plain
+"too large" instead of a JSON parser error, but the file still won't go through
+until the proxy allows it.
+
 **Idle timeout.** A resting agent's `/ws` carries no traffic, and proxies
 idle-close a quiet socket (nginx `proxy_read_timeout`, 60s by default;
 Cloudflare ~100s) — the symptom is a cockpit that keeps flashing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shadok-ai",
-  "version": "0.13.15",
+  "version": "0.14.1",
   "main": "dist/session.js",
   "scripts": {
     "test": "node --import tsx --test test/*.ts context/*/test/*.test.mjs",

package/public/index.html

@@ -2351,6 +2351,8 @@
   window.bangCommands = bangCommands;
   import { claudeUpdateState } from "/update-ready.js?v=__ASSET_V__";
   window.claudeUpdateState = claudeUpdateState;
+  import { uploadFailure } from "/upload.js?v=__ASSET_V__";
+  window.uploadFailure = uploadFailure;
   window.MODEL_CHOICES = MODEL_CHOICES;
   window.composeModel = composeModel;
   window.pickChannelSource = pickChannelSource;
@@ -2446,6 +2448,8 @@
     // cache. instanceKey is stamped synchronously, so the stub can namespace.
     dirKey: (base) => (instanceKey ? base + ":" + instanceKey : base),
     serverSwapped: (pageKey, serverKey) => !!pageKey && !!serverKey && pageKey !== serverKey,
+    uploadFailure: (status, contentType) =>
+      /json/i.test(contentType || "") ? null : status === 413 ? "too large (over the server's upload limit)" : `upload failed (HTTP ${status || "?"})`,
   };
   for (const [name, stub] of Object.entries(BRIDGE_STUBS)) {
     if (typeof window[name] !== "function") { stub.__stub = true; window[name] = stub; }
@@ -6455,6 +6459,12 @@
         },
         body: file,
       });
+      // A proxy rejects an oversized body with a 413 text/html page that never
+      // reaches /paste — parsing THAT as JSON is what showed the user
+      // "Unexpected token '<'" instead of "too large". Decide from the status
+      // first; only parse when the response is actually ours (JSON).
+      const fail = window.uploadFailure(r.status, r.headers.get("content-type"));
+      if (fail) throw new Error(fail);
       const j = await r.json();
       if (!r.ok || !j.line) throw new Error(j.error || `HTTP ${r.status}`);
       promptInput.value = promptInput.value.replace(mark, j.line);

package/public/upload.js

@@ -0,0 +1,24 @@
+// Pure helper for the composer's file upload (paste / drag-and-drop). ESM:
+// loaded by the browser (bridged to window) AND imported by test/upload.test.ts.
+//
+// Why it exists: `attachFile` POSTs to /paste and calls `r.json()`. A reverse
+// proxy (nginx, default `client_max_body_size` 1 MB) rejects an oversized body
+// with its OWN error page — `413 text/html` — which never reaches our JSON
+// route. `r.json()` on that HTML threw `Unexpected token '<', "<html>…"`, and
+// the composer surfaced the raw parser error instead of a plain "too large".
+// The server itself accepts up to PASTE_LIMIT (50 MB), so this is always the
+// proxy, and the fix is to read the STATUS, not the body.
+
+/**
+ * Should the caller refuse to parse this /paste response, and with what message?
+ * Returns null for a JSON response (success OR our `{error}` body — the caller's
+ * existing `r.json()` path handles both); otherwise a human string, because a
+ * non-JSON response is a proxy/gateway page, never something to `JSON.parse`.
+ * @param {number} status - the HTTP status
+ * @param {string|null|undefined} contentType - the response Content-Type header
+ */
+export function uploadFailure(status, contentType) {
+  if (/json/i.test(contentType || "")) return null; // ours — let the caller read it
+  if (status === 413) return "too large (over the server's upload limit)";
+  return `upload failed (HTTP ${status || "?"})`;
+}