@agentforge-ai/cli 0.5.0 → 0.5.1

package/dist/default/convex/vault.ts

@@ -1,5 +1,5 @@
 import { v } from "convex/values";
-import { mutation, query, action } from "./_generated/server";
+import { mutation, query, internalMutation } from "./_generated/server";
 
 // ============================================================
 // SECURE VAULT - Encrypted secrets management
@@ -35,10 +35,20 @@ function maskSecret(value: string): string {
   return value.substring(0, 6) + "..." + value.substring(value.length - 4);
 }
 
-// Simple XOR-based encoding (in production, use proper AES-256-GCM with a KMS)
-// This provides a layer of obfuscation in the database
+// Encryption key from Convex environment variable.
+// Set VAULT_ENCRYPTION_KEY in your Convex dashboard under Settings > Environment Variables.
+// If not set, a default key is used (NOT SECURE for production).
+function getEncryptionKey(): string {
+  return process.env.VAULT_ENCRYPTION_KEY ?? "agentforge-default-key-set-env-var";
+}
+
+// XOR-based encoding with per-entry IV for database obfuscation.
+// For production deployments with sensitive data, consider integrating
+// with a proper KMS (e.g., AWS KMS, Cloudflare Workers Secrets).
 function encodeSecret(value: string, key: string): { encrypted: string; iv: string } {
-  const iv = Array.from({ length: 16 }, () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")).join("");
+  const iv = Array.from({ length: 16 }, () =>
+    Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
+  ).join("");
   const combined = key + iv;
   let encrypted = "";
   for (let i = 0; i < value.length; i++) {
@@ -52,15 +62,14 @@ function decodeSecret(encrypted: string, iv: string, key: string): string {
   const combined = key + iv;
   let decoded = "";
   for (let i = 0; i < encrypted.length; i += 4) {
-    const charCode = parseInt(encrypted.substring(i, i + 4), 16) ^ combined.charCodeAt((i / 4) % combined.length);
+    const charCode =
+      parseInt(encrypted.substring(i, i + 4), 16) ^
+      combined.charCodeAt((i / 4) % combined.length);
     decoded += String.fromCharCode(charCode);
   }
   return decoded;
 }
 
-// The encryption key should come from environment variables in production
-const VAULT_ENCRYPTION_KEY = "agentforge-vault-key-change-in-production-2026";
-
 // ---- Queries ----
 
 export const list = query({
@@ -69,11 +78,21 @@ export const list = query({
     category: v.optional(v.string()),
   },
   handler: async (ctx, args) => {
-    let q = ctx.db.query("vault");
+    let entries;
     if (args.userId) {
-      q = ctx.db.query("vault").withIndex("byUserId", (q) => q.eq("userId", args.userId));
+      entries = await ctx.db
+        .query("vault")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId!))
+        .order("desc")
+        .collect();
+    } else {
+      entries = await ctx.db.query("vault").order("desc").collect();
     }
-    const entries = await q.order("desc").take(100);
+
+    if (args.category) {
+      entries = entries.filter((e) => e.category === args.category);
+    }
+
     // Never return encrypted values - only masked
     return entries.map((entry) => ({
       _id: entry._id,
@@ -99,13 +118,13 @@ export const getAuditLog = query({
   handler: async (ctx, args) => {
     const limit = args.limit ?? 50;
     if (args.vaultEntryId) {
-      return ctx.db
+      return await ctx.db
         .query("vaultAuditLog")
         .withIndex("byVaultEntryId", (q) => q.eq("vaultEntryId", args.vaultEntryId!))
         .order("desc")
         .take(limit);
     }
-    return ctx.db.query("vaultAuditLog").order("desc").take(limit);
+    return await ctx.db.query("vaultAuditLog").order("desc").take(limit);
   },
 });
 
@@ -116,12 +135,13 @@ export const store = mutation({
     name: v.string(),
     category: v.string(),
     provider: v.optional(v.string()),
-    value: v.string(), // Raw secret value - will be encrypted before storage
+    value: v.string(),
     userId: v.optional(v.string()),
     expiresAt: v.optional(v.number()),
   },
   handler: async (ctx, args) => {
-    const { encrypted, iv } = encodeSecret(args.value, VAULT_ENCRYPTION_KEY);
+    const key = getEncryptionKey();
+    const { encrypted, iv } = encodeSecret(args.value, key);
     const masked = maskSecret(args.value);
     const now = Date.now();
 
@@ -134,14 +154,12 @@ export const store = mutation({
       maskedValue: masked,
       isActive: true,
       expiresAt: args.expiresAt,
-      lastAccessedAt: undefined,
       accessCount: 0,
       userId: args.userId,
       createdAt: now,
       updatedAt: now,
     });
 
-    // Audit log
     await ctx.db.insert("vaultAuditLog", {
       vaultEntryId: id,
       action: "created",
@@ -163,7 +181,8 @@ export const storeFromChat = mutation({
     userId: v.optional(v.string()),
   },
   handler: async (ctx, args) => {
-    const { encrypted, iv } = encodeSecret(args.value, VAULT_ENCRYPTION_KEY);
+    const key = getEncryptionKey();
+    const { encrypted, iv } = encodeSecret(args.value, key);
     const masked = maskSecret(args.value);
     const now = Date.now();
 
@@ -181,7 +200,6 @@ export const storeFromChat = mutation({
       updatedAt: now,
     });
 
-    // Audit log with auto_captured source
     await ctx.db.insert("vaultAuditLog", {
       vaultEntryId: id,
       action: "auto_captured",
@@ -207,14 +225,15 @@ export const update = mutation({
     const existing = await ctx.db.get(args.id);
     if (!existing) throw new Error("Vault entry not found");
 
-    const updates: any = { updatedAt: Date.now() };
+    const updates: Record<string, unknown> = { updatedAt: Date.now() };
 
     if (args.name !== undefined) updates.name = args.name;
     if (args.isActive !== undefined) updates.isActive = args.isActive;
     if (args.expiresAt !== undefined) updates.expiresAt = args.expiresAt;
 
     if (args.value) {
-      const { encrypted, iv } = encodeSecret(args.value, VAULT_ENCRYPTION_KEY);
+      const key = getEncryptionKey();
+      const { encrypted, iv } = encodeSecret(args.value, key);
       updates.encryptedValue = encrypted;
       updates.iv = iv;
       updates.maskedValue = maskSecret(args.value);
@@ -241,7 +260,6 @@ export const remove = mutation({
     const existing = await ctx.db.get(args.id);
     if (!existing) throw new Error("Vault entry not found");
 
-    // Log deletion before removing
     await ctx.db.insert("vaultAuditLog", {
       vaultEntryId: args.id,
       action: "deleted",
@@ -254,8 +272,8 @@ export const remove = mutation({
   },
 });
 
-// Retrieve decrypted value (for internal agent use only - never expose to frontend)
-export const retrieveSecret = mutation({
+// Internal-only: Retrieve decrypted value (only callable from other Convex functions)
+export const retrieveSecret = internalMutation({
   args: {
     id: v.id("vault"),
     userId: v.optional(v.string()),
@@ -265,13 +283,11 @@ export const retrieveSecret = mutation({
     if (!entry) throw new Error("Vault entry not found");
     if (!entry.isActive) throw new Error("Vault entry is disabled");
 
-    // Update access tracking
     await ctx.db.patch(args.id, {
       lastAccessedAt: Date.now(),
       accessCount: entry.accessCount + 1,
     });
 
-    // Audit log
     await ctx.db.insert("vaultAuditLog", {
       vaultEntryId: args.id,
       action: "accessed",
@@ -280,14 +296,13 @@ export const retrieveSecret = mutation({
       timestamp: Date.now(),
     });
 
-    // Decrypt and return
-    const decrypted = decodeSecret(entry.encryptedValue, entry.iv, VAULT_ENCRYPTION_KEY);
+    const key = getEncryptionKey();
+    const decrypted = decodeSecret(entry.encryptedValue, entry.iv, key);
     return decrypted;
   },
 });
 
 // ---- Secret Detection Utility ----
-// This is exported for use by the chat message handler
 
 export const detectSecrets = query({
   args: { text: v.string() },
@@ -329,7 +344,7 @@ export const censorMessage = mutation({
   },
   handler: async (ctx, args) => {
     let censoredText = args.text;
-    const storedSecrets: Array<{ name: string; masked: string; id: any }> = [];
+    const storedSecrets: Array<{ name: string; masked: string; id: unknown }> = [];
 
     for (const { pattern, category, provider, name } of SECRET_PATTERNS) {
       const regex = new RegExp(pattern, "g");
@@ -338,12 +353,11 @@ export const censorMessage = mutation({
         const secretValue = match[0];
         const masked = maskSecret(secretValue);
 
-        // Replace in censored text
         censoredText = censoredText.replace(secretValue, `[REDACTED: ${masked}]`);
 
-        // Auto-store if enabled
         if (args.autoStore !== false) {
-          const { encrypted, iv } = encodeSecret(secretValue, VAULT_ENCRYPTION_KEY);
+          const key = getEncryptionKey();
+          const { encrypted, iv } = encodeSecret(secretValue, key);
           const now = Date.now();
 
           const id = await ctx.db.insert("vault", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge-ai/cli",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "CLI tool for creating, running, and managing AgentForge projects",
   "type": "module",
   "bin": {

package/templates/default/convex/agents.ts

@@ -11,10 +11,10 @@ export const list = query({
     if (args.userId) {
       return await ctx.db
         .query("agents")
-        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
-        .take(100).collect();
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId!))
+        .collect();
     }
-    return await ctx.db.query("agents").take(100).collect();
+    return await ctx.db.query("agents").collect();
   },
 });
 
@@ -24,7 +24,7 @@ export const get = query({
   handler: async (ctx, args) => {
     return await ctx.db
       .query("agents")
-      .withIndex("byAgentId", (q) => q.eq("id", args.id))
+      .withIndex("byAgentId", (q) => q.eq("id", args.id!))
       .first();
   },
 });
@@ -35,11 +35,11 @@ export const listActive = query({
     userId: v.optional(v.string()),
   },
   handler: async (ctx, args) => {
-    let query = ctx.db
+    const activeQuery = ctx.db
       .query("agents")
       .withIndex("byIsActive", (q) => q.eq("isActive", true));
     
-    const agents = await query.take(100).collect();
+    const agents = await activeQuery.collect();
     
     if (args.userId) {
       return agents.filter((agent) => agent.userId === args.userId);
@@ -117,7 +117,7 @@ export const remove = mutation({
   handler: async (ctx, args) => {
     const agent = await ctx.db
       .query("agents")
-      .withIndex("byAgentId", (q) => q.eq("id", args.id))
+      .withIndex("byAgentId", (q) => q.eq("id", args.id!))
       .first();
 
     if (!agent) {
@@ -135,7 +135,7 @@ export const toggleActive = mutation({
   handler: async (ctx, args) => {
     const agent = await ctx.db
       .query("agents")
-      .withIndex("byAgentId", (q) => q.eq("id", args.id))
+      .withIndex("byAgentId", (q) => q.eq("id", args.id!))
       .first();
 
     if (!agent) {

package/templates/default/convex/apiKeys.ts

@@ -11,8 +11,8 @@ export const list = query({
     if (args.provider) {
       const keys = await ctx.db
         .query("apiKeys")
-        .withIndex("byProvider", (q) => q.eq("provider", args.provider))
-        .take(100).collect();
+        .withIndex("byProvider", (q) => q.eq("provider", args.provider!))
+        .collect();
       
       if (args.userId) {
         return keys.filter((k) => k.userId === args.userId);
@@ -23,11 +23,11 @@ export const list = query({
     if (args.userId) {
       return await ctx.db
         .query("apiKeys")
-        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
-        .take(100).collect();
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId!))
+        .collect();
     }
     
-    return await ctx.db.query("apiKeys").take(100).collect();
+    return await ctx.db.query("apiKeys").collect();
   },
 });
 
@@ -48,8 +48,8 @@ export const getActiveForProvider = query({
   handler: async (ctx, args) => {
     const keys = await ctx.db
       .query("apiKeys")
-      .withIndex("byProvider", (q) => q.eq("provider", args.provider))
-      .take(100).collect();
+      .withIndex("byProvider", (q) => q.eq("provider", args.provider!))
+      .collect();
     
     const activeKeys = keys.filter((k) => k.isActive);
     

package/templates/default/convex/cronJobs.ts

@@ -12,8 +12,8 @@ export const list = query({
     if (args.isEnabled !== undefined) {
       const jobs = await ctx.db
         .query("cronJobs")
-        .withIndex("byIsEnabled", (q) => q.eq("isEnabled", args.isEnabled))
-        .take(100).collect();
+        .withIndex("byIsEnabled", (q) => q.eq("isEnabled", args.isEnabled!))
+        .collect();
       
       if (args.userId) {
         return jobs.filter((j) => j.userId === args.userId);
@@ -27,18 +27,18 @@ export const list = query({
     if (args.agentId) {
       return await ctx.db
         .query("cronJobs")
-        .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
-        .take(100).collect();
+        .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId!))
+        .collect();
     }
     
     if (args.userId) {
       return await ctx.db
         .query("cronJobs")
-        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
-        .take(100).collect();
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId!))
+        .collect();
     }
     
-    return await ctx.db.query("cronJobs").take(100).collect();
+    return await ctx.db.query("cronJobs").collect();
   },
 });
 
@@ -58,7 +58,7 @@ export const getDueJobs = query({
     const jobs = await ctx.db
       .query("cronJobs")
       .withIndex("byNextRun")
-      .take(100).collect();
+      .collect();
     
     return jobs.filter((j) => j.isEnabled && j.nextRun && j.nextRun <= now);
   },
@@ -162,8 +162,8 @@ export const remove = mutation({
     // Delete all run history
     const runs = await ctx.db
       .query("cronJobRuns")
-      .withIndex("byCronJobId", (q) => q.eq("cronJobId", args.id))
-      .take(100).collect();
+      .withIndex("byCronJobId", (q) => q.eq("cronJobId", args.id!))
+      .collect();
     
     for (const run of runs) {
       await ctx.db.delete(run._id);
@@ -209,8 +209,8 @@ export const getRunHistory = query({
   handler: async (ctx, args) => {
     const runs = await ctx.db
       .query("cronJobRuns")
-      .withIndex("byCronJobId", (q) => q.eq("cronJobId", args.cronJobId))
-      .take(100).collect();
+      .withIndex("byCronJobId", (q) => q.eq("cronJobId", args.cronJobId!))
+      .collect();
     
     // Sort by startedAt descending
     runs.sort((a, b) => b.startedAt - a.startedAt);

package/templates/default/convex/files.ts

@@ -12,25 +12,25 @@ export const list = query({
     if (args.folderId) {
       return await ctx.db
         .query("files")
-        .withIndex("byFolderId", (q) => q.eq("folderId", args.folderId))
-        .take(100).collect();
+        .withIndex("byFolderId", (q) => q.eq("folderId", args.folderId!))
+        .collect();
     }
     
     if (args.projectId) {
       return await ctx.db
         .query("files")
-        .withIndex("byProjectId", (q) => q.eq("projectId", args.projectId))
-        .take(100).collect();
+        .withIndex("byProjectId", (q) => q.eq("projectId", args.projectId!))
+        .collect();
     }
     
     if (args.userId) {
       return await ctx.db
         .query("files")
-        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
-        .take(100).collect();
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId!))
+        .collect();
     }
     
-    return await ctx.db.query("files").take(100).collect();
+    return await ctx.db.query("files").collect();
   },
 });
 

package/templates/default/convex/folders.ts

@@ -12,25 +12,25 @@ export const list = query({
     if (args.projectId) {
       return await ctx.db
         .query("folders")
-        .withIndex("byProjectId", (q) => q.eq("projectId", args.projectId))
-        .take(100).collect();
+        .withIndex("byProjectId", (q) => q.eq("projectId", args.projectId!))
+        .collect();
     }
     
     if (args.parentId) {
       return await ctx.db
         .query("folders")
-        .withIndex("byParentId", (q) => q.eq("parentId", args.parentId))
-        .take(100).collect();
+        .withIndex("byParentId", (q) => q.eq("parentId", args.parentId!))
+        .collect();
     }
     
     if (args.userId) {
       return await ctx.db
         .query("folders")
-        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
-        .take(100).collect();
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId!))
+        .collect();
     }
     
-    return await ctx.db.query("folders").take(100).collect();
+    return await ctx.db.query("folders").collect();
   },
 });
 
@@ -85,8 +85,8 @@ export const remove = mutation({
     // Delete all files in the folder
     const files = await ctx.db
       .query("files")
-      .withIndex("byFolderId", (q) => q.eq("folderId", args.id))
-      .take(100).collect();
+      .withIndex("byFolderId", (q) => q.eq("folderId", args.id!))
+      .collect();
     
     for (const file of files) {
       await ctx.db.delete(file._id);
@@ -95,8 +95,8 @@ export const remove = mutation({
     // Delete all subfolders recursively
     const subfolders = await ctx.db
       .query("folders")
-      .withIndex("byParentId", (q) => q.eq("parentId", args.id))
-      .take(100).collect();
+      .withIndex("byParentId", (q) => q.eq("parentId", args.id!))
+      .collect();
     
     for (const subfolder of subfolders) {
       // Recursive delete (will be called via mutation)

package/templates/default/convex/heartbeat.ts

@@ -37,8 +37,8 @@ export const get = query({
   handler: async (ctx, args) => {
     const heartbeats = await ctx.db
       .query("heartbeats")
-      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
-      .take(100).collect();
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId!))
+      .collect();
     
     if (args.threadId) {
       return heartbeats.find((h) => h.threadId === args.threadId);
@@ -57,14 +57,14 @@ export const listActive = query({
     const heartbeats = await ctx.db
       .query("heartbeats")
       .withIndex("byStatus", (q) => q.eq("status", "active"))
-      .take(100).collect();
+      .collect();
     
     if (args.userId) {
       // Filter by userId if provided
       const userAgents = await ctx.db
         .query("agents")
-        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
-        .take(100).collect();
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId!))
+        .collect();
       
       const userAgentIds = new Set(userAgents.map((a) => a.id));
       return heartbeats.filter((h) => userAgentIds.has(h.agentId));
@@ -82,7 +82,7 @@ export const getDueForCheck = query({
     const heartbeats = await ctx.db
       .query("heartbeats")
       .withIndex("byNextCheck")
-      .take(100).collect();
+      .collect();
     
     return heartbeats.filter((h) => h.nextCheck <= now && h.status === "active");
   },
@@ -107,10 +107,10 @@ export const upsert = mutation({
     // Check if heartbeat exists
     const existing = await ctx.db
       .query("heartbeats")
-      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId!))
       .filter((q) =>
         args.threadId
-          ? q.eq(q.field("threadId"), args.threadId)
+          ? q.eq(q.field("threadId"), args.threadId!)
           : q.eq(q.field("threadId"), undefined)
       )
       .first();
@@ -146,10 +146,10 @@ export const updateStatus = mutation({
   handler: async (ctx, args) => {
     const heartbeat = await ctx.db
       .query("heartbeats")
-      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId!))
       .filter((q) =>
         args.threadId
-          ? q.eq(q.field("threadId"), args.threadId)
+          ? q.eq(q.field("threadId"), args.threadId!)
           : q.eq(q.field("threadId"), undefined)
       )
       .first();
@@ -178,10 +178,10 @@ export const addPendingTask = mutation({
   handler: async (ctx, args) => {
     const heartbeat = await ctx.db
       .query("heartbeats")
-      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId!))
       .filter((q) =>
         args.threadId
-          ? q.eq(q.field("threadId"), args.threadId)
+          ? q.eq(q.field("threadId"), args.threadId!)
           : q.eq(q.field("threadId"), undefined)
       )
       .first();
@@ -210,10 +210,10 @@ export const removePendingTask = mutation({
   handler: async (ctx, args) => {
     const heartbeat = await ctx.db
       .query("heartbeats")
-      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId!))
       .filter((q) =>
         args.threadId
-          ? q.eq(q.field("threadId"), args.threadId)
+          ? q.eq(q.field("threadId"), args.threadId!)
           : q.eq(q.field("threadId"), undefined)
       )
       .first();
@@ -242,10 +242,10 @@ export const updateContext = mutation({
   handler: async (ctx, args) => {
     const heartbeat = await ctx.db
       .query("heartbeats")
-      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId!))
       .filter((q) =>
         args.threadId
-          ? q.eq(q.field("threadId"), args.threadId)
+          ? q.eq(q.field("threadId"), args.threadId!)
           : q.eq(q.field("threadId"), undefined)
       )
       .first();
@@ -353,10 +353,10 @@ export const remove = mutation({
   handler: async (ctx, args) => {
     const heartbeat = await ctx.db
       .query("heartbeats")
-      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId!))
       .filter((q) =>
         args.threadId
-          ? q.eq(q.field("threadId"), args.threadId)
+          ? q.eq(q.field("threadId"), args.threadId!)
           : q.eq(q.field("threadId"), undefined)
       )
       .first();

package/templates/default/convex/mastraIntegration.ts

@@ -54,6 +54,7 @@ export const executeAgent = action({
 
     try {
       // Import Mastra dynamically (Node.js runtime)
+      // @ts-expect-error - Mastra is installed at runtime in the user's project
       const { Agent } = await import("@mastra/core/agent");
       
       // Format model string for Mastra
@@ -83,7 +84,7 @@ export const executeAgent = action({
         .join("\n");
 
       // Execute agent
-      const result = await mastraAgent.generate(args.prompt, {
+      const result: any = await mastraAgent.generate(args.prompt, {
         ...(args.stream && { stream: args.stream }),
         context: context || undefined,
       });

package/templates/default/convex/mcpConnections.ts

@@ -11,8 +11,8 @@ export const list = query({
     if (args.isEnabled !== undefined) {
       const connections = await ctx.db
         .query("mcpConnections")
-        .withIndex("byIsEnabled", (q) => q.eq("isEnabled", args.isEnabled))
-        .take(100).collect();
+        .withIndex("byIsEnabled", (q) => q.eq("isEnabled", args.isEnabled!))
+        .collect();
       
       if (args.userId) {
         return connections.filter((c) => c.userId === args.userId);
@@ -23,11 +23,11 @@ export const list = query({
     if (args.userId) {
       return await ctx.db
         .query("mcpConnections")
-        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
-        .take(100).collect();
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId!))
+        .collect();
     }
     
-    return await ctx.db.query("mcpConnections").take(100).collect();
+    return await ctx.db.query("mcpConnections").collect();
   },
 });
 

package/templates/default/convex/messages.ts

@@ -57,8 +57,8 @@ export const list = query({
   handler: async (ctx, args) => {
     const messages = await ctx.db
       .query("messages")
-      .withIndex("by_thread", (q) => q.eq("threadId", args.threadId))
-      .take(100).collect();
+      .withIndex("byThread", (q) => q.eq("threadId", args.threadId!))
+      .collect();
     return messages;
   },
 });
@@ -78,8 +78,8 @@ export const clearThread = mutation({
   handler: async (ctx, args) => {
     const messages = await ctx.db
       .query("messages")
-      .withIndex("by_thread", (q) => q.eq("threadId", args.threadId))
-      .take(100).collect();
+      .withIndex("byThread", (q) => q.eq("threadId", args.threadId!))
+      .collect();
     
     for (const message of messages) {
       await ctx.db.delete(message._id);