calabasas 0.3.6 → 0.5.0

package/dist/index.js

@@ -2236,7 +2236,8 @@ export default defineCalabasas({
 `;
 async function init() {
   const convexDir = path.resolve(process.cwd(), "convex");
-  const configPath = path.join(convexDir, "calabasas.config.ts");
+  const calabasasDir = path.join(convexDir, "calabasas");
+  const configPath = path.join(calabasasDir, "config.ts");
   p3.intro("calabasas init");
   if (!fs.existsSync(convexDir)) {
     p3.cancel(`convex/ directory not found.
@@ -2246,15 +2247,18 @@ Run \`npx convex dev\` to initialize a new Convex project.`);
     process.exit(1);
   }
   if (fs.existsSync(configPath)) {
-    p3.cancel(`convex/calabasas.config.ts already exists.
+    p3.cancel(`convex/calabasas/config.ts already exists.
 
 Delete the existing file if you want to start fresh:
-  rm convex/calabasas.config.ts`);
+  rm convex/calabasas/config.ts`);
     process.exit(1);
   }
+  if (!fs.existsSync(calabasasDir)) {
+    fs.mkdirSync(calabasasDir, { recursive: true });
+  }
   fs.writeFileSync(configPath, CONFIG_TEMPLATE);
-  p3.note("1. Edit convex/calabasas.config.ts to configure sync and events\n2. Run `calabasas generate` to generate type-safe handlers\n3. Run `calabasas push` to sync config with Calabasas", "Next steps");
-  p3.outro("Created convex/calabasas.config.ts");
+  p3.note("1. Edit convex/calabasas/config.ts to configure sync and events\n2. Run `calabasas generate` to generate type-safe handlers\n3. Run `calabasas push` to sync config with Calabasas", "Next steps");
+  p3.outro("Created convex/calabasas/config.ts");
 }
 
 // src/commands/push.ts
@@ -2321,7 +2325,7 @@ async function push(options) {
   const configPath = path3.resolve(process.cwd(), options.config);
   if (!fs3.existsSync(configPath)) {
     console.error(`Error: Config file not found: ${configPath}`);
-    console.error("\nRun `calabasas init` to create a calabasas.config.ts file.");
+    console.error("\nRun `calabasas init` to create a config file.");
     process.exit(1);
   }
   if (!isAuthenticated(env)) {
@@ -2840,7 +2844,7 @@ export const syncGuildAdmins = mutation({
     if (!expectedSecret || secret !== expectedSecret) {
       throw new Error("Invalid secret");
     }
-    await ctx.runMutation(internal.calabasas.sync._syncGuildAdmins, { data });
+    await ctx.runMutation(internal.calabasas._generated.sync._syncGuildAdmins, { data });
     return null;
   },
 });`;
@@ -2864,7 +2868,7 @@ export const sync${capitalType} = mutation({
     if (!expectedSecret || secret !== expectedSecret) {
       throw new Error("Invalid secret");
     }
-    await ctx.runMutation(internal.calabasas.sync._sync${capitalType}, { data, operation });
+    await ctx.runMutation(internal.calabasas._generated.sync._sync${capitalType}, { data, operation });
     return null;
   },
 });`;
@@ -2920,7 +2924,7 @@ function generateSyncFile(sync) {
  * updated, run \`calabasas generate\` to regenerate it from the config.
  * Editing this file directly will cause your changes to be overwritten.
  *
- * No sync handlers configured - enable sync options in calabasas.config.ts
+ * No sync handlers configured - enable sync options in convex/calabasas/config.ts
  */
 
 export {};
@@ -2936,8 +2940,8 @@ export {};
  * Editing this file directly will cause your changes to be overwritten.
  */
 
-import { mutation, internalMutation } from "../_generated/server";
-import { internal } from "../_generated/api";
+import { mutation, internalMutation } from "../../_generated/server";
+import { internal } from "../../_generated/api";
 import { v } from "convex/values";
 
 // ============================================================================
@@ -3273,9 +3277,9 @@ function generateHandlersCode(eventNames) {
  * Editing this file directly will cause your changes to be overwritten.
  */
 
-import { mutation } from "./_generated/server";
+import { mutation } from "../../_generated/server";
 import { v } from "convex/values";
-import type { MutationCtx } from "./_generated/server";
+import type { MutationCtx } from "../../_generated/server";
 
 // Event type validators
 ${eventNames.map((name) => `const ${name}Validator = ${generateValidatorForEvent(name)};`).join(`
@@ -3496,17 +3500,27 @@ export const discord = {
 }
 async function generate(options) {
   const convexDir = path4.resolve(process.cwd(), "convex");
-  const configPath = path4.join(convexDir, "calabasas.config.ts");
+  const calabasasDir = path4.join(convexDir, "calabasas");
+  const configPath = path4.join(calabasasDir, "config.ts");
+  const legacyConfigPath = path4.join(convexDir, "calabasas.config.ts");
   p5.intro("calabasas generate");
   let config = { sync: {}, events: {} };
   if (fs4.existsSync(configPath)) {
     config = await parseConfigFile(configPath);
+  } else if (fs4.existsSync(legacyConfigPath)) {
+    p5.log.warn("Found config at legacy path convex/calabasas.config.ts");
+    p5.log.info("Run `calabasas migrate dedicated-folder` to move files to the new layout.");
+    config = await parseConfigFile(legacyConfigPath);
   } else {
-    p5.log.warn("No calabasas.config.ts found, generating with default settings...");
+    p5.log.warn("No config found, generating with default settings...");
     p5.log.info("Run `calabasas init` to create a config file.");
   }
   const s = p5.spinner();
   s.start("Generating files...");
+  const generatedDir = path4.join(calabasasDir, "_generated");
+  if (!fs4.existsSync(generatedDir)) {
+    fs4.mkdirSync(generatedDir, { recursive: true });
+  }
   const eventHandlersPath = path4.resolve(process.cwd(), options.output);
   const eventHandlersCode = generateEventHandlersFile(config.events ?? {});
   fs4.writeFileSync(eventHandlersPath, eventHandlersCode);
@@ -3514,23 +3528,19 @@ async function generate(options) {
   const syncConfig = config.sync ?? {};
   const hasSyncEnabled = syncConfig.guilds || syncConfig.channels || syncConfig.roles || syncConfig.members;
   if (hasSyncEnabled) {
-    const calabasasDir = path4.join(convexDir, "calabasas");
-    if (!fs4.existsSync(calabasasDir)) {
-      fs4.mkdirSync(calabasasDir, { recursive: true });
-    }
-    const schemaPath = path4.join(calabasasDir, "schema.ts");
+    const schemaPath = path4.join(generatedDir, "schema.ts");
     const schemaCode = generateSchemaFile(syncConfig);
     fs4.writeFileSync(schemaPath, schemaCode);
-    generated.push("convex/calabasas/schema.ts");
-    const syncPath = path4.join(calabasasDir, "sync.ts");
+    generated.push("convex/calabasas/_generated/schema.ts");
+    const syncPath = path4.join(generatedDir, "sync.ts");
     const syncCode = generateSyncFile(syncConfig);
     fs4.writeFileSync(syncPath, syncCode);
-    generated.push("convex/calabasas/sync.ts");
+    generated.push("convex/calabasas/_generated/sync.ts");
   }
-  const actionsPath = path4.join(convexDir, "discord.actions.generated.ts");
+  const actionsPath = path4.join(generatedDir, "discord.actions.ts");
   const actionsCode = generateActionsFile();
   fs4.writeFileSync(actionsPath, actionsCode);
-  generated.push("convex/discord.actions.generated.ts");
+  generated.push("convex/calabasas/_generated/discord.actions.ts");
   s.stop(`Generated ${generated.length} file${generated.length > 1 ? "s" : ""}`);
   p5.note(generated.join(`
 `), "Generated files");
@@ -3547,14 +3557,14 @@ async function generate(options) {
     if (syncConfig.members)
       syncExports.push("syncMember");
     p5.note(`1. Add tables to your convex/schema.ts:
-   import { calabasasTables } from "./calabasas/schema";
+   import { calabasasTables } from "./calabasas/_generated/schema";
 
    export default defineSchema({
      ...calabasasTables,
    });
 
 2. Re-export sync mutations in convex/discord.ts:
-   export { ${syncExports.join(", ")} } from "./calabasas/sync";
+   export { ${syncExports.join(", ")} } from "./calabasas/_generated/sync";
 
 3. Add CALABASAS_SECRET to your Convex environment variables
 4. Create your event handler in convex/discord.ts
@@ -3563,7 +3573,7 @@ async function generate(options) {
     p5.note(`1. Add CALABASAS_SECRET to your Convex environment variables
 2. Create your handler in convex/discord.ts:
 
-   import { handleDiscordEvent } from "./discord.generated";
+   import { handleDiscordEvent } from "./calabasas/_generated/discord";
 
    export const receive = handleDiscordEvent({
      messageCreate: async (ctx, event) => {
@@ -5702,9 +5712,10 @@ async function add(componentNames) {
   const cwd = process.cwd();
   const convexDir = path6.resolve(cwd, "convex");
   const calabasasDir = path6.join(convexDir, "calabasas");
-  const configPath = path6.join(convexDir, "calabasas.config.ts");
-  if (!fs6.existsSync(calabasasDir) || !fs6.existsSync(path6.join(calabasasDir, "schema.ts"))) {
-    console.log("Error: convex/calabasas/schema.ts not found.");
+  const configPath = path6.join(calabasasDir, "config.ts");
+  const generatedDir = path6.join(calabasasDir, "_generated");
+  if (!fs6.existsSync(generatedDir) || !fs6.existsSync(path6.join(generatedDir, "schema.ts"))) {
+    console.log("Error: convex/calabasas/_generated/schema.ts not found.");
     console.log("");
     console.log("Run `calabasas init` and `calabasas generate` first to enable sync.");
     return;
@@ -5755,7 +5766,7 @@ async function add(componentNames) {
     const missingSyncTypes = comp.requiredSyncTypes.filter((t) => !enabledSync.has(t));
     if (missingSyncTypes.length > 0) {
       p7.log.warn(`Skipped ${comp.name} — requires sync types not enabled: ${missingSyncTypes.join(", ")}`);
-      p7.log.info(`Enable them in calabasas.config.ts and re-run \`calabasas generate\`.`);
+      p7.log.info(`Enable them in convex/calabasas/config.ts and re-run \`calabasas generate\`.`);
       continue;
     }
     if (!fs6.existsSync(componentsDir)) {
@@ -5858,8 +5869,195 @@ ${props}
   }
 }
 
-// src/commands/bot.ts
+// src/commands/migrate.ts
+import * as p9 from "@clack/prompts";
+
+// src/migrations/dedicated-folder.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
 import * as p8 from "@clack/prompts";
+var FILE_MOVES = [
+  ["convex/calabasas.config.ts", "convex/calabasas/config.ts"],
+  ["convex/discord.generated.ts", "convex/calabasas/_generated/discord.ts"],
+  [
+    "convex/discord.actions.generated.ts",
+    "convex/calabasas/_generated/discord.actions.ts"
+  ],
+  ["convex/calabasas/schema.ts", "convex/calabasas/_generated/schema.ts"],
+  ["convex/calabasas/sync.ts", "convex/calabasas/_generated/sync.ts"]
+];
+var IMPORT_REWRITES = [
+  [
+    /from\s+["']\.\/discord\.generated["']/g,
+    `from "./calabasas/_generated/discord"`
+  ],
+  [
+    /from\s+["']\.\/discord\.actions\.generated["']/g,
+    `from "./calabasas/_generated/discord.actions"`
+  ],
+  [
+    /from\s+["']\.\/calabasas\/schema["']/g,
+    `from "./calabasas/_generated/schema"`
+  ],
+  [
+    /from\s+["']\.\/calabasas\/sync["']/g,
+    `from "./calabasas/_generated/sync"`
+  ]
+];
+var GENERATED_IMPORT_REWRITES = {
+  "convex/calabasas/_generated/discord.ts": [
+    [
+      /from\s+["']\.\/(_generated\/server)["']/g,
+      `from "../../_generated/server"`
+    ],
+    [
+      /from\s+["']\.\/(_generated\/api)["']/g,
+      `from "../../_generated/api"`
+    ]
+  ],
+  "convex/calabasas/_generated/sync.ts": [
+    [
+      /from\s+["']\.\.\/(_generated\/server)["']/g,
+      `from "../../_generated/server"`
+    ],
+    [
+      /from\s+["']\.\.\/(_generated\/api)["']/g,
+      `from "../../_generated/api"`
+    ]
+  ]
+};
+function isUserFile(filePath) {
+  const rel = path7.relative(path7.resolve(process.cwd(), "convex"), filePath);
+  if (rel.startsWith("_generated"))
+    return false;
+  if (rel.includes("_generated"))
+    return false;
+  return /\.tsx?$/.test(filePath);
+}
+var dedicatedFolder = {
+  name: "dedicated-folder",
+  description: "Move all Calabasas files under convex/calabasas/ with _generated/ subdirectory",
+  async run() {
+    const cwd = process.cwd();
+    const convexDir = path7.resolve(cwd, "convex");
+    if (!fs7.existsSync(convexDir)) {
+      p8.log.error("convex/ directory not found.");
+      return;
+    }
+    const generatedDir = path7.join(convexDir, "calabasas", "_generated");
+    if (!fs7.existsSync(generatedDir)) {
+      fs7.mkdirSync(generatedDir, { recursive: true });
+    }
+    let movedCount = 0;
+    for (const [oldRel, newRel] of FILE_MOVES) {
+      const oldPath = path7.join(cwd, oldRel);
+      const newPath = path7.join(cwd, newRel);
+      if (!fs7.existsSync(oldPath))
+        continue;
+      if (fs7.existsSync(newPath)) {
+        p8.log.warn(`Skipped ${oldRel} → ${newRel} (target already exists)`);
+        continue;
+      }
+      fs7.renameSync(oldPath, newPath);
+      p8.log.success(`Moved ${oldRel} → ${newRel}`);
+      movedCount++;
+    }
+    let fixedGeneratedCount = 0;
+    for (const [relPath, rewrites] of Object.entries(GENERATED_IMPORT_REWRITES)) {
+      const absPath = path7.join(cwd, relPath);
+      if (!fs7.existsSync(absPath))
+        continue;
+      let content = fs7.readFileSync(absPath, "utf-8");
+      let changed = false;
+      for (const [pattern, replacement] of rewrites) {
+        const updated = content.replace(pattern, replacement);
+        if (updated !== content) {
+          content = updated;
+          changed = true;
+        }
+      }
+      if (changed) {
+        fs7.writeFileSync(absPath, content);
+        fixedGeneratedCount++;
+        p8.log.success(`Fixed imports in ${relPath}`);
+      }
+    }
+    let rewrittenCount = 0;
+    const userFiles = collectTsFiles(convexDir).filter(isUserFile);
+    for (const filePath of userFiles) {
+      let content = fs7.readFileSync(filePath, "utf-8");
+      let changed = false;
+      for (const [pattern, replacement] of IMPORT_REWRITES) {
+        const updated = content.replace(pattern, replacement);
+        if (updated !== content) {
+          content = updated;
+          changed = true;
+        }
+      }
+      if (changed) {
+        fs7.writeFileSync(filePath, content);
+        const rel = path7.relative(cwd, filePath);
+        p8.log.success(`Rewrote imports in ${rel}`);
+        rewrittenCount++;
+      }
+    }
+    if (movedCount === 0 && rewrittenCount === 0 && fixedGeneratedCount === 0) {
+      p8.log.info("Already up to date.");
+      return;
+    }
+    p8.log.info(`
+Moved ${movedCount} file${movedCount !== 1 ? "s" : ""}, ` + `fixed imports in ${fixedGeneratedCount + rewrittenCount} file${fixedGeneratedCount + rewrittenCount !== 1 ? "s" : ""}.`);
+  }
+};
+function collectTsFiles(dir) {
+  const results = [];
+  const entries = fs7.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path7.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectTsFiles(fullPath));
+    } else if (/\.tsx?$/.test(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+// src/migrations/index.ts
+var migrations = [dedicatedFolder];
+
+// src/commands/migrate.ts
+async function migrate(name) {
+  if (!name) {
+    p9.intro("calabasas migrate");
+    if (migrations.length === 0) {
+      p9.log.info("No migrations available.");
+      p9.outro("Done");
+      return;
+    }
+    p9.log.info(`Available migrations:
+`);
+    for (const m of migrations) {
+      p9.log.message(`  ${m.name}  —  ${m.description}`);
+    }
+    p9.log.info(`
+Run a migration with: calabasas migrate <name>`);
+    p9.outro("Done");
+    return;
+  }
+  const migration = migrations.find((m) => m.name === name);
+  if (!migration) {
+    p9.log.error(`Unknown migration: ${name}`);
+    p9.log.info(`Available migrations: ${migrations.map((m) => m.name).join(", ")}`);
+    return;
+  }
+  p9.intro(`calabasas migrate ${name}`);
+  await migration.run();
+  p9.outro("Migration complete!");
+}
+
+// src/commands/bot.ts
+import * as p10 from "@clack/prompts";
 import pc from "picocolors";
 var INTENTS = [
   { name: "Guilds", value: 1 << 0, description: "Guild create/update/delete, roles, channels" },
@@ -5882,26 +6080,9 @@ var INTENTS = [
   { name: "Auto Moderation Config", value: 1 << 20, description: "Auto mod rule changes" },
   { name: "Auto Moderation Execution", value: 1 << 21, description: "Auto mod action execution" }
 ];
-function encrypt(text2, key) {
-  const keyBytes = new TextEncoder().encode(key);
-  const textBytes = new TextEncoder().encode(text2);
-  const encrypted = new Uint8Array(textBytes.length);
-  for (let i = 0;i < textBytes.length; i++) {
-    encrypted[i] = textBytes[i] ^ keyBytes[i % keyBytes.length];
-  }
-  return btoa(String.fromCharCode(...encrypted));
-}
-function generateSecret() {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0;i < 32; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
-}
-async function apiRequest(method, path7, body, env) {
+async function apiRequest(method, path8, body, env) {
   const config = getConfig(env);
-  const url = `${getApiUrlForEnv(env)}${path7}`;
+  const url = `${getApiUrlForEnv(env)}${path8}`;
   const response = await fetch(url, {
     method,
     headers: {
@@ -5927,43 +6108,43 @@ async function botAdd(options) {
     console.log("Not logged in. Run `calabasas login` first.");
     return;
   }
-  p8.intro("calabasas bot add");
-  const name = await p8.text({
+  p10.intro("calabasas bot add");
+  const name = await p10.text({
     message: "Bot name",
     placeholder: "My Discord Bot",
     validate: (v) => v.trim() ? undefined : "Bot name is required"
   });
-  if (p8.isCancel(name)) {
-    p8.cancel("Cancelled.");
+  if (p10.isCancel(name)) {
+    p10.cancel("Cancelled.");
     return;
   }
-  const discordAppId = await p8.text({
+  const discordAppId = await p10.text({
     message: "Discord Application ID",
     placeholder: "123456789012345678",
     validate: (v) => v.trim() ? undefined : "Discord Application ID is required"
   });
-  if (p8.isCancel(discordAppId)) {
-    p8.cancel("Cancelled.");
+  if (p10.isCancel(discordAppId)) {
+    p10.cancel("Cancelled.");
     return;
   }
-  const token = await p8.password({
+  const token = await p10.password({
     message: "Bot token",
     validate: (v) => v.trim() ? undefined : "Bot token is required"
   });
-  if (p8.isCancel(token)) {
-    p8.cancel("Cancelled.");
+  if (p10.isCancel(token)) {
+    p10.cancel("Cancelled.");
     return;
   }
-  const convexUrl = await p8.text({
+  const convexUrl = await p10.text({
     message: "Your Convex URL",
     placeholder: "https://your-project.convex.cloud",
     validate: (v) => v.trim() ? undefined : "Convex URL is required"
   });
-  if (p8.isCancel(convexUrl)) {
-    p8.cancel("Cancelled.");
+  if (p10.isCancel(convexUrl)) {
+    p10.cancel("Cancelled.");
     return;
   }
-  const selectedIntents = await p8.multiselect({
+  const selectedIntents = await p10.multiselect({
     message: "Select Gateway Intents",
     options: INTENTS.map((intent, i) => ({
       value: i,
@@ -5973,35 +6154,32 @@ async function botAdd(options) {
     initialValues: [0, 9],
     required: true
   });
-  if (p8.isCancel(selectedIntents)) {
-    p8.cancel("Cancelled.");
+  if (p10.isCancel(selectedIntents)) {
+    p10.cancel("Cancelled.");
     return;
   }
   const intents = selectedIntents.reduce((sum, i) => sum + INTENTS[i].value, 0);
-  const s = p8.spinner();
+  const s = p10.spinner();
   s.start("Creating bot...");
-  const encryptionKey = "calabasas-dev-key-change-in-production";
-  const encryptedToken = encrypt(token, encryptionKey);
-  const sharedSecret = generateSecret();
   const { ok, data, status } = await apiRequest("POST", "/api/cli/bots", {
     name: name.trim(),
     discordAppId: discordAppId.trim(),
-    encryptedToken,
+    token,
     intents,
-    convexUrl: convexUrl.trim(),
-    sharedSecret
+    convexUrl: convexUrl.trim()
   }, env);
   if (!ok) {
     s.stop("Failed to create bot");
-    p8.cancel(`${data.error || `HTTP ${status}`}`);
+    p10.cancel(`${data.error || `HTTP ${status}`}`);
     return;
   }
   s.stop("Bot created!");
-  p8.note(`${sharedSecret}
+  const sharedSecret = data.sharedSecret;
+  p10.note(`${sharedSecret}
 
 Add this to your Convex environment as CALABASAS_SECRET`, "Shared Secret");
-  p8.note("1. Run `calabasas generate` to generate the event handler\n2. Create your handler in convex/discord.ts\n3. Add CALABASAS_SECRET to your Convex environment variables", "Next steps");
-  p8.outro("Bot created successfully!");
+  p10.note("1. Run `calabasas generate` to generate the event handler\n2. Create your handler in convex/discord.ts\n3. Add CALABASAS_SECRET to your Convex environment variables", "Next steps");
+  p10.outro("Bot created successfully!");
 }
 async function botList(options) {
   if (options.dev && options.prod) {
@@ -6072,24 +6250,24 @@ async function botRemove(botId, options) {
     console.log("Not logged in. Run `calabasas login` first.");
     return;
   }
-  p8.intro("calabasas bot remove");
-  const confirmed = await p8.confirm({
+  p10.intro("calabasas bot remove");
+  const confirmed = await p10.confirm({
     message: `Are you sure you want to remove bot ${botId}?`
   });
-  if (p8.isCancel(confirmed) || !confirmed) {
-    p8.cancel("Cancelled.");
+  if (p10.isCancel(confirmed) || !confirmed) {
+    p10.cancel("Cancelled.");
     return;
   }
-  const s = p8.spinner();
+  const s = p10.spinner();
   s.start("Removing bot...");
   const { ok, data, status } = await apiRequest("DELETE", `/api/cli/bots?id=${botId}`, undefined, env);
   if (!ok) {
     s.stop("Failed to remove bot");
-    p8.cancel(`${data.error || `HTTP ${status}`}`);
+    p10.cancel(`${data.error || `HTTP ${status}`}`);
     return;
   }
   s.stop("Done");
-  p8.outro("Bot removed successfully!");
+  p10.outro("Bot removed successfully!");
 }
 async function botEdit(botId, options) {
   if (options.dev && options.prod) {
@@ -6108,8 +6286,8 @@ async function botEdit(botId, options) {
   const updates = { botId };
   const hasFlags = options.name || options.url || options.token || options.intents;
   if (!hasFlags) {
-    p8.intro("calabasas bot edit");
-    const field = await p8.select({
+    p10.intro("calabasas bot edit");
+    const field = await p10.select({
       message: "Which field do you want to edit?",
       options: [
         { value: "name", label: "Bot name" },
@@ -6118,36 +6296,35 @@ async function botEdit(botId, options) {
         { value: "intents", label: "Intents value" }
       ]
     });
-    if (p8.isCancel(field)) {
-      p8.cancel("Cancelled.");
+    if (p10.isCancel(field)) {
+      p10.cancel("Cancelled.");
       return;
     }
     if (field === "name") {
-      const value = await p8.text({ message: "New bot name" });
-      if (p8.isCancel(value)) {
-        p8.cancel("Cancelled.");
+      const value = await p10.text({ message: "New bot name" });
+      if (p10.isCancel(value)) {
+        p10.cancel("Cancelled.");
         return;
       }
       updates.name = value;
     } else if (field === "url") {
-      const value = await p8.text({ message: "New Convex URL" });
-      if (p8.isCancel(value)) {
-        p8.cancel("Cancelled.");
+      const value = await p10.text({ message: "New Convex URL" });
+      if (p10.isCancel(value)) {
+        p10.cancel("Cancelled.");
         return;
       }
       updates.convexUrl = value;
     } else if (field === "token") {
-      const value = await p8.password({ message: "New bot token" });
-      if (p8.isCancel(value)) {
-        p8.cancel("Cancelled.");
+      const value = await p10.password({ message: "New bot token" });
+      if (p10.isCancel(value)) {
+        p10.cancel("Cancelled.");
         return;
       }
-      const encryptionKey = "calabasas-dev-key-change-in-production";
-      updates.encryptedToken = encrypt(value, encryptionKey);
+      updates.token = value;
     } else if (field === "intents") {
-      const value = await p8.text({ message: "New intents value (number)" });
-      if (p8.isCancel(value)) {
-        p8.cancel("Cancelled.");
+      const value = await p10.text({ message: "New intents value (number)" });
+      if (p10.isCancel(value)) {
+        p10.cancel("Cancelled.");
         return;
       }
       updates.intents = parseInt(value, 10);
@@ -6158,8 +6335,7 @@ async function botEdit(botId, options) {
     if (options.url)
       updates.convexUrl = options.url;
     if (options.token) {
-      const encryptionKey = "calabasas-dev-key-change-in-production";
-      updates.encryptedToken = encrypt(options.token, encryptionKey);
+      updates.token = options.token;
     }
     if (options.intents)
       updates.intents = parseInt(options.intents, 10);
@@ -6168,17 +6344,17 @@ async function botEdit(botId, options) {
     console.log("No updates specified.");
     return;
   }
-  const s = p8.spinner();
+  const s = p10.spinner();
   s.start("Updating bot...");
   const { ok, data, status } = await apiRequest("PATCH", "/api/cli/bots", updates, env);
   if (!ok) {
     s.stop("Failed to update bot");
-    p8.cancel(`${data.error || `HTTP ${status}`}`);
+    p10.cancel(`${data.error || `HTTP ${status}`}`);
     return;
   }
   s.stop("Done");
-  p8.note("The Gateway will automatically reconnect with the new settings.", "Note");
-  p8.outro("Bot updated successfully!");
+  p10.note("The Gateway will automatically reconnect with the new settings.", "Note");
+  p10.outro("Bot updated successfully!");
 }
 
 // src/index.ts
@@ -6195,10 +6371,11 @@ program2.name("calabasas").description("CLI for Calabasas - Discord Gateway as a
 program2.command("login").description("Authenticate with Calabasas using your API key").option("--dev", "Use development environment").option("--prod", "Use production environment").action(login);
 program2.command("logout").description("Clear stored credentials").option("--dev", "Use development environment").option("--prod", "Use production environment").action(logout);
 program2.command("init").description("Initialize Calabasas config in your Convex project").action(init);
-program2.command("push").description("Push your calabasas.config.ts to Calabasas").option("-c, --config <path>", "Path to config file", "convex/calabasas.config.ts").option("-b, --bot <botId>", "Bot ID to configure (prompts if not specified)").option("--dev", "Push to development environment").option("--prod", "Push to production environment").action(push);
-program2.command("generate").description("Generate discord.generated.ts with type-safe handlers").option("-o, --output <path>", "Output path", "convex/discord.generated.ts").action(generate);
+program2.command("push").description("Push your Calabasas config to the server").option("-c, --config <path>", "Path to config file", "convex/calabasas/config.ts").option("-b, --bot <botId>", "Bot ID to configure (prompts if not specified)").option("--dev", "Push to development environment").option("--prod", "Push to production environment").action(push);
+program2.command("generate").description("Generate type-safe Discord handlers and helpers").option("-o, --output <path>", "Output path", "convex/calabasas/_generated/discord.ts").action(generate);
 program2.command("skill").description("Generate Calabasas documentation for AI assistants").option("--dev", "Use development environment").option("--prod", "Use production environment").action(skill);
 program2.command("add [components...]").description("Add Discord UI components to your project").action(add);
+program2.command("migrate [name]").description("Run a codemod migration (list available if no name given)").action(migrate);
 program2.command("status").alias("dashboard").description("Real-time dashboard showing bot status, events, and stats").option("--dev", "Use development environment").option("--prod", "Use production environment").action(dashboard);
 program2.command("logs [botId]").description("Live event log viewer for a bot").option("-n, --limit <number>", "Number of log entries to show", "50").option("--dev", "Use development environment").option("--prod", "Use production environment").action(logs);
 var bot = program2.command("bot").description("Manage Discord bots");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "calabasas",
-  "version": "0.3.6",
+  "version": "0.5.0",
   "description": "CLI for Calabasas - Discord Gateway as a Service for Convex",
   "type": "module",
   "bin": {