@ateam-ai/mcp 0.4.75 → 0.4.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai/mcp",
-  "version": "0.4.75",
+  "version": "0.4.77",
   "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/tools.js

@@ -2241,6 +2241,24 @@ export const tools = [
       required: ["solution_id"],
     },
   },
+  {
+    name: "ateam_github_reconcile",
+    core: true,
+    description:
+      "JOIN a diverged dev and main. Use when ateam_github_promote returns PROMOTE_NEEDS_HUMAN or PROMOTE_PRECONDITION_FAILED — i.e. the automatic main→dev back-merge could not resolve itself.\n\n" +
+      "TRY sync_from_main FIRST; this tool calls it internally (a plain merge keeps both sides with no judgement call) and only escalates when git genuinely conflicts.\n\n" +
+      "On conflict it writes a TWO-PARENT merge commit so the histories actually join. That matters: copying one branch's tree onto the other makes the contents match while leaving NO merge base, so the very next promote conflicts again — equal content is not a reconciled history.\n\n" +
+      "Conflicting files are resolved per file, NEWEST WINS, and every decision is reported. Recency is a heuristic, not intent: read the decisions. On a real tenant main held the newer solution.json while dev held the newer widget, so a blanket choice would have reverted one of them.\n\n" +
+      "WHO NEEDS THIS: any tenant whose deploys predate the dev-routing fix carries main-only commits the platform itself wrote, and hits this on its first promote afterwards. Pass dry_run:true to see the decisions before writing anything.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: { type: "string", description: "The solution ID" },
+        dry_run: { type: "boolean", description: "Report the per-file decisions without writing the merge commit." },
+      },
+      required: ["solution_id"],
+    },
+  },
   {
     name: "ateam_github_sync_from_main",
     core: true,
@@ -5329,10 +5347,78 @@ const handlers = {
       gaps.push(`solution health unavailable: ${e.message}`);
     }
 
+    // 4. SMOKE CALL — actually invoke a tool the SOLUTION depends on.
+    //
+    // Everything above is tools/list-level: `connected`, `tools > 0`, "renders",
+    // "deployed". All of it stayed green on a clinic connector that answered
+    // tools/list correctly and returned 401 on EVERY storage call, because its
+    // generated client put a PAT in the shared-secret header. The build shipped,
+    // reported healthy, and failed the first time a user touched it. The only
+    // check that could have caught it is calling something.
+    //
+    // Tool names come from the SKILLS, not the connector: the connector
+    // endpoints expose a count and a description but no name (verified live —
+    // /connectors/<id>/tools returns 7 objects that are all {description:""}),
+    // and the tools a skill declares are the ones that actually have to work.
+    // Testing those is a better question than testing an arbitrary one.
+    out.smoke = [];
+    try {
+      const wanted = new Map();   // toolName -> connectorId (first skill that declares it)
+      for (const sk of Array.isArray(out.skills) ? out.skills : []) {
+        if (!sk?.id) continue;
+        const def = await get(`/deploy/solutions/${solution_id}/skills/${sk.id}`, sid).catch(() => null);
+        for (const t of (def?.skill?.tools || def?.tools || [])) {
+          const name = typeof t === "string" ? t : t?.name;
+          if (!name || wanted.has(name)) continue;
+          const conn = (typeof t === "object" && (t?.source?.connector || t?.source?.id)) || null;
+          wanted.set(name, conn);
+        }
+      }
+
+      // READ-SHAPED ONLY. A smoke test must never book an appointment or delete a
+      // row to prove a connector is alive, so a write-shaped name is skipped and
+      // SAID to be skipped rather than quietly passed over.
+      const readish = [...wanted.keys()].filter((n) => /(^|[._])(list|get|today|available|health|status|ping|info|search)([._]|$)/i.test(n));
+      const perConnector = new Map();
+      for (const name of readish) {
+        const conn = wanted.get(name) || (Array.isArray(out.connectors) && out.connectors[0]?.id) || null;
+        if (!conn || perConnector.has(conn)) continue;
+        perConnector.set(conn, name);
+      }
+
+      for (const c of Array.isArray(out.connectors) ? out.connectors : []) {
+        // DELIBERATELY NOT GATED ON c.connected. Connectors are LAZY — one idles
+        // back to sleep between step 1 and here, and the /call endpoint wakes it
+        // on demand. Skipping a sleeping connector would make this check silently
+        // untestable exactly when it is most needed, and "asleep" is not an
+        // answer to "do its calls work?". The call itself is the verdict.
+        const pick = perConnector.get(c.id);
+        if (!pick) {
+          out.smoke.push({ connector: c.id, called: null, note: "no read-shaped tool declared by any skill — NOT smoke-tested" });
+          gaps.push(`connector '${c.id}' was not smoke-tested (no read-shaped tool declared by a skill); tools/list working does NOT prove its calls succeed`);
+          continue;
+        }
+        try {
+          const r = await post(`/deploy/solutions/${solution_id}/connectors/${c.id}/call`, { tool: pick, args: {} }, sid);
+          const failed = r?.ok === false;
+          out.smoke.push({ connector: c.id, called: pick, ok: !failed, ...(failed && { error: String(r?.error || "").slice(0, 200) }) });
+          if (failed) {
+            gaps.push(`connector '${c.id}' lists ${c.tools} tool(s) but CALLING ${pick} failed: ${String(r?.error || "").slice(0, 160)} — tools/list works and real calls do not`);
+          }
+        } catch (e) {
+          out.smoke.push({ connector: c.id, called: pick, ok: false, error: e.message.slice(0, 200) });
+          gaps.push(`connector '${c.id}' smoke call ${pick} errored: ${e.message.slice(0, 160)}`);
+        }
+      }
+    } catch (e) {
+      out.smoke = { error: e.message };
+      gaps.push(`smoke check could not run: ${e.message}`);
+    }
+
     out.gaps = gaps;
     out.ok = gaps.length === 0;
     out._status = out.ok
-      ? "✅ Verified live — connectors connected, widgets render, skills deployed."
+      ? "✅ Verified live — connectors connected AND answering real calls, widgets render, skills deployed."
       : `⚠️ ${gaps.length} gap(s): ${gaps.slice(0, 5).join("; ")}${gaps.length > 5 ? " …" : ""}`;
     return out;
   },
@@ -5412,6 +5498,11 @@ const handlers = {
   ateam_github_promote: async ({ solution_id, label, dry_run, skip_tag }, sid) =>
     post(`/deploy/solutions/${solution_id}/promote`, { label, dry_run, skip_tag }, sid),
 
+  ateam_github_reconcile: async ({ solution_id, dry_run }, sid) => {
+    if (!solution_id) throw new Error("solution_id required");
+    return await post(`/deploy/solutions/${solution_id}/reconcile`, { dry_run: dry_run === true }, sid);
+  },
+
   ateam_github_sync_from_main: async ({ solution_id, dry_run }, sid) =>
     post(`/deploy/solutions/${solution_id}/sync-from-main`, { dry_run }, sid),