@ateam-ai/mcp 0.4.35 → 0.4.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai/mcp",
-  "version": "0.4.35",
+  "version": "0.4.37",
   "mcpName": "io.github.ariekogan/ateam-mcp",
   "description": "A-Team MCP Server — build, validate, and deploy multi-agent solutions from any AI environment",
   "type": "module",

package/src/api.js

@@ -520,7 +520,12 @@ async function request(method, path, body, sessionId, opts = {}) {
 
       if (!res.ok) {
         const text = await res.text().catch(() => "");
-        throw new Error(formatError(method, path, res.status, text, baseUrl));
+        // Attach the HTTP status so callers can distinguish a genuine 404
+        // (resource absent) from a transient/5xx failure. ateam_patch relies
+        // on this to NOT scaffold-clobber an existing skill on a read error.
+        const e = new Error(formatError(method, path, res.status, text, baseUrl));
+        e.status = res.status;
+        throw e;
       }
 
       return res.json();

package/src/tools.js

@@ -116,6 +116,32 @@ function _summarizeDef(def) {
   };
 }
 
+// OPEN-8: byte offset/limit paging for reads that can exceed the ~50KB output
+// cap. Serializes the result to pretty JSON and returns a [offset, offset+limit)
+// slice plus a cursor so an agent can page the rest (like Read offset/limit).
+function _pageJson(data, offset = 0, limit) {
+  const full = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+  const total = full.length;
+  const start = Math.min(Math.max(0, Math.trunc(offset) || 0), total);
+  const size = (limit != null) ? Math.max(1, Math.trunc(limit)) : (total - start);
+  const chunk = full.slice(start, start + size);
+  const end = start + chunk.length;
+  return {
+    ok: true,
+    _paging: {
+      offset: start,
+      limit: (limit != null) ? size : null,
+      returned_bytes: chunk.length,
+      total_bytes: total,
+      next_offset: end < total ? end : null,
+      has_more: end < total,
+      note: end < total ? `Truncated to bytes ${start}-${end} of ${total}. Fetch the next page with offset:${end}.` : `Complete (bytes ${start}-${end} of ${total}).`,
+    },
+    // Raw JSON text slice — parse only once you've concatenated all pages.
+    content: chunk,
+  };
+}
+
 function _widgetHasRender(r) {
   if (!r || typeof r !== "object" || !r.mode) return false;
   const hasIframe = !!(r.iframeUrl || r.iframe?.iframeUrl);
@@ -783,6 +809,14 @@ export const tools = [
           type: "string",
           description: "Optional (with skill_id): return ONLY this section of the skill instead of the whole definition — avoids the ~50KB output truncation on big skills. Dotted paths work (e.g. 'role', 'tools', 'intents.supported', 'policy', 'engine'). Omit for the full skill; use ateam_show_skill_minimal for the slim authoring view.",
         },
+        offset: {
+          type: "number",
+          description: "Optional byte-paging: start returning the serialized result from this byte offset. Use with 'limit' to page a result larger than the ~50KB output cap; the response's _paging.next_offset gives the next page (null when done). Concatenate the `content` slices across pages, then JSON.parse.",
+        },
+        limit: {
+          type: "number",
+          description: "Optional byte-paging: max bytes of the serialized result to return in this page (pair with 'offset'). Omit both for the whole result (may truncate at the output cap).",
+        },
       },
       required: ["solution_id", "view"],
     },
@@ -3227,11 +3261,51 @@ const handlers = {
         current = JSON.parse(readResult.content);
       }
     } catch (err) {
-      // If it's a skill that doesn't exist yet, create a default scaffold.
-      // This lets agents use ateam_patch to both CREATE and UPDATE skills —
-      // no separate "create" step needed.
+      // OPEN-31 guard: only scaffold-create when the skill is GENUINELY ABSENT.
+      // The old code scaffolded on ANY read error, so a transient github/read
+      // failure (fetch failed, 5xx, parse error) silently OVERWROTE a full
+      // deployed skill with a bare scaffold on the next write — total data loss.
+      //
+      // A genuine "doesn't exist" is a 404 (or the local empty-definition throw).
+      // Anything else = the store is unreachable/broken → FAIL LOUD, never write.
+      const notFound = err.status === 404 || /not found \(empty definition\)/i.test(err.message || "");
+      if (target === "skill" && skill_id && !notFound) {
+        return {
+          ok: false, phase: "read",
+          error: `Refusing to patch "${skill_id}": could not read its current definition from ${isLocal ? "the Builder store" : "GitHub"} (${err.message}). This is NOT a "skill doesn't exist" error (that would be a 404) — scaffolding now could DESTROY the existing definition. Retry once the store is reachable, or check ateam_get_solution(solution_id, skill_id).`,
+          phases,
+        };
+      }
+      // Even on a real 404, the skill may exist in the OTHER source (deployed to
+      // the Builder store but not pushed to GitHub, or vice versa). Scaffolding
+      // then would destroy/diverge that real def — cross-check before creating.
+      if (target === "skill" && skill_id) {
+        let otherDef = null;
+        try {
+          const other = isLocal
+            ? JSON.parse((await get(`/deploy/solutions/${solution_id}/github/read?path=${encodeURIComponent(filePath)}`, sid)).content)
+            : await get(`/deploy/solutions/${solution_id}/skills/${encodeURIComponent(skill_id)}`, sid);
+          otherDef = other?.skill || other?.definition || other;
+        } catch { otherDef = null; /* absent in the other source too → truly new */ }
+        const otherIsReal = otherDef && typeof otherDef === "object" && (
+          (Array.isArray(otherDef.tools) && otherDef.tools.length > 0) ||
+          (Array.isArray(otherDef.connectors) && otherDef.connectors.length > 0) ||
+          otherDef.voice_native || otherDef.ui_plugins ||
+          (otherDef.role && otherDef.role.persona)
+        );
+        if (otherIsReal) {
+          return {
+            ok: false, phase: "read",
+            error: `Refusing to patch "${skill_id}": it was not found in ${isLocal ? "the Builder store" : "GitHub"}, but a full definition EXISTS in ${isLocal ? "GitHub" : "the Builder store"}. Scaffold-creating here would destroy/diverge it. Sync the two first (ateam_redeploy / ateam_verify_consistency), then retry — do NOT patch-create over an existing skill.`,
+            phases,
+          };
+        }
+      }
+      // If it's a skill that GENUINELY doesn't exist (404 in the primary source
+      // AND absent from the other), create a default scaffold. This lets agents
+      // use ateam_patch to both CREATE and UPDATE skills — no separate step.
       if (target === "skill" && skill_id) {
-        console.log(`[ateam_patch] Skill "${skill_id}" not found on GitHub — creating new skill scaffold`);
+        console.log(`[ateam_patch] Skill "${skill_id}" genuinely absent (404, both sources) — creating new skill scaffold`);
         isNewSkill = true;
         current = {
           id: skill_id,
@@ -3672,22 +3746,24 @@ const handlers = {
     return { ...raw, solutions: enriched };
   },
 
-  ateam_get_solution: async ({ solution_id, view, skill_id, section }, sid) => {
+  ateam_get_solution: async ({ solution_id, view, skill_id, section, offset, limit }, sid) => {
     const base = `/deploy/solutions/${solution_id}`;
+    const paged = (offset != null || limit != null);
     if (skill_id) {
       const r = await get(`${base}/skills/${skill_id}`, sid);
       // OPEN-8: a single skill def can be 50KB+ and truncate at the output cap.
-      // `section` slices it to one field (dotted paths ok, e.g. intents.supported)
-      // so agents can page a big skill instead of grepping a truncated file.
+      // `section` slices it to one field (dotted paths ok, e.g. intents.supported);
+      // offset/limit page the raw bytes — so a big skill is always readable.
+      let result = r;
       if (section) {
         const skill = r?.skill || r?.definition || r || {};
         const val = String(section).split(".").reduce((o, k) => (o == null ? undefined : o[k]), skill);
-        return {
+        result = {
           ok: true, solution_id, skill_id, section, [section]: val,
           _note: `Sliced to '${section}'. Omit 'section' for the full skill; ateam_show_skill_minimal gives the slim authoring view.`,
         };
       }
-      return r;
+      return paged ? _pageJson(result, offset, limit) : result;
     }
     const paths = {
       definition: `${base}/definition`,
@@ -3698,7 +3774,8 @@ const handlers = {
       validate: `${base}/validate`,
       connectors_health: `${base}/connectors/health`,
     };
-    return get(paths[view], sid);
+    const viewResult = await get(paths[view], sid);
+    return paged ? _pageJson(viewResult, offset, limit) : viewResult;
   },
 
   ateam_update: async ({ solution_id, target, skill_id, updates }, sid) => {