@kya-os/create-mcpi-app 1.7.19 → 1.7.20

package/src/helpers/create.ts

@@ -0,0 +1,239 @@
+import path from "path";
+import fs from "fs-extra";
+import { fileURLToPath } from "url";
+import { fetchMCPITemplate } from "./fetch-mcpi-template.js";
+import { fetchCloudflareTemplate } from "./fetch-cloudflare-template.js";
+import { fetchCloudflareMcpiTemplate } from "./fetch-cloudflare-mcpi-template.js";
+import { renameFiles } from "./rename.js";
+import { install } from "./install.js";
+import {
+  validateProjectStructure,
+  ensureLockfile,
+} from "./validate-project-structure.js";
+import { ScaffolderResult } from "@kya-os/contracts";
+import chalk from "chalk";
+import crypto from "crypto";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Function to generate claim URL
+function generateClaimUrl(did: string, privateKeyBase64: string): string {
+  try {
+    const timestamp = Date.now();
+    const message = `${did}:${timestamp}`;
+
+    const privateKeyBuffer = Buffer.from(privateKeyBase64, "base64");
+    const privateKeyBytes =
+      privateKeyBuffer.length === 64
+        ? privateKeyBuffer.subarray(0, 32)
+        : privateKeyBuffer;
+
+    const privateKey = crypto.createPrivateKey({
+      key: Buffer.concat([
+        Buffer.from("302e020100300506032b657004220420", "hex"),
+        privateKeyBytes,
+      ]),
+      format: "der",
+      type: "pkcs8",
+    });
+
+    const signature = crypto.sign(null, Buffer.from(message), privateKey);
+    const signatureBase64 = signature.toString("base64");
+
+    const params = new URLSearchParams({
+      did: did,
+      timestamp: timestamp.toString(),
+      signature: signatureBase64,
+    });
+
+    return `https://knowthat.ai/agents/claim?${params.toString()}`;
+  } catch (error) {
+    console.error("Error generating claim URL:", error);
+    return "";
+  }
+}
+
+interface CreateProjectOptions {
+  projectPath: string;
+  projectName: string;
+  packageManager: string;
+  transports: string[];
+  packageVersion: string;
+  useLocalXmcp?: boolean;
+  mcpiVersion?: string;
+  deployToVercel?: boolean;
+  skipInstall?: boolean;
+  agentName?: string;
+  agentDescription?: string;
+  agentRepository?: string;
+  skipIdentity?: boolean;
+  skipAnimation?: boolean;
+  fastAnimation?: boolean;
+  spinner?: any; // ora spinner instance
+  platform?: string; // Platform: 'node' or 'cloudflare'
+  mode?: string; // Mode: 'mcp-i' or 'verifier'
+  template?: string; // [DEPRECATED] Template type: 'default' or 'cloudflare'
+  apikey?: string; // AgentShield API key for Cloudflare deployment
+  projectId?: string; // AgentShield Project ID for Cloudflare deployment
+}
+
+/**
+ * Create necessary project directories
+ */
+function createProjectDirectories(projectPath: string): void {
+  fs.ensureDirSync(path.join(projectPath, ".mcpi"));
+}
+
+/**
+ * Create a new MCP-I project with identity features
+ */
+export async function createProject(
+  options: CreateProjectOptions
+): Promise<ScaffolderResult> {
+  const {
+    projectPath,
+    projectName,
+    packageManager,
+    transports,
+    packageVersion,
+    useLocalXmcp,
+    mcpiVersion,
+    deployToVercel,
+    skipInstall,
+    agentName = projectName,
+    agentDescription = "MCP-I server with identity features",
+    agentRepository = "",
+    skipIdentity = false,
+    skipAnimation = false,
+    fastAnimation = false,
+    platform = "node",
+    mode = "mcp-i",
+    template = "default",
+    apikey,
+    projectId,
+  } = options;
+
+  const warnings: string[] = [];
+  let resolvedMcpiVersion = mcpiVersion;
+
+  try {
+    // Ensure the project directory exists
+    fs.ensureDirSync(projectPath);
+
+    // Scaffold project based on platform/mode
+    console.log(chalk.blue("\n📁 Scaffolding project..."));
+
+    if (platform === "cloudflare" && mode === "verifier") {
+      // Cloudflare Worker verifier template (standalone verifier)
+      await fetchCloudflareTemplate(projectPath, {
+        packageManager,
+      });
+    } else if (platform === "cloudflare" && mode === "mcp-i") {
+      // Cloudflare Worker MCP-I server template (NEW)
+      await fetchCloudflareMcpiTemplate(projectPath, {
+        packageManager,
+        projectName,
+        apikey,
+        projectId,
+        skipIdentity,
+      });
+    } else if (platform === "node" && mode === "mcp-i") {
+      // Node.js MCP-I server template (default)
+      await fetchMCPITemplate(projectPath, {
+        mcpiVersion,
+        packageManager,
+        skipIdentity,
+      });
+    } else {
+      throw new Error(`Unsupported platform/mode combination: ${platform}/${mode}`);
+    }
+
+    // Capture the resolved version for the result
+    const packageJsonPath = path.join(projectPath, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = fs.readJsonSync(packageJsonPath);
+      // Try to extract version from dependencies
+      resolvedMcpiVersion =
+        packageJson.dependencies?.["@kya-os/mcp-i"] || mcpiVersion || "unknown";
+    }
+
+    // Rename special files (e.g., _gitignore to .gitignore)
+    renameFiles(projectPath);
+
+    // Add vercel.json if deployToVercel is true
+    if (deployToVercel) {
+      // Create a basic vercel.json for MCP-I deployment
+      const vercelConfig = {
+        functions: {
+          "src/server.ts": {
+            runtime: "@vercel/node@3",
+          },
+        },
+        rewrites: [
+          {
+            source: "/(.*)",
+            destination: "/src/server.ts",
+          },
+        ],
+      };
+
+      fs.writeJsonSync(path.join(projectPath, "vercel.json"), vercelConfig, {
+        spaces: 2,
+      });
+    }
+
+    // Create necessary project directories (skip for cloudflare templates)
+    const isCloudflare = platform === "cloudflare";
+    if (!isCloudflare) {
+      createProjectDirectories(projectPath);
+    }
+
+    // Install project dependencies
+    if (!skipInstall) {
+      install(projectPath, packageManager, packageVersion);
+
+      // Ensure lockfile is properly created
+      ensureLockfile(projectPath, packageManager);
+    }
+
+    // Validate project structure meets requirements (skip for cloudflare)
+    if (!isCloudflare) {
+      const validation = validateProjectStructure(projectPath, !skipIdentity);
+      if (!validation.valid) {
+        console.warn(chalk.yellow("⚠️  Project structure validation issues:"));
+        for (const issue of validation.issues) {
+          console.warn(chalk.yellow(`   - ${issue}`));
+          warnings.push(...validation.issues);
+        }
+      }
+    }
+
+    // Identity setup is now handled by the CLI after scaffolding (not for cloudflare)
+    if (!skipIdentity && !isCloudflare) {
+      console.log(chalk.blue("\n🔐 Identity setup will be handled by the CLI"));
+      console.log(
+        chalk.gray("   Run 'mcpi init' after scaffolding to set up identity")
+      );
+    }
+
+    return {
+      success: true,
+      projectPath,
+      xmcpVersion: resolvedMcpiVersion || "unknown",
+      identityEnabled: !skipIdentity,
+      warnings: warnings.length > 0 ? warnings : undefined,
+    };
+  } catch (error) {
+    console.error(chalk.red("Failed to create project:"), error);
+    return {
+      success: false,
+      projectPath,
+      xmcpVersion: resolvedMcpiVersion || "unknown",
+      identityEnabled: !skipIdentity,
+      warnings: [
+        `Project creation failed: ${error instanceof Error ? error.message : String(error)}`,
+      ],
+    };
+  }
+}