@ateam-ai/mcp 0.3.5 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai/mcp",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "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

@@ -124,14 +124,18 @@ export const tools = [
     inputSchema: {
       type: "object",
       properties: {
+        solution_id: {
+          type: "string",
+          description: "The solution ID. Use this INSTEAD of passing the full solution object — the solution definition is auto-pulled from GitHub. Required if solution object is omitted.",
+        },
         solution: {
           type: "object",
-          description: "Solution architecture — identity, grants, handoffs, routing",
+          description: "Full solution definition. Required on first deploy. After first deploy, just pass solution_id instead — everything is auto-pulled from GitHub.",
         },
         skills: {
           type: "array",
           items: { type: "object" },
-          description: "Array of full skill definitions",
+          description: "Optional after first deploy: skill definitions. If omitted, auto-pulled from GitHub repo (skills/{id}/skill.json).",
         },
         connectors: {
           type: "array",
@@ -155,7 +159,7 @@ export const tools = [
           description: "Optional: which skill to test (defaults to the first skill).",
         },
       },
-      required: ["solution", "skills"],
+      required: [],
     },
   },
   {
@@ -1291,7 +1295,13 @@ const handlers = {
   // Validates → Deploys → Health-checks → Optionally tests
   // One call replaces: validate_solution + deploy_solution + get_solution(health)
 
-  ateam_build_and_run: async ({ solution, skills, connectors, mcp_store, github, test_message, test_skill_id }, sid) => {
+  ateam_build_and_run: async ({ solution_id: solIdArg, solution: solutionArg, skills, connectors, mcp_store, github, test_message, test_skill_id }, sid) => {
+    let solution = solutionArg;
+    // If only solution_id passed (no full solution), we'll pull from GitHub
+    const solutionId = solution?.id || solIdArg;
+    if (!solutionId) {
+      return { ok: false, phase: "pre_check", error: "Provide either solution (object) or solution_id (string)." };
+    }
     const phases = [];
 
     // Guard: reject large mcp_store — agent should use github_patch instead
@@ -1314,13 +1324,13 @@ const handlers = {
       }
     }
 
-    // Phase 0: Auto-detect GitHub repo — if no mcp_store passed and repo exists, pull from GitHub automatically
+    // Phase 0: Auto-detect GitHub repo — if no mcp_store passed and repo exists, pull bundle from GitHub
     let effectiveMcpStore = mcp_store;
+    let effectiveSkills = skills;
     if (!mcp_store) {
       try {
-        const ghStatus = await get(`/deploy/solutions/${solution.id}/github/status`, sid);
+        const ghStatus = await get(`/deploy/solutions/${solutionId}/github/status`, sid);
         if (ghStatus?.repo_url) {
-          // Repo exists — auto-pull from GitHub
           github = true;
         }
       } catch { /* no repo — first deploy, mcp_store expected */ }
@@ -1328,24 +1338,33 @@ const handlers = {
     if (github && !mcp_store) {
       try {
         const pullResult = await post(
-          `/deploy/solutions/${solution.id}/github/pull-connectors`,
+          `/deploy/solutions/${solutionId}/github/pull-bundle`,
           {},
           sid,
-          { timeoutMs: 30_000 },
+          { timeoutMs: 60_000 },
         );
         if (!pullResult.ok) {
           return {
             ok: false,
             phase: "github_pull",
-            error: pullResult.error || "Failed to pull connectors from GitHub",
+            error: pullResult.error || "Failed to pull bundle from GitHub",
             hint: pullResult.hint || "Deploy the solution first (with mcp_store) to auto-create the GitHub repo.",
-            message: "Cannot pull connector code from GitHub. The repo may not exist yet — deploy with mcp_store first.",
+            message: "Cannot pull from GitHub. The repo may not exist yet — deploy with mcp_store first.",
           };
         }
-        effectiveMcpStore = pullResult.mcp_store;
+        effectiveMcpStore = pullResult.mcp_store || {};
+        // Use solution from GitHub if not passed inline
+        if (!solution && pullResult.solution) {
+          solution = pullResult.solution;
+        }
+        // Use skills from GitHub if not passed inline
+        if (!effectiveSkills?.length && pullResult.skills?.length) {
+          effectiveSkills = pullResult.skills;
+        }
         phases.push({
           phase: "github_pull",
           status: "done",
+          skills_found: pullResult.skills_found || 0,
           connectors_found: pullResult.connectors_found || 0,
           files_loaded: pullResult.files_loaded || 0,
         });
@@ -1354,15 +1373,35 @@ const handlers = {
           ok: false,
           phase: "github_pull",
           error: err.message,
-          message: "Failed to pull connector code from GitHub. The repo may not exist yet — deploy with mcp_store first.",
+          message: "Failed to pull from GitHub. The repo may not exist yet — deploy with mcp_store first.",
         };
       }
     }
 
+    // Guard: solution required (either inline or from GitHub)
+    if (!solution) {
+      return {
+        ok: false,
+        phase: "pre_check",
+        error: "No solution provided and none found in GitHub repo.",
+        message: "Pass solution inline or ensure solution.json exists in the GitHub repo.",
+      };
+    }
+
+    // Guard: skills required (either inline or from GitHub)
+    if (!effectiveSkills?.length) {
+      return {
+        ok: false,
+        phase: "pre_check",
+        error: "No skills provided and none found in GitHub repo.",
+        message: "Pass skills inline or ensure they exist in the GitHub repo (skills/{id}/skill.json).",
+      };
+    }
+
     // Phase 1: Validate
     let validation;
     try {
-      validation = await post("/validate/solution", { solution, skills, connectors, mcp_store: effectiveMcpStore }, sid, { timeoutMs: 120_000 });
+      validation = await post("/validate/solution", { solution, skills: effectiveSkills, connectors, mcp_store: effectiveMcpStore }, sid, { timeoutMs: 120_000 });
       phases.push({ phase: "validate", status: "done" });
     } catch (err) {
       return {
@@ -1388,7 +1427,7 @@ const handlers = {
     // Phase 2: Deploy
     let deploy;
     try {
-      deploy = await post("/deploy/solution", { solution, skills, connectors, mcp_store: effectiveMcpStore }, sid, { timeoutMs: 300_000, retries: 2 });
+      deploy = await post("/deploy/solution", { solution, skills: effectiveSkills, connectors, mcp_store: effectiveMcpStore }, sid, { timeoutMs: 300_000, retries: 2 });
       phases.push({ phase: "deploy", status: deploy.ok ? "done" : "failed" });
     } catch (err) {
       return {
@@ -1412,11 +1451,35 @@ const handlers = {
       };
     }
 
+    // Phase 2.5: Restart connectors that have source code (upload triggers stop+start)
+    if (effectiveMcpStore && Object.keys(effectiveMcpStore).length > 0) {
+      const connectorResults = [];
+      for (const [connId, files] of Object.entries(effectiveMcpStore)) {
+        if (!Array.isArray(files) || files.length === 0) continue;
+        try {
+          const uploadResult = await post(
+            `/deploy/solutions/${solutionId}/connectors/${connId}/upload`,
+            { files },
+            sid,
+            { timeoutMs: 120_000 },
+          );
+          connectorResults.push({ id: connId, ok: true, tools: uploadResult.tools || 0 });
+        } catch (err) {
+          connectorResults.push({ id: connId, ok: false, error: err.message });
+        }
+      }
+      phases.push({
+        phase: "connector_restart",
+        status: connectorResults.every(r => r.ok) ? "done" : "partial",
+        connectors: connectorResults,
+      });
+    }
+
     // Phase 3: Health check (with brief wait for propagation)
     let health;
     try {
       await sleep(2000);
-      health = await get(`/deploy/solutions/${solution.id}/health`, sid);
+      health = await get(`/deploy/solutions/${solutionId}/health`, sid);
       phases.push({ phase: "health", status: "done" });
     } catch (err) {
       health = { error: err.message };
@@ -1426,11 +1489,11 @@ const handlers = {
     // Phase 4: Warm test (optional)
     let test_result;
     if (test_message) {
-      const skillId = test_skill_id || skills?.[0]?.id;
+      const skillId = test_skill_id || effectiveSkills?.[0]?.id;
       if (skillId) {
         try {
           test_result = await post(
-            `/deploy/solutions/${solution.id}/skills/${skillId}/test`,
+            `/deploy/solutions/${solutionId}/skills/${skillId}/test`,
             { message: test_message },
             sid,
             { timeoutMs: 90_000 },
@@ -1443,28 +1506,34 @@ const handlers = {
       }
     }
 
-    // Phase 5: GitHub push (auto — non-blocking, failures don't fail the deploy)
+    // Phase 5: GitHub push (skip if we just pulled from GitHub — don't overwrite source of truth)
     let github_result;
-    try {
-      github_result = await post(
-        `/deploy/solutions/${solution.id}/github/push`,
-        { message: `Deploy: ${solution.name || solution.id}` },
-        sid,
-        { timeoutMs: 60_000 },
-      );
-      phases.push({
-        phase: "github",
-        status: github_result.skipped ? "skipped" : "done",
-        ...(github_result.repo_url && { repo_url: github_result.repo_url }),
-      });
-    } catch (err) {
-      github_result = { error: err.message };
-      phases.push({ phase: "github", status: "error", error: err.message });
+    if (github) {
+      // We pulled from GitHub → GitHub IS the source of truth. Don't push stale Core state back.
+      github_result = { skipped: true, reason: 'Deployed from GitHub — skipping push-back to avoid overwriting source of truth.' };
+      phases.push({ phase: "github", status: "skipped", reason: "pulled_from_github" });
+    } else {
+      try {
+        github_result = await post(
+          `/deploy/solutions/${solutionId}/github/push`,
+          { message: `Deploy: ${solution.name || solutionId}` },
+          sid,
+          { timeoutMs: 60_000 },
+        );
+        phases.push({
+          phase: "github",
+          status: github_result.skipped ? "skipped" : "done",
+          ...(github_result.repo_url && { repo_url: github_result.repo_url }),
+        });
+      } catch (err) {
+        github_result = { error: err.message };
+        phases.push({ phase: "github", status: "error", error: err.message });
+      }
     }
 
     return {
       ok: true,
-      solution_id: solution.id,
+      solution_id: solutionId,
       branch: 'main',
       phases,
       deploy: {