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

package/src/__tests__.bak/regression.test.ts

@@ -0,0 +1,434 @@
+/**
+ * Regression Tests - Preventing Known Issues
+ *
+ * These tests specifically verify that bugs we've encountered and fixed
+ * do not re-occur. Each test documents the original issue, what broke,
+ * and how we prevent it from happening again.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { existsSync } from "fs";
+import { mkdir, rmdir, readFile, readdir } from "fs/promises";
+import { join } from "path";
+import { execa } from "execa";
+
+describe("Regression Tests", () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    tempDir = join(process.cwd(), ".test-regression");
+    await mkdir(tempDir, { recursive: true });
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    try {
+      if (existsSync(tempDir)) {
+        await rmdir(tempDir, { recursive: true });
+      }
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe("Regression #1: workspace:* Dependencies Not Resolved", () => {
+    /**
+     * WHAT BROKE: v1.2.0 was published with workspace:* dependencies
+     * IMPACT: npm couldn't install the package - 404 errors
+     * ROOT CAUSE: Build process didn't rewrite workspace protocol
+     * FIX: Ensured dependencies use proper semver versions
+     */
+
+    it("should NOT contain workspace:* in dependencies", async () => {
+      const packageJson = JSON.parse(
+        await readFile(join(__dirname, "../../package.json"), "utf-8")
+      );
+
+      const allDeps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+        ...packageJson.peerDependencies,
+      };
+
+      for (const [name, version] of Object.entries(allDeps)) {
+        expect(version).not.toMatch(
+          /workspace:/,
+          `Dependency ${name} should not use workspace: protocol in published package`
+        );
+      }
+    });
+
+    it("should use valid semver for @kya-os/* dependencies", async () => {
+      const packageJson = JSON.parse(
+        await readFile(join(__dirname, "../../package.json"), "utf-8")
+      );
+
+      const deps = packageJson.dependencies || {};
+
+      if (deps["@kya-os/mcp-i"]) {
+        expect(deps["@kya-os/mcp-i"]).toMatch(
+          /^\^?\d+\.\d+\.\d+$/,
+          "@kya-os/mcp-i should use valid semver"
+        );
+      }
+
+      if (deps["@kya-os/cli"]) {
+        expect(deps["@kya-os/cli"]).toMatch(
+          /^\^?\d+\.\d+\.\d+$/,
+          "@kya-os/cli should use valid semver"
+        );
+      }
+    });
+  });
+
+  describe("Regression #2: Invalid Config Field Generated", () => {
+    /**
+     * WHAT BROKE: xmcp.config.ts had identity: { enabled: true }
+     * IMPACT: TypeScript compilation errors in generated projects
+     * ROOT CAUSE: Template included field that doesn't exist in type
+     * FIX: Removed invalid identity field from config generator
+     */
+
+    it("should NOT generate identity field in xmcp.config.ts", async () => {
+      // Simulate config generation
+      const { generateXmcpConfig } = await import("../helpers/generate-config.js");
+
+      const config = await generateXmcpConfig({
+        transports: ["stdio"],
+        projectName: "test-project",
+      });
+
+      expect(config).not.toMatch(/identity:\s*{/);
+      expect(config).not.toMatch(/enabled:\s*true/);
+    });
+
+    it("generated config should be valid TypeScript", async () => {
+      const { generateXmcpConfig } = await import("../helpers/generate-config.js");
+
+      const config = await generateXmcpConfig({
+        transports: ["http"],
+        projectName: "test-project",
+      });
+
+      // Write to temp file
+      const configPath = join(tempDir, "xmcp.config.ts");
+      await import("fs/promises").then((fs) =>
+        fs.writeFile(configPath, config)
+      );
+
+      // Should have no typescript errors
+      try {
+        await execa("npx", ["tsc", "--noEmit", configPath], {
+          cwd: process.cwd(),
+        });
+        // If no error thrown, test passes
+        expect(true).toBe(true);
+      } catch (error: any) {
+        // If typescript finds errors, fail the test
+        throw new Error(`TypeScript compilation failed: ${error.stderr}`);
+      }
+    });
+  });
+
+  describe("Regression #3: Wrong Package Names in Templates", () => {
+    /**
+     * WHAT BROKE: Templates used "mcp-i" instead of "@kya-os/mcp-i"
+     * IMPACT: npm 404 errors - package doesn't exist
+     * ROOT CAUSE: Forgot to update package names after scoping
+     * FIX: Updated all templates to use scoped package names
+     */
+
+    it("should use scoped @kya-os/* package names", async () => {
+      const { applyIdentityPreset } = await import(
+        "../helpers/apply-identity-preset.js"
+      );
+
+      // Create a mock project
+      const projectPath = join(tempDir, "test-project");
+      await mkdir(projectPath, { recursive: true });
+
+      // Create basic package.json
+      await import("fs/promises").then((fs) =>
+        fs.writeFile(
+          join(projectPath, "package.json"),
+          JSON.stringify({
+            name: "test-project",
+            version: "0.1.0",
+            dependencies: {},
+          })
+        )
+      );
+
+      // Apply identity preset
+      await applyIdentityPreset({
+        projectPath,
+        projectName: "test-project",
+        transports: ["stdio"],
+      });
+
+      // Read generated package.json
+      const packageJson = JSON.parse(
+        await readFile(join(projectPath, "package.json"), "utf-8")
+      );
+
+      // Should have scoped names
+      expect(packageJson.dependencies["@kya-os/mcp-i"]).toBeDefined();
+      expect(packageJson.dependencies["@kya-os/cli"]).toBeDefined();
+
+      // Should NOT have unscoped names
+      expect(packageJson.dependencies["mcp-i"]).toBeUndefined();
+      expect(packageJson.dependencies["cli"]).toBeUndefined();
+    });
+  });
+
+  describe("Regression #4: Wrong Binary Names in Scripts", () => {
+    /**
+     * WHAT BROKE: Scripts used "mcp-i" but binary is "mcpi"
+     * IMPACT: Command not found errors
+     * ROOT CAUSE: Binary was renamed but scripts weren't updated
+     * FIX: Updated all scripts to use correct binary name
+     */
+
+    it("should use correct mcpi binary in all scripts", async () => {
+      const { applyIdentityPreset } = await import(
+        "../helpers/apply-identity-preset.js"
+      );
+
+      const projectPath = join(tempDir, "test-project");
+      await mkdir(projectPath, { recursive: true });
+
+      await import("fs/promises").then((fs) =>
+        fs.writeFile(
+          join(projectPath, "package.json"),
+          JSON.stringify({
+            name: "test-project",
+            version: "0.1.0",
+            scripts: {},
+          })
+        )
+      );
+
+      await applyIdentityPreset({
+        projectPath,
+        projectName: "test-project",
+        transports: ["http"],
+      });
+
+      const packageJson = JSON.parse(
+        await readFile(join(projectPath, "package.json"), "utf-8")
+      );
+
+      const scripts = packageJson.scripts;
+
+      // Verify all scripts use "mcpi"
+      expect(scripts.dev).toBe("mcpi dev");
+      expect(scripts.build).toBe("mcpi build");
+      expect(scripts.init).toBe("mcpi init");
+      expect(scripts.register).toBe("mcpi register");
+      expect(scripts.status).toBe("mcpi status");
+
+      // Verify NO scripts use old "mcp-i" binary
+      for (const [name, script] of Object.entries(scripts)) {
+        expect(script).not.toMatch(
+          /\bmcp-i\b/,
+          `Script ${name} should not use old mcp-i binary`
+        );
+      }
+    });
+
+    it("should have exactly 8 scripts as specified", async () => {
+      const { applyIdentityPreset } = await import(
+        "../helpers/apply-identity-preset.js"
+      );
+
+      const projectPath = join(tempDir, "test-project");
+      await mkdir(projectPath, { recursive: true });
+
+      await import("fs/promises").then((fs) =>
+        fs.writeFile(
+          join(projectPath, "package.json"),
+          JSON.stringify({
+            name: "test-project",
+            version: "0.1.0",
+            scripts: {},
+          })
+        )
+      );
+
+      await applyIdentityPreset({
+        projectPath,
+        projectName: "test-project",
+        transports: ["stdio"],
+      });
+
+      const packageJson = JSON.parse(
+        await readFile(join(projectPath, "package.json"), "utf-8")
+      );
+
+      const scriptNames = Object.keys(packageJson.scripts);
+      expect(scriptNames).toHaveLength(8);
+
+      expect(scriptNames).toContain("dev");
+      expect(scriptNames).toContain("build");
+      expect(scriptNames).toContain("start");
+      expect(scriptNames).toContain("init");
+      expect(scriptNames).toContain("register");
+      expect(scriptNames).toContain("keys:rotate");
+      expect(scriptNames).toContain("identity:clean");
+      expect(scriptNames).toContain("status");
+    });
+  });
+
+  describe("Regression #5: Reference Error in Callbacks", () => {
+    /**
+     * WHAT BROKE: onProgress callback accessed 'result' before definition
+     * IMPACT: Runtime error during identity creation
+     * ROOT CAUSE: Trying to access Promise result inside callback
+     * FIX: Moved effect calls outside the callback, after result available
+     */
+
+    it("should not have reference to unavailable variables in templates", async () => {
+      // This is tested more thoroughly in CLI tests
+      // Here we just verify the template doesn't have obvious issues
+
+      const { applyIdentityPreset } = await import(
+        "../helpers/apply-identity-preset.js"
+      );
+
+      const projectPath = join(tempDir, "test-project");
+      await mkdir(projectPath, { recursive: true });
+      await mkdir(join(projectPath, "src"), { recursive: true });
+
+      await applyIdentityPreset({
+        projectPath,
+        projectName: "test-project",
+        transports: ["stdio"],
+      });
+
+      // Check that middleware.ts was created
+      const middlewarePath = join(projectPath, "src", "middleware.ts");
+      expect(existsSync(middlewarePath)).toBe(true);
+
+      const middlewareContent = await readFile(middlewarePath, "utf-8");
+
+      // Should not have obvious reference errors
+      expect(middlewareContent).toContain("createMCPIRuntime");
+      expect(middlewareContent).toContain("identityMiddleware");
+    });
+  });
+
+  describe("Regression #6: .gitignore Missing Identity Files", () => {
+    /**
+     * WHAT BROKE: .mcpi directory could be committed to git
+     * IMPACT: Private keys exposed in version control
+     * ROOT CAUSE: .gitignore not updated
+     * FIX: Ensured .mcpi/ is always gitignored
+     */
+
+    it("should add .mcpi to .gitignore", async () => {
+      const { applyIdentityPreset } = await import(
+        "../helpers/apply-identity-preset.js"
+      );
+
+      const projectPath = join(tempDir, "test-project");
+      await mkdir(projectPath, { recursive: true });
+
+      await applyIdentityPreset({
+        projectPath,
+        projectName: "test-project",
+        transports: ["stdio"],
+      });
+
+      const gitignorePath = join(projectPath, ".gitignore");
+      expect(existsSync(gitignorePath)).toBe(true);
+
+      const gitignoreContent = await readFile(gitignorePath, "utf-8");
+
+      expect(gitignoreContent).toContain(".mcpi/");
+      expect(gitignoreContent).toContain(".env.local");
+    });
+
+    it("should preserve existing .gitignore entries", async () => {
+      const { applyIdentityPreset } = await import(
+        "../helpers/apply-identity-preset.js"
+      );
+
+      const projectPath = join(tempDir, "test-project");
+      await mkdir(projectPath, { recursive: true });
+
+      // Create existing .gitignore
+      const existingContent = "node_modules/\ndist/\n.DS_Store\n";
+      await import("fs/promises").then((fs) =>
+        fs.writeFile(join(projectPath, ".gitignore"), existingContent)
+      );
+
+      await applyIdentityPreset({
+        projectPath,
+        projectName: "test-project",
+        transports: ["stdio"],
+      });
+
+      const gitignoreContent = await readFile(
+        join(projectPath, ".gitignore"),
+        "utf-8"
+      );
+
+      // Should have both old and new entries
+      expect(gitignoreContent).toContain("node_modules/");
+      expect(gitignoreContent).toContain("dist/");
+      expect(gitignoreContent).toContain(".DS_Store");
+      expect(gitignoreContent).toContain(".mcpi/");
+    });
+  });
+
+  describe("Regression #7: Project Structure Validation", () => {
+    /**
+     * WHAT BROKE: Missing directories caused file write errors
+     * IMPACT: Scaffolding failed midway through
+     * ROOT CAUSE: Didn't ensure parent directories existed
+     * FIX: Use ensureDir before writing files
+     */
+
+    it("should create all necessary directories", async () => {
+      const { applyIdentityPreset } = await import(
+        "../helpers/apply-identity-preset.js"
+      );
+
+      const projectPath = join(tempDir, "test-project");
+      await mkdir(projectPath, { recursive: true });
+
+      await applyIdentityPreset({
+        projectPath,
+        projectName: "test-project",
+        transports: ["http"],
+      });
+
+      // Verify directories exist
+      expect(existsSync(join(projectPath, "src"))).toBe(true);
+      expect(existsSync(join(projectPath, "src", "tools"))).toBe(true);
+      expect(existsSync(join(projectPath, ".mcpi"))).toBe(true);
+    });
+
+    it("should handle existing directories gracefully", async () => {
+      const { applyIdentityPreset } = await import(
+        "../helpers/apply-identity-preset.js"
+      );
+
+      const projectPath = join(tempDir, "test-project");
+      await mkdir(projectPath, { recursive: true });
+      await mkdir(join(projectPath, "src"), { recursive: true });
+      await mkdir(join(projectPath, "src", "tools"), { recursive: true });
+
+      // Should not throw
+      await expect(
+        applyIdentityPreset({
+          projectPath,
+          projectName: "test-project",
+          transports: ["stdio"],
+        })
+      ).resolves.not.toThrow();
+    });
+  });
+});

package/src/effects/index.ts

@@ -0,0 +1,80 @@
+import { 
+  BlackholeEffect, 
+  EffectRunner,
+  createSuccessBox,
+  createWelcomeBanner,
+  createGradientText,
+  createAgentTable
+} from "@kya-os/cli-effects";
+
+export { BlackholeEffect, EffectRunner, createSuccessBox, createWelcomeBanner, createGradientText };
+
+export async function showBlackholeAnimation(
+  text: string,
+  options?: any,
+  skipExitPrompt: boolean = false
+): Promise<void> {
+  const runner = new EffectRunner();
+  const effect = new BlackholeEffect(options);
+  await runner.run({
+    effect: effect as any,
+    text,
+    skipExitPrompt
+  });
+}
+
+// Display the claim URL as the success message
+export function createSuccessMessage(claimUrl?: string): string {
+  if (claimUrl) {
+    // Format the claim URL for display
+    return `
+🔗 Claim Your Agent Identity:
+
+${claimUrl}
+
+Your agent is ready to be claimed!`;
+  }
+  
+  // Fallback if no claim URL
+  return createSuccessBox(
+    "XMCP-I INITIALIZED", 
+    "Your AI agent now has a verifiable decentralized identity"
+  );
+}
+
+// Use the package's createWelcomeBanner for banners
+export async function createKYAOSBanner(): Promise<string> {
+  return await createWelcomeBanner("XMCP-I");
+}
+
+// Wrapper function that maps our field names to the package's expected names
+export function createIdentityTable(data: {
+  agentName: string;
+  description: string;
+  did: string;
+  profileUrl: string;
+  privateKey: string;
+  claimUrl?: string;
+}): string {
+  // Map field names to match the package's AgentData interface
+  const agentData = {
+    name: data.agentName,  // Map agentName to name
+    description: data.description,
+    did: data.did,
+    publicKey: undefined,  // Not used in our implementation
+    privateKey: data.privateKey,
+    agentSlug: undefined,  // Not used, profileUrl is provided directly
+    claimUrl: data.claimUrl,
+    profileUrl: data.profileUrl
+  };
+
+  // Use the package's createAgentTable
+  let tableOutput = createAgentTable(agentData);
+  
+  // Add claim URL below the table if it exists (since package doesn't show it)
+  if (data.claimUrl) {
+    tableOutput += "\n\n🔗 Claim URL (clickable):\n" + data.claimUrl;
+  }
+  
+  return tableOutput;
+}