@skaleagents/swarm 0.1.0

package/README.md

@@ -0,0 +1,46 @@
+# @skaleagents/swarm (legacy template)
+
+Historical stdio MCP starter for SkaleAgents Phase 1 (`review_architecture`, `scan_iac_stub`).
+The extracted [`mcp-server`](https://github.com/SkaleAgents/mcp-server) repo is canonical.
+
+This template talks to the legacy Fastify API with `SKALEAGENTS_API_TOKEN` (personal access token from mock Google login).
+
+The default points at the Fastify template on `:4000`. For the extracted Laravel API, use `PLATFORM_API_URL=http://localhost:8082` and `PLATFORM_API_PREFIX=/api`.
+
+## Local
+
+```bash
+npm install
+cp .env.example .env
+# Get a token:
+# curl -s -X POST http://localhost:4000/auth/google/callback \
+#   -H 'Content-Type: application/json' \
+#   -d '{"code":"mcp","displayName":"MCP","email":"mcp@example.com"}'
+npm run build
+npm test
+npm run smoke   # needs platform-api on PLATFORM_API_URL
+# Extracted Laravel API:
+# PLATFORM_API_URL=http://localhost:8082 PLATFORM_API_PREFIX=/api npm run smoke
+```
+
+## Cursor / Claude Code
+
+```json
+{
+  "mcpServers": {
+    "skaleagents": {
+      "command": "npx",
+      "args": ["tsx", "/absolute/path/to/mcp-server/src/index.ts"],
+      "env": {
+        "SKALEAGENTS_API_TOKEN": "<token from Google callback>",
+        "PLATFORM_API_URL": "http://localhost:4000",
+        "PLATFORM_API_PREFIX": ""
+      }
+    }
+  }
+}
+```
+
+Or after build: `"command": "node", "args": ["/absolute/path/to/mcp-server/dist/index.js"]`.
+
+Hub contract: [docs/contracts/mcp/tools.md](https://github.com/SkaleAgents/workspace/blob/main/docs/contracts/mcp/tools.md)

package/dist/auth.d.ts

@@ -0,0 +1,20 @@
+export type AuthResult = {
+    ok: true;
+    userId?: string;
+} | {
+    ok: false;
+    reason: "missing_token" | "unauthorized" | "api_unavailable";
+};
+/**
+ * Require the API to validate the bearer token before running any tool.
+ */
+export declare function requireApiAuth(): Promise<AuthResult>;
+export declare function unauthorizedContent(reason: AuthResult & {
+    ok: false;
+}): {
+    isError: true;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};

package/dist/auth.js

@@ -0,0 +1,40 @@
+import { getApiEndpoint, getApiToken } from "./config.js";
+/**
+ * Require the API to validate the bearer token before running any tool.
+ */
+export async function requireApiAuth() {
+    const token = getApiToken();
+    if (!token) {
+        return { ok: false, reason: "missing_token" };
+    }
+    try {
+        const res = await fetch(getApiEndpoint("/user"), {
+            headers: {
+                Accept: "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (res.status === 401 || res.status === 403) {
+            return { ok: false, reason: "unauthorized" };
+        }
+        if (!res.ok) {
+            return { ok: false, reason: "unauthorized" };
+        }
+        const user = (await res.json());
+        return { ok: true, userId: user.id };
+    }
+    catch {
+        return { ok: false, reason: "api_unavailable" };
+    }
+}
+export function unauthorizedContent(reason) {
+    const text = reason.reason === "missing_token"
+        ? "unauthorized: set SKALEAGENTS_API_TOKEN"
+        : reason.reason === "unauthorized"
+            ? "unauthorized: invalid SKALEAGENTS_API_TOKEN"
+            : "api unavailable: could not validate SKALEAGENTS_API_TOKEN";
+    return {
+        isError: true,
+        content: [{ type: "text", text }],
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+export declare function getApiUrl(): string;
+export declare function getApiEndpoint(path: string): string;
+export declare function getApiToken(): string;

package/dist/config.js

@@ -0,0 +1,11 @@
+export function getApiUrl() {
+    return (process.env.PLATFORM_API_URL?.replace(/\/$/, "") ?? "http://localhost:4000");
+}
+export function getApiEndpoint(path) {
+    const rawPrefix = (process.env.PLATFORM_API_PREFIX ?? "").replace(/\/$/, "");
+    const prefix = rawPrefix && !rawPrefix.startsWith("/") ? `/${rawPrefix}` : rawPrefix;
+    return `${getApiUrl()}${prefix}${path.startsWith("/") ? path : `/${path}`}`;
+}
+export function getApiToken() {
+    return process.env.SKALEAGENTS_API_TOKEN?.trim() ?? "";
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { requireApiAuth, unauthorizedContent } from "./auth.js";
+import { cannedFindings, countIacResources, fetchPublicBotHints, } from "./review.js";
+const server = new McpServer({
+    name: "skaleagents-swarm",
+    version: "0.1.0",
+});
+server.registerTool("review_architecture", {
+    title: "Review architecture",
+    description: "Request a high-level architecture / security review of a code or IaC snippet.",
+    inputSchema: {
+        content: z.string().describe("Source or IaC text to review"),
+        focus: z
+            .string()
+            .optional()
+            .describe("Review focus: security, reliability, cost, general"),
+    },
+}, async ({ content, focus }) => {
+    const auth = await requireApiAuth();
+    if (!auth.ok)
+        return unauthorizedContent(auth);
+    const botHints = await fetchPublicBotHints();
+    const focusValue = focus === "security" ||
+        focus === "reliability" ||
+        focus === "cost" ||
+        focus === "general"
+        ? focus
+        : "general";
+    const output = {
+        summary: "Phase 1 stub architecture review from @skaleagents/swarm",
+        findings: cannedFindings(content, focusValue),
+        botHints,
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+    };
+});
+server.registerTool("scan_iac_stub", {
+    title: "Scan IaC (stub)",
+    description: "Stub seam for Phase 2 DevSecOps IaC scanning.",
+    inputSchema: {
+        content: z
+            .string()
+            .describe("Terraform / CloudFormation / Kubernetes YAML"),
+        format: z
+            .string()
+            .optional()
+            .describe("terraform, cloudformation, kubernetes, auto"),
+    },
+}, async ({ content, format }) => {
+    const auth = await requireApiAuth();
+    if (!auth.ok)
+        return unauthorizedContent(auth);
+    const formatValue = format === "terraform" ||
+        format === "cloudformation" ||
+        format === "kubernetes" ||
+        format === "auto"
+        ? format
+        : "auto";
+    const output = {
+        status: "stub",
+        message: "Full IaC scanning lands in Phase 2 agent-swarm",
+        format: formatValue,
+        parsedResourceCount: countIacResources(content),
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+    };
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/review.d.ts

@@ -0,0 +1,9 @@
+export type FindingSeverity = "info" | "low" | "medium" | "high" | "critical";
+export type Finding = {
+    severity: FindingSeverity;
+    title: string;
+    detail: string;
+};
+export declare function cannedFindings(content: string, focus: string): Finding[];
+export declare function fetchPublicBotHints(): Promise<string[]>;
+export declare function countIacResources(content: string): number;

package/dist/review.js

@@ -0,0 +1,48 @@
+import { getApiEndpoint, getApiToken } from "./config.js";
+export function cannedFindings(content, focus) {
+    const findings = [
+        {
+            severity: "info",
+            title: "Stub review",
+            detail: `Phase 1 canned review (focus=${focus}). Length=${content.length} chars.`,
+        },
+    ];
+    if (/0\.0\.0\.0(?:\/0)?/.test(content)) {
+        findings.push({
+            severity: "high",
+            title: "Broad network exposure",
+            detail: "Detected a possible wide-open CIDR or bind address.",
+        });
+    }
+    if (/AKIA[0-9A-Z]{16}/.test(content)) {
+        findings.push({
+            severity: "critical",
+            title: "Possible AWS access key",
+            detail: "Remove secrets from source; rotate credentials.",
+        });
+    }
+    return findings;
+}
+export async function fetchPublicBotHints() {
+    try {
+        const res = await fetch(getApiEndpoint("/bots"), {
+            headers: {
+                Accept: "application/json",
+                Authorization: `Bearer ${getApiToken()}`,
+            },
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return data.bots
+            .filter((b) => b.status === "published" && b.visibility === "public")
+            .map((b) => b.name)
+            .slice(0, 5);
+    }
+    catch {
+        return [];
+    }
+}
+export function countIacResources(content) {
+    return (content.match(/\bresource\b|\bkind:\s*\w+/gi) ?? []).length;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@skaleagents/swarm",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "SkaleAgents MCP server — stdio tools against the Laravel api",
+  "bin": {
+    "skaleagents-swarm": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test src/**/*.test.ts",
+    "smoke": "tsx scripts/smoke-tools.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "tsx": "^4.23.12",
+    "typescript": "^5.7.3"
+  }
+}