@barivia/barsom-mcp 0.11.0 → 0.11.1

package/dist/shared.js

@@ -2,6 +2,10 @@
  * Shared configuration, helpers, types, and state for the MCP proxy.
  */
 import fs from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { createGzip } from "node:zlib";
+import { createHash } from "node:crypto";
+import { Readable } from "node:stream";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { logInfo } from "./logger.js";
@@ -20,7 +24,7 @@ export const RETRYABLE_STATUS = new Set([502, 503, 504]);
  * X-Barsom-Client-Version so the server can annotate tool guidance with the
  * wrapper version each action requires. Keep in sync with package.json on bump.
  */
-export const CLIENT_VERSION = "0.11.0";
+export const CLIENT_VERSION = "0.11.1";
 /** User-facing links; keep aligned with barivia.se / api.barivia.se. */
 export const PUBLIC_SITE_ORIGIN = "https://barivia.se";
 /** Self-serve account dashboard (manage plan, billing, and API keys). */
@@ -29,6 +33,12 @@ export const PUBLIC_DASHBOARD_URL = `${PUBLIC_SITE_ORIGIN}/dashboard`;
 export const POLL_DERIVE_MAX_MS = 120_000;
 /** Large CSV uploads may exceed default FETCH_TIMEOUT_MS. */
 export const UPLOAD_DATASET_TIMEOUT_MS = 180_000;
+/** Files at/above this size use the presigned direct-to-R2 streaming upload path. */
+export const LARGE_UPLOAD_BYTES = 64 * 1024 * 1024; // 64 MB
+/** Timeout for a direct presigned PUT of a large (gzipped) file to R2. */
+export const PRESIGNED_PUT_TIMEOUT_MS = 30 * 60_000; // 30 min
+/** Poll window for the async stage_dataset job (large files take minutes). */
+export const POLL_STAGE_MAX_MS = 30 * 60_000; // 30 min
 // ---------------------------------------------------------------------------
 // Shared state (mutable)
 // ---------------------------------------------------------------------------
@@ -60,6 +70,43 @@ export function isTransientError(err, status) {
         return true; // network-level fetch failure
     return false;
 }
+/** Streaming SHA-256 of a file (for idempotency keys) without reading it into memory. */
+export async function streamFileSha256(srcPath) {
+    return new Promise((resolve, reject) => {
+        const h = createHash("sha256");
+        const s = createReadStream(srcPath);
+        s.on("data", (chunk) => h.update(chunk));
+        s.on("end", () => resolve(h.digest("hex")));
+        s.on("error", reject);
+    });
+}
+/**
+ * Stream a local file through gzip directly to a presigned PUT URL (e.g. R2),
+ * never materializing the file in memory. Bypasses the API/Cloudflare body cap.
+ */
+export async function putPresignedStream(url, srcPath, contentType, timeoutMs = PRESIGNED_PUT_TIMEOUT_MS) {
+    const gz = createReadStream(srcPath).pipe(createGzip());
+    const webStream = Readable.toWeb(gz);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const resp = await fetch(url, {
+            method: "PUT",
+            body: webStream,
+            headers: { "Content-Type": contentType },
+            // Required by Node's fetch to send a streaming request body.
+            duplex: "half",
+            signal: controller.signal,
+        });
+        if (!resp.ok) {
+            const t = await resp.text().catch(() => "");
+            throw new Error(`Presigned upload failed: HTTP ${resp.status} ${t.slice(0, 200)}`);
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 export async function fetchWithTimeout(url, init, timeoutMs = FETCH_TIMEOUT_MS) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);

package/dist/tools/datasets.js

@@ -4,7 +4,7 @@ import { gzipSync } from "node:zlib";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { registerAuditedTool } from "../audit.js";
-import { apiCall, getWorkspaceRootAsync, resolveFilePathForUpload, textResult, pollUntilComplete, POLL_DERIVE_MAX_MS, UPLOAD_DATASET_TIMEOUT_MS, } from "../shared.js";
+import { apiCall, getWorkspaceRootAsync, resolveFilePathForUpload, textResult, pollUntilComplete, POLL_DERIVE_MAX_MS, UPLOAD_DATASET_TIMEOUT_MS, LARGE_UPLOAD_BYTES, PRESIGNED_PUT_TIMEOUT_MS, POLL_STAGE_MAX_MS, streamFileSha256, putPresignedStream, } from "../shared.js";
 /**
  * Format a dataset analyze result (from either the async job summary or the
  * legacy sync GET response) into the human-readable text block.
@@ -216,20 +216,46 @@ ESCALATION: If upload fails with column errors, open the file locally and verify
                 if (ext !== ".csv" && ext !== ".tsv") {
                     throw new Error("Only .csv and .tsv files can be uploaded as datasets.");
                 }
-                const MAX_UPLOAD_BYTES = 256 * 1024 * 1024; // 256 MB (gzip keeps the wire payload small)
+                const HARD_MAX_BYTES = 5 * 1024 * 1024 * 1024; // 5 GB (R2 single-PUT limit)
+                let stat;
                 try {
-                    const stat = await fs.stat(resolved);
-                    if (stat.size > MAX_UPLOAD_BYTES) {
-                        throw new Error(`File too large (${(stat.size / 1024 / 1024).toFixed(1)} MB). Maximum upload size is ${MAX_UPLOAD_BYTES / 1024 / 1024} MB.`);
-                    }
-                    body = await fs.readFile(resolved, "utf-8");
+                    stat = await fs.stat(resolved);
                 }
-                catch (err) {
-                    if (err instanceof Error && err.message.includes("too large"))
-                        throw err;
+                catch {
                     throw new Error(`File not accessible at resolved path. file_path is relative to workspace root. ` +
                         `Set BARIVIA_WORKSPACE_ROOT in your MCP config env if needed (current: ${await getWorkspaceRootAsync(server)}).`);
                 }
+                if (stat.size > HARD_MAX_BYTES) {
+                    throw new Error(`File too large (${(stat.size / 1024 / 1024 / 1024).toFixed(2)} GB). Maximum upload size is 5 GB.`);
+                }
+                // Large files: stream gzip directly to R2 (presigned PUT), then stage async.
+                // Never reads the file into memory or sends it through the API/Cloudflare.
+                if (stat.size >= LARGE_UPLOAD_BYTES) {
+                    const idem = await streamFileSha256(resolved);
+                    const init = (await apiCall("POST", "/v1/datasets/upload-url", { name, size_bytes: stat.size }, { "Idempotency-Key": idem }));
+                    const datasetId = (init.dataset_id ?? init.id);
+                    if (init.idempotent_replay) {
+                        return textResult({ id: datasetId, status: init.status, idempotent_replay: true,
+                            suggested_next_step: `datasets(action=preview, dataset_id=${datasetId})` });
+                    }
+                    await putPresignedStream(init.upload_url, resolved, init.content_type ?? "application/octet-stream", PRESIGNED_PUT_TIMEOUT_MS);
+                    const fin = (await apiCall("POST", `/v1/datasets/${datasetId}/finalize`, {}));
+                    const jobId = (fin.id ?? fin.job_id);
+                    const poll = await pollUntilComplete(jobId, POLL_STAGE_MAX_MS);
+                    if (poll.status === "failed") {
+                        return textResult({ id: datasetId, status: "failed", error: poll.error ?? "staging failed" });
+                    }
+                    const ready = poll.status === "completed";
+                    return textResult({
+                        id: datasetId,
+                        status: ready ? "ready" : "staging",
+                        job_id: jobId,
+                        suggested_next_step: ready
+                            ? `datasets(action=preview, dataset_id=${datasetId}) to inspect columns before training.`
+                            : `Still staging; poll jobs(action=status, job_id="${jobId}") then datasets(action=preview, dataset_id=${datasetId}).`,
+                    });
+                }
+                body = await fs.readFile(resolved, "utf-8");
             }
             else if (csv_data && csv_data.length > 0) {
                 body = csv_data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barivia/barsom-mcp",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "barSOM MCP proxy — connect any MCP client to the barSOM cloud API for Self-Organizing Map analytics",
   "keywords": [
     "mcp",