@barivia/barmesh-mcp 0.2.0 → 0.3.0

package/README.md

@@ -50,6 +50,11 @@ API key; otherwise the analysis calls return HTTP 403. Contact Barivia to enable
 | `barmesh_richardson` | Richardson/GCI on scalar QoIs (async job). |
 | `barmesh_jobs` | Poll job status / list jobs. |
 | `barmesh_results` | Distances, convergence reading, and figures. |
+| `barmesh_send_feedback` | Send a short note or bug report to the Barivia team. |
+
+### Migration notes
+
+- **`send_feedback` → `barmesh_send_feedback` (0.3.0):** the feedback tool was renamed so it no longer collides with the `@barivia/barsom-mcp` tool of the same name when both servers are enabled in one client. Update any direct call sites; the behavior is unchanged.
 
 ## Data format (mesh_convergence)
 
@@ -63,6 +68,6 @@ cell-volume column (`V`). Use `barmesh_prepare_mesh_data` for the full recipe.
 |----------|---------|---------|
 | `BARIVIA_API_KEY` | (required) | Your Barivia API key. |
 | `BARIVIA_API_URL` | `https://api.barivia.se` | API base URL. |
-| `BARIVIA_FETCH_TIMEOUT_MS` | `30000` | Per-request timeout (raise for large uploads). |
+| `BARIVIA_FETCH_TIMEOUT_MS` | `60000` | Per-request timeout (raise for large uploads). |
 | `BARIVIA_WORKSPACE_ROOT` | workspace/cwd | Root for resolving relative `file_path` uploads. |
 | `BARIVIA_ENFORCE_WORKSPACE_SANDBOX` | `1` | Restrict uploads to the workspace; set `0` to allow absolute paths. |

package/dist/shared.js

@@ -4,6 +4,10 @@
  * remains a thin HTTPS client to the same Barivia API (no domain logic here).
  */
 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";
@@ -12,24 +16,65 @@ import { logInfo } from "./logger.js";
 // ---------------------------------------------------------------------------
 export const API_URL = process.env.BARIVIA_API_URL ?? process.env.BARSOM_API_URL ?? "https://api.barivia.se";
 export const API_KEY = process.env.BARIVIA_API_KEY ?? process.env.BARSOM_API_KEY ?? "";
-export const FETCH_TIMEOUT_MS = parseInt(process.env.BARIVIA_FETCH_TIMEOUT_MS ?? "30000", 10);
+export const FETCH_TIMEOUT_MS = parseInt(process.env.BARIVIA_FETCH_TIMEOUT_MS ?? "60000", 10);
 export const MAX_RETRIES = 2;
 export const RETRYABLE_STATUS = new Set([502, 503, 504]);
 /** Single source of truth for the proxy version. Keep in sync with package.json on bump. */
-export const CLIENT_VERSION = "0.2.0";
+export const CLIENT_VERSION = "0.3.0";
 export const PUBLIC_SITE_ORIGIN = "https://barivia.se";
 /** Large per-cell CSV uploads may exceed the default fetch timeout. */
 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. */
+export const POLL_STAGE_MAX_MS = 30 * 60_000; // 30 min
+/** Streaming SHA-256 of a file (idempotency key) 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). */
+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 },
+            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);
+    }
+}
 // ---------------------------------------------------------------------------
 // Fetch helpers
 // ---------------------------------------------------------------------------
 export function isTransientError(err, status) {
     if (status !== undefined && RETRYABLE_STATUS.has(status))
         return true;
-    if (err instanceof DOMException && err.name === "AbortError")
-        return true;
+    // NOTE: a client-side timeout (AbortError) is deliberately NOT retried. Re-firing
+    // a slow/expensive request (e.g. mesh-convergence enqueue, large upload) while the
+    // server is still processing the first one only multiplies load and risks duplicates
+    // — raise BARIVIA_FETCH_TIMEOUT_MS or use the async (job_id + poll) path instead.
     if (err instanceof TypeError)
-        return true;
+        return true; // network-level fetch failure
     return false;
 }
 export async function fetchWithTimeout(url, init, timeoutMs = FETCH_TIMEOUT_MS) {
@@ -234,6 +279,9 @@ export async function apiRawCall(pathPart, requestTimeoutMs) {
                 await new Promise((r) => setTimeout(r, 1000 * 2 ** attempt));
                 continue;
             }
+            if (err instanceof DOMException && err.name === "AbortError" && !err.httpStatus) {
+                throw new Error(`Image request timed out after ${effectiveTimeout}ms. Increase BARIVIA_FETCH_TIMEOUT_MS (e.g. 120000) for large images. (request id: ${requestId})`);
+            }
             throw err;
         }
     }

package/dist/tools/cfd.js

@@ -10,7 +10,6 @@ BEST FOR: A mesh-refinement study where you want a field-level (not just scalar)
 NOT FOR: Single scalar quantities of interest — use barmesh_richardson for classical GCI.
 ASYNC: This is a queued job. It returns a job id immediately. Then poll barmesh_jobs(action=status) every 10-20s; datacenter-scale grids plus EMD can take a few minutes — keep polling. On completion call barmesh_results(action=get).
 COMMON MISTAKES: omitting feature_columns (required); choosing a reference_mesh label that is not present; forgetting the cell-volume column at upload time.`, {
-        action: z.enum(["submit"]).optional().describe("submit: enqueue the analysis (default)"),
         dataset_id: z.string().describe("Dataset ID from barmesh_datasets(upload)"),
         feature_columns: z.array(z.string()).describe("Per-cell numeric feature columns to train the SOM on (e.g. [\"p\",\"U_mag\",\"k\",\"log_epsilon\"])"),
         preset: z.enum(["generic", "cavity", "pitz", "datacenter"]).optional().describe("Hyperparameter preset; defaults to generic. cavity/pitz/datacenter reproduce the published settings."),
@@ -29,8 +28,7 @@ COMMON MISTAKES: omitting feature_columns (required); choosing a reference_mesh
         figures: z.boolean().optional().describe("Generate publication figures (default true)"),
         label: z.string().optional().describe("Optional job label"),
     }, async (args) => {
-        const { action, dataset_id, label, ...rest } = args;
-        void action;
+        const { dataset_id, label, ...rest } = args;
         const params = {};
         for (const [k, v] of Object.entries(rest)) {
             if (v !== undefined && v !== null)
@@ -53,7 +51,6 @@ BEST FOR: Scalar benchmarks (reattachment length, centerline values, probe readi
 NOT FOR: High-dimensional field comparison — use barmesh_mesh_convergence (complementary).
 ASYNC: queued job; poll barmesh_jobs(action=status), then barmesh_results(action=get).
 COMMON MISTAKES: not providing h_column or n_cells_column; mixing QoIs with different mesh sets in one CSV.`, {
-        action: z.enum(["submit"]).optional().describe("submit: enqueue the GCI job (default)"),
         dataset_id: z.string().describe("Dataset ID (one row per mesh)"),
         qoi_columns: z.array(z.string()).describe("Scalar QoI column names to extrapolate"),
         mesh_column: z.string().optional().describe("Mesh label column (default mesh_id)"),
@@ -63,8 +60,7 @@ COMMON MISTAKES: not providing h_column or n_cells_column; mixing QoIs with diff
         safety_factor: z.number().optional().describe("GCI safety factor Fs (default 1.25, Roache)"),
         label: z.string().optional().describe("Optional job label"),
     }, async (args) => {
-        const { action, dataset_id, label, ...rest } = args;
-        void action;
+        const { dataset_id, label, ...rest } = args;
         const params = {};
         for (const [k, v] of Object.entries(rest)) {
             if (v !== undefined && v !== null)

package/dist/tools/datasets.js

@@ -1,8 +1,10 @@
 import { gzipSync } from "node:zlib";
+import { createHash } from "node:crypto";
 import { z } from "zod";
 import fs from "node:fs/promises";
+import path from "node:path";
 import { registerAuditedTool } from "../audit.js";
-import { apiCall, resolveFilePathForUpload, textResult, UPLOAD_DATASET_TIMEOUT_MS, } from "../shared.js";
+import { apiCall, resolveFilePathForUpload, textResult, pollUntilComplete, UPLOAD_DATASET_TIMEOUT_MS, LARGE_UPLOAD_BYTES, PRESIGNED_PUT_TIMEOUT_MS, POLL_STAGE_MAX_MS, streamFileSha256, putPresignedStream, } from "../shared.js";
 export function registerDatasetsTool(server) {
     registerAuditedTool(server, "barmesh_datasets", `Upload, preview, or list the combined per-cell mesh CSV used for convergence analysis.
 
@@ -29,7 +31,39 @@ ESCALATION: If preview shows a feature column as non-numeric, fix the extraction
                 throw new Error("barmesh_datasets(upload) requires name.");
             let body;
             if (file_path && file_path.length > 0) {
+                // Preflight: warm plan/limits and reject over-limit uploads before reading the file.
+                await apiCall("GET", "/v1/system/info");
                 const resolved = await resolveFilePathForUpload(file_path, server);
+                const ext = path.extname(resolved).toLowerCase();
+                if (ext !== ".csv" && ext !== ".tsv") {
+                    throw new Error("Only .csv and .tsv files can be uploaded as datasets.");
+                }
+                const HARD_MAX_BYTES = 5 * 1024 * 1024 * 1024; // 5 GB
+                const stat = await fs.stat(resolved);
+                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.`);
+                }
+                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: `barmesh_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
+                            ? `barmesh_datasets(action=preview, dataset_id=${datasetId})`
+                            : `Still staging; poll barmesh_jobs(action=status, job_id="${jobId}").` });
+                }
                 body = await fs.readFile(resolved, "utf-8");
             }
             else if (csv_data && csv_data.length > 0) {
@@ -39,7 +73,13 @@ ESCALATION: If preview shows a feature column as non-numeric, fix the extraction
                 throw new Error("barmesh_datasets(upload) requires file_path or csv_data. Prefer file_path.");
             }
             const GZIP_THRESHOLD = 1024 * 1024;
-            const uploadHeaders = { "X-Dataset-Name": name, "Content-Type": "text/csv" };
+            const uploadHeaders = {
+                "X-Dataset-Name": name,
+                "Content-Type": "text/csv",
+                // Deterministic key so a timed-out retry of the SAME upload reconciles to
+                // the original dataset server-side instead of creating a duplicate.
+                "Idempotency-Key": createHash("sha256").update(`${name}\n`).update(body).digest("hex"),
+            };
             let uploadBody = body;
             if (Buffer.byteLength(body, "utf-8") > GZIP_THRESHOLD) {
                 uploadBody = gzipSync(Buffer.from(body, "utf-8"));

package/dist/tools/feedback.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { registerAuditedTool } from "../audit.js";
 import { apiCall, API_URL, fetchWithTimeout, textResult } from "../shared.js";
 export function registerFeedbackTool(server) {
-    registerAuditedTool(server, "send_feedback", `Send feedback or feature requests to Barivia developers (CFD mesh-convergence / barmesh workflow). Use when the user has suggestions, ran into issues, or wants something improved. Do NOT call without asking the user first — but after a mesh-convergence or Richardson session, you SHOULD prepare feedback based on the user's workflow or errors encountered, show it to them, and ask for permission to send it. Once they accept, call this tool.
+    registerAuditedTool(server, "barmesh_send_feedback", `Send feedback or feature requests to Barivia developers (CFD mesh-convergence / barmesh workflow). Use when the user has suggestions, ran into issues, or wants something improved. Do NOT call without asking the user first — but after a mesh-convergence or Richardson session, you SHOULD prepare feedback based on the user's workflow or errors encountered, show it to them, and ask for permission to send it. Once they accept, call this tool.
 
 For a substantial issue, prefer feedback_items: submit several focused instances (each max 1400 chars) covering, e.g., symptoms, exact reproduction steps, environment, and concrete asks — they are stored together as one batch so developers see the full picture. Use the single feedback field for a short one-off note.`, {
         feedback: z.string().max(1400).optional().describe("Single feedback note (max 1400 characters). Use feedback_items instead for a multi-part report."),
@@ -12,7 +12,7 @@ For a substantial issue, prefer feedback_items: submit several focused instances
         if (feedback && feedback.trim().length > 0)
             items.unshift(feedback.trim());
         if (items.length === 0) {
-            throw new Error("send_feedback requires feedback or feedback_items (at least one non-empty entry).");
+            throw new Error("barmesh_send_feedback requires feedback or feedback_items (at least one non-empty entry).");
         }
         const body = items.length === 1 ? { feedback: items[0] } : { feedback_items: items };
         try {

package/dist/tools/guide.js

@@ -1,16 +1,20 @@
-import { z } from "zod";
 import { registerAuditedTool } from "../audit.js";
 import { apiCall, textResult } from "../shared.js";
 const OFFLINE_GUIDE = `barmesh: CFD mesh-convergence on the Barivia API.
 Two tracks: barmesh_mesh_convergence (SOM fingerprint distances) and barmesh_richardson (classical GCI).
 Workflow: barmesh_prepare_mesh_data -> barmesh_datasets(upload) -> barmesh_mesh_convergence / barmesh_richardson -> barmesh_jobs(status) -> barmesh_results(get).
 (API unreachable; this is the offline summary. Set BARIVIA_API_KEY / BARIVIA_API_URL.)`;
+const OFFLINE_PREP = `barmesh mesh-data prep (offline summary; API unreachable):
+Build ONE combined per-cell CSV across all meshes of the refinement study:
+- one row per cell; a mesh label column (mesh_id); the physical channels you want compared (e.g. p, U_mag, k, log_epsilon — log-compress turbulence quantities); and a cell-volume column (V) for fingerprint weighting.
+- keep the SAME feature columns across every mesh; pick the finest mesh as the reference.
+Then: barmesh_datasets(upload) -> barmesh_mesh_convergence. (Set BARIVIA_API_KEY / BARIVIA_API_URL.)`;
 export function registerGuideTool(server) {
     registerAuditedTool(server, "barmesh_guide_workflow", `Get the barmesh CFD mesh-convergence workflow and tool map from the API (tier-scoped).
 
 BEST FOR: First call in a session — orients you on the two tracks (SOM fingerprint distances and Richardson/GCI), the upload->submit->poll->results flow, and what your plan allows.
 NOT FOR: Step-by-step mesh-data preparation — use barmesh_prepare_mesh_data for that.
-ESCALATION: If the response says your plan does not include CFD tools, the analysis tools will return 403; contact Barivia to enable the cfd entitlement.`, { action: z.enum(["get"]).optional().describe("get: fetch the workflow guide (default)") }, async () => {
+ESCALATION: If the response says your plan does not include CFD tools, the analysis tools will return 403; contact Barivia to enable the cfd entitlement.`, {}, async () => {
         try {
             const data = (await apiCall("GET", "/v1/cfd/guide"));
             return textResult({
@@ -29,8 +33,15 @@ ESCALATION: If the response says your plan does not include CFD tools, the analy
 
 BEST FOR: Before barmesh_datasets(upload) — tells you which physical channels to extract, how to label meshes (mesh_id), the cell-volume column (V), and how to pick the reference mesh.
 NOT FOR: Submitting jobs — after preparing the CSV, use barmesh_datasets(upload) then barmesh_mesh_convergence.
-COMMON MISTAKES: forgetting the per-cell cell-volume column; using different channels across meshes; not log-compressing turbulence quantities (k, epsilon, omega).`, { action: z.enum(["get"]).optional().describe("get: fetch the mesh-prep recipe (default)") }, async () => {
-        const data = (await apiCall("GET", "/v1/cfd/prep"));
-        return textResult({ recipe: data.recipe, entitled: data.entitled });
+COMMON MISTAKES: forgetting the per-cell cell-volume column; using different channels across meshes; not log-compressing turbulence quantities (k, epsilon, omega).`, {}, async () => {
+        try {
+            const data = (await apiCall("GET", "/v1/cfd/prep"));
+            return textResult({ recipe: data.recipe, entitled: data.entitled });
+        }
+        catch (e) {
+            if (e?.httpStatus === 401 || e?.httpStatus === 403)
+                throw e;
+            return textResult(OFFLINE_PREP);
+        }
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barivia/barmesh-mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "barmesh MCP proxy — SOM-based CFD mesh-convergence and Richardson/GCI analysis on the Barivia cloud API",
   "keywords": [
     "mcp",