@cortexmemory/cli 0.26.2 → 0.27.3

package/templates/vercel-ai-quickstart/lib/password.ts

@@ -0,0 +1,120 @@
+/**
+ * Password Hashing Utilities
+ *
+ * Uses Web Crypto API (PBKDF2) for password hashing.
+ * Works in Edge runtime - no external dependencies.
+ */
+
+const ITERATIONS = 100000;
+const KEY_LENGTH = 256;
+const SALT_LENGTH = 16;
+
+/**
+ * Hash a password using PBKDF2
+ *
+ * @param password - Plain text password to hash
+ * @returns Hashed password as base64 string (format: salt:hash)
+ */
+export async function hashPassword(password: string): Promise<string> {
+  const encoder = new TextEncoder();
+  const passwordBuffer = encoder.encode(password);
+
+  // Generate random salt
+  const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
+
+  // Import password as key material
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    passwordBuffer,
+    "PBKDF2",
+    false,
+    ["deriveBits"]
+  );
+
+  // Derive key using PBKDF2
+  const derivedBits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt,
+      iterations: ITERATIONS,
+      hash: "SHA-256",
+    },
+    keyMaterial,
+    KEY_LENGTH
+  );
+
+  // Convert to base64 strings
+  const saltB64 = btoa(String.fromCharCode(...salt));
+  const hashB64 = btoa(String.fromCharCode(...new Uint8Array(derivedBits)));
+
+  // Return combined format: salt:hash
+  return `${saltB64}:${hashB64}`;
+}
+
+/**
+ * Verify a password against a stored hash
+ *
+ * @param password - Plain text password to verify
+ * @param storedHash - Previously hashed password (format: salt:hash)
+ * @returns True if password matches
+ */
+export async function verifyPassword(
+  password: string,
+  storedHash: string
+): Promise<boolean> {
+  try {
+    const [saltB64, expectedHashB64] = storedHash.split(":");
+    if (!saltB64 || !expectedHashB64) {
+      return false;
+    }
+
+    const encoder = new TextEncoder();
+    const passwordBuffer = encoder.encode(password);
+
+    // Decode salt from base64
+    const saltStr = atob(saltB64);
+    const salt = new Uint8Array(saltStr.length);
+    for (let i = 0; i < saltStr.length; i++) {
+      salt[i] = saltStr.charCodeAt(i);
+    }
+
+    // Import password as key material
+    const keyMaterial = await crypto.subtle.importKey(
+      "raw",
+      passwordBuffer,
+      "PBKDF2",
+      false,
+      ["deriveBits"]
+    );
+
+    // Derive key using same parameters
+    const derivedBits = await crypto.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        salt,
+        iterations: ITERATIONS,
+        hash: "SHA-256",
+      },
+      keyMaterial,
+      KEY_LENGTH
+    );
+
+    // Compare hashes
+    const hashB64 = btoa(String.fromCharCode(...new Uint8Array(derivedBits)));
+    return hashB64 === expectedHashB64;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Generate a secure random session token
+ *
+ * @returns Random token as hex string
+ */
+export function generateSessionToken(): string {
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}

package/templates/vercel-ai-quickstart/next.config.js

@@ -0,0 +1,27 @@
+const path = require("path");
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  transpilePackages: ["@cortexmemory/sdk", "@cortexmemory/vercel-ai-provider"],
+  serverExternalPackages: ["convex"],
+  experimental: {
+    // Ensure linked packages resolve dependencies from this project's node_modules
+    externalDir: true,
+  },
+  // Empty turbopack config to silence the warning about missing turbopack config
+  turbopack: {},
+  // Webpack configuration for module resolution when SDK is file-linked
+  // This is needed because the SDK uses dynamic imports that don't resolve
+  // correctly from a linked package's location during local development
+  webpack: (config) => {
+    config.resolve.alias = {
+      ...config.resolve.alias,
+      "@anthropic-ai/sdk": path.resolve(__dirname, "node_modules/@anthropic-ai/sdk"),
+      "openai": path.resolve(__dirname, "node_modules/openai"),
+      "neo4j-driver": path.resolve(__dirname, "node_modules/neo4j-driver"),
+    };
+    return config;
+  },
+};
+
+module.exports = nextConfig;

package/templates/vercel-ai-quickstart/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@cortexmemory/vercel-ai-quickstart",
+  "version": "1.0.0",
+  "private": true,
+  "license": "UNLICENSED",
+  "description": "Cortex Memory + Vercel AI SDK Quickstart Demo",
+  "scripts": {
+    "dev": "next dev --webpack",
+    "build": "next build --webpack",
+    "start": "next start",
+    "lint": "next lint",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "convex:dev": "convex dev",
+    "convex:deploy": "convex deploy"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^3.0.1",
+    "@ai-sdk/react": "^3.0.3",
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@cortexmemory/sdk": "file:../../..",
+    "@cortexmemory/vercel-ai-provider": "file:..",
+    "ai": "^6.0.3",
+    "convex": "^1.31.2",
+    "framer-motion": "^12.23.26",
+    "neo4j-driver": "^6.0.1",
+    "next": "^16.1.1",
+    "openai": "^6.15.0",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.1.18",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "autoprefixer": "^10.4.23",
+    "jest": "^29.7.0",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^4.1.18",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.9.3"
+  }
+}

package/templates/vercel-ai-quickstart/postcss.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};

package/templates/vercel-ai-quickstart/tailwind.config.js

@@ -0,0 +1,37 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    "./app/**/*.{js,ts,jsx,tsx,mdx}",
+    "./components/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+    extend: {
+      colors: {
+        cortex: {
+          50: "#f0f7ff",
+          100: "#e0effe",
+          200: "#b9dffc",
+          300: "#7cc5fa",
+          400: "#36a8f5",
+          500: "#0c8ce6",
+          600: "#006fc4",
+          700: "#0159a0",
+          800: "#064b84",
+          900: "#0b3f6d",
+          950: "#072848",
+        },
+      },
+      animation: {
+        "pulse-slow": "pulse 3s cubic-bezier(0.4, 0, 0.6, 1) infinite",
+        flow: "flow 2s ease-in-out infinite",
+      },
+      keyframes: {
+        flow: {
+          "0%, 100%": { opacity: "0.3" },
+          "50%": { opacity: "1" },
+        },
+      },
+    },
+  },
+  plugins: [],
+};

package/templates/vercel-ai-quickstart/tests/helpers/mock-cortex.ts

@@ -0,0 +1,263 @@
+/**
+ * Mock Cortex SDK
+ *
+ * Provides a mock implementation of the Cortex SDK for testing.
+ * Simulates the SDK behavior without requiring a real Convex backend.
+ */
+
+// In-memory stores for test state
+let mutableStore: Map<string, Map<string, unknown>> = new Map();
+let usersStore: Map<string, { userId: string; data: Record<string, unknown> }> =
+  new Map();
+interface StoredConversation {
+  conversationId: string;
+  memorySpaceId: string;
+  type: string;
+  participants: { userId?: string; agentId?: string };
+  metadata: Record<string, unknown>;
+  createdAt: number;
+  updatedAt: number;
+  messageCount: number;
+  messages?: Array<{
+    id: string;
+    role: string;
+    content: string;
+    timestamp: number;
+  }>;
+}
+
+let conversationsStore: Map<string, StoredConversation> = new Map();
+
+/**
+ * Reset all mock stores (call in beforeEach)
+ */
+export function resetMockStores(): void {
+  mutableStore = new Map();
+  usersStore = new Map();
+  conversationsStore = new Map();
+}
+
+/**
+ * Create a mock Cortex SDK instance
+ */
+export function createMockCortex() {
+  return {
+    mutable: {
+      get: jest.fn(
+        async (namespace: string, key: string): Promise<unknown | null> => {
+          const ns = mutableStore.get(namespace);
+          if (!ns) return null;
+          return ns.get(key) ?? null;
+        }
+      ),
+      set: jest.fn(
+        async (
+          namespace: string,
+          key: string,
+          value: unknown
+        ): Promise<void> => {
+          if (!mutableStore.has(namespace)) {
+            mutableStore.set(namespace, new Map());
+          }
+          mutableStore.get(namespace)!.set(key, value);
+        }
+      ),
+      delete: jest.fn(
+        async (namespace: string, key: string): Promise<void> => {
+          const ns = mutableStore.get(namespace);
+          if (ns) ns.delete(key);
+        }
+      ),
+    },
+    users: {
+      get: jest.fn(
+        async (
+          userId: string
+        ): Promise<{
+          userId: string;
+          data: Record<string, unknown>;
+        } | null> => {
+          return usersStore.get(userId) ?? null;
+        }
+      ),
+      update: jest.fn(
+        async (
+          userId: string,
+          data: Record<string, unknown>
+        ): Promise<{ userId: string; data: Record<string, unknown> }> => {
+          const existing = usersStore.get(userId);
+          const user = {
+            userId,
+            data: { ...(existing?.data || {}), ...data },
+          };
+          usersStore.set(userId, user);
+          return user;
+        }
+      ),
+      delete: jest.fn(async (userId: string): Promise<void> => {
+        usersStore.delete(userId);
+      }),
+      list: jest.fn(async () => {
+        return {
+          users: Array.from(usersStore.values()),
+          hasMore: false,
+        };
+      }),
+    },
+    conversations: {
+      list: jest.fn(
+        async (params: { memorySpaceId?: string; userId?: string }) => {
+          const conversations = Array.from(conversationsStore.values()).filter(
+            (conv) => {
+              if (
+                params.memorySpaceId &&
+                conv.memorySpaceId !== params.memorySpaceId
+              ) {
+                return false;
+              }
+              if (
+                params.userId &&
+                conv.participants.userId !== params.userId
+              ) {
+                return false;
+              }
+              return true;
+            }
+          );
+          return { conversations, hasMore: false };
+        }
+      ),
+      create: jest.fn(
+        async (params: {
+          memorySpaceId: string;
+          conversationId: string;
+          type: string;
+          participants: { userId?: string; agentId?: string };
+          metadata?: Record<string, unknown>;
+        }) => {
+          const now = Date.now();
+          const conversation = {
+            conversationId: params.conversationId,
+            memorySpaceId: params.memorySpaceId,
+            type: params.type,
+            participants: params.participants,
+            metadata: params.metadata || {},
+            createdAt: now,
+            updatedAt: now,
+            messageCount: 0,
+          };
+          conversationsStore.set(params.conversationId, conversation);
+          return conversation;
+        }
+      ),
+      get: jest.fn(async (conversationId: string, options?: { includeMessages?: boolean; messageLimit?: number }) => {
+        const conv = conversationsStore.get(conversationId);
+        if (!conv) return null;
+        
+        // If includeMessages is requested, return with messages
+        if (options?.includeMessages) {
+          return {
+            ...conv,
+            messages: conv.messages || [],
+          };
+        }
+        
+        // Otherwise return without messages
+        const { messages: _messages, ...convWithoutMessages } = conv;
+        return convWithoutMessages;
+      }),
+      delete: jest.fn(async (conversationId: string): Promise<void> => {
+        conversationsStore.delete(conversationId);
+      }),
+      update: jest.fn(
+        async (
+          conversationId: string,
+          updates: { metadata?: Record<string, unknown> }
+        ) => {
+          const conv = conversationsStore.get(conversationId);
+          if (!conv) throw new Error("Conversation not found");
+          const updated = {
+            ...conv,
+            metadata: { ...conv.metadata, ...updates.metadata },
+            updatedAt: Date.now(),
+          };
+          conversationsStore.set(conversationId, updated);
+          return updated;
+        }
+      ),
+    },
+    memory: {
+      search: jest.fn().mockResolvedValue([]),
+      remember: jest.fn().mockResolvedValue({
+        conversation: { conversationId: "conv-1", messageIds: [] },
+        memories: [],
+        facts: [],
+      }),
+      recall: jest.fn().mockResolvedValue({
+        context: "",
+        totalResults: 0,
+        queryTimeMs: 10,
+        sources: { vector: { count: 0, items: [] } },
+      }),
+    },
+    close: jest.fn(),
+  };
+}
+
+/**
+ * Type for the mock Cortex instance
+ */
+export type MockCortex = ReturnType<typeof createMockCortex>;
+
+/**
+ * Helper to seed test data into stores
+ */
+export const seedTestData = {
+  user: (
+    userId: string,
+    data: Record<string, unknown> = {}
+  ): { userId: string; data: Record<string, unknown> } => {
+    const user = { userId, data };
+    usersStore.set(userId, user);
+    return user;
+  },
+  mutable: (namespace: string, key: string, value: unknown): void => {
+    if (!mutableStore.has(namespace)) {
+      mutableStore.set(namespace, new Map());
+    }
+    mutableStore.get(namespace)!.set(key, value);
+  },
+  conversation: (
+    conversationId: string,
+    params: {
+      memorySpaceId?: string;
+      userId?: string;
+      title?: string;
+      messages?: Array<{ role: string; content: string }>;
+    } = {}
+  ) => {
+    const now = Date.now();
+    const messages = params.messages?.map((msg, i) => ({
+      id: `msg-${i}`,
+      role: msg.role,
+      content: msg.content,
+      timestamp: now + i,
+    }));
+    const conversation: StoredConversation = {
+      conversationId,
+      memorySpaceId: params.memorySpaceId || "quickstart-demo",
+      type: "user-agent",
+      participants: {
+        userId: params.userId || "test-user",
+        agentId: "quickstart-assistant",
+      },
+      metadata: { title: params.title || "Test Chat" },
+      createdAt: now,
+      updatedAt: now,
+      messageCount: messages?.length || 0,
+      messages,
+    };
+    conversationsStore.set(conversationId, conversation);
+    return conversation;
+  },
+};

package/templates/vercel-ai-quickstart/tests/helpers/setup.ts

@@ -0,0 +1,48 @@
+/**
+ * Jest Test Setup
+ *
+ * Configures global test environment for quickstart tests.
+ */
+
+import { TextEncoder, TextDecoder } from "util";
+
+// Polyfill TextEncoder/TextDecoder for Node.js environment
+global.TextEncoder = TextEncoder;
+global.TextDecoder = TextDecoder as typeof global.TextDecoder;
+
+// Polyfill crypto for Node.js environment (required for password utilities)
+if (typeof global.crypto === "undefined") {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { webcrypto } = require("crypto");
+  global.crypto = webcrypto;
+}
+
+// Polyfill btoa/atob for Node.js environment
+if (typeof global.btoa === "undefined") {
+  global.btoa = (str: string) => Buffer.from(str, "binary").toString("base64");
+}
+
+if (typeof global.atob === "undefined") {
+  global.atob = (str: string) => Buffer.from(str, "base64").toString("binary");
+}
+
+// Set test environment variables
+process.env.NODE_ENV = "test";
+process.env.CONVEX_URL = "https://test.convex.cloud";
+
+// Suppress console output during tests (optional - comment out for debugging)
+// global.console = {
+//   ...console,
+//   log: jest.fn(),
+//   debug: jest.fn(),
+//   info: jest.fn(),
+//   warn: jest.fn(),
+// };
+
+// Increase test timeout for async operations
+jest.setTimeout(10000);
+
+// Reset mocks between tests
+beforeEach(() => {
+  jest.clearAllMocks();
+});