calabasas 0.10.1 → 0.12.0

package/dist/config.d.ts

@@ -9,9 +9,21 @@ export type SyncConfig = {
   presence?: boolean;
 };
 
-export type EventConfig = {
-  [eventType: string]: true;
-};
+export type DiscordEventName =
+  | "messageCreate"
+  | "messageUpdate"
+  | "messageDelete"
+  | "guildMemberAdd"
+  | "guildMemberRemove"
+  | "guildMemberUpdate"
+  | "interactionCreate"
+  | "voiceStateUpdate"
+  | "presenceUpdate"
+  | "typingStart"
+  | "messageReactionAdd"
+  | "messageReactionRemove";
+
+export type EventConfig = { [K in DiscordEventName]?: true };
 
 export type CommandOptionType = "string" | "integer" | "number" | "boolean" | "user" | "channel" | "role" | "mentionable" | "attachment";
 

package/dist/dashboard-r2cptf7m.js

@@ -0,0 +1,236 @@
+import {
+  LogViewer
+} from "./index-f8td7thj.js";
+import {
+  getConfig,
+  getConvexUrl,
+  isAuthenticated,
+  resolveEnv
+} from "./index-qnd4rw0e.js";
+import {
+  build_default,
+  formatLatency,
+  formatNumber
+} from "./index-8gymgyxd.js";
+import"./index-tre7d3f1.js";
+import {
+  __toESM
+} from "./index-sdksp5px.js";
+import {
+  BotList
+} from "./BotList-jqxxq32e.js";
+import {
+  Box_default,
+  Text,
+  render_default,
+  use_app_default,
+  use_input_default
+} from "./index-4rn9k8et.js";
+import {
+  ConvexProvider,
+  cliApi,
+  createConvexClient,
+  require_jsx_dev_runtime,
+  useQuery
+} from "./convex-1z1jsz1n.js";
+import {
+  require_react
+} from "./index-vmy4gfe1.js";
+
+// src/components/Dashboard.tsx
+var import_react2 = __toESM(require_react(), 1);
+
+// src/components/Header.tsx
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function Header({
+  botCount,
+  env
+}) {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
+    marginBottom: 1,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        bold: true,
+        color: "magenta",
+        children: "calabasas"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        dimColor: true,
+        children: " v0.1.12"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        dimColor: true,
+        children: " · "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        children: [
+          botCount,
+          " bot",
+          botCount !== 1 ? "s" : ""
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        dimColor: true,
+        children: " · "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        color: env === "dev" ? "yellow" : "green",
+        children: env
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        dimColor: true,
+        children: " · Press "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        bold: true,
+        children: "q"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        dimColor: true,
+        children: " to quit"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/StatsPanel.tsx
+var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
+var ONE_HOUR = 60 * 60 * 1000;
+function StatsPanel({
+  apiKey,
+  botId
+}) {
+  const stats = useQuery(cliApi.botStats, {
+    apiKey,
+    botId,
+    since: Date.now() - ONE_HOUR
+  });
+  if (stats === undefined) {
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          color: "cyan",
+          children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(build_default, {
+            type: "dots"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          children: " Loading stats..."
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+    gap: 2,
+    marginBottom: 1,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        dimColor: true,
+        children: "Events (1h):"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        bold: true,
+        children: formatNumber(stats.total)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        color: "green",
+        children: [
+          formatNumber(stats.success),
+          " ok"
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        color: "red",
+        children: [
+          formatNumber(stats.failed),
+          " failed"
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        dimColor: true,
+        children: [
+          "avg ",
+          formatLatency(stats.avgLatencyMs)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/Dashboard.tsx
+var jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
+function Dashboard({
+  apiKey,
+  env
+}) {
+  const { exit } = use_app_default();
+  const [selectedIndex, setSelectedIndex] = import_react2.useState(0);
+  const bots = useQuery(cliApi.listBots, { apiKey });
+  const botCount = bots?.length ?? 0;
+  const selectedBot = bots?.[selectedIndex];
+  use_input_default(import_react2.useCallback((input, key) => {
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if ((input === "j" || key.downArrow) && botCount > 0) {
+      setSelectedIndex((i) => Math.min(i, botCount - 1) === botCount - 1 ? 0 : i + 1);
+    }
+    if ((input === "k" || key.upArrow) && botCount > 0) {
+      setSelectedIndex((i) => i === 0 ? botCount - 1 : i - 1);
+    }
+  }, [botCount, exit]));
+  return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Header, {
+        botCount,
+        env
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(BotList, {
+        apiKey,
+        selectedIndex
+      }, undefined, false, undefined, this),
+      selectedBot && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+        flexDirection: "column",
+        marginTop: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(StatsPanel, {
+            apiKey,
+            botId: selectedBot._id
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(LogViewer, {
+            apiKey,
+            botId: selectedBot._id
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/commands/dashboard.tsx
+var jsx_dev_runtime4 = __toESM(require_jsx_dev_runtime(), 1);
+async function dashboard(options) {
+  const env = resolveEnv(options);
+  if (!isAuthenticated(env)) {
+    console.log("Not logged in. Run `calabasas login` first.");
+    return;
+  }
+  const config = getConfig(env);
+  const apiKey = config.apiKey;
+  const convexUrl = getConvexUrl(env);
+  const client = createConvexClient(convexUrl);
+  const { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime4.jsxDEV(ConvexProvider, {
+    client,
+    children: /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Dashboard, {
+      apiKey,
+      env
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this));
+  await waitUntilExit();
+  await client.close();
+}
+export {
+  dashboard
+};

package/dist/index-qnd4rw0e.js

@@ -0,0 +1,191 @@
+import {
+  __require,
+  __toESM
+} from "./index-sdksp5px.js";
+
+// src/lib/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".calabasas");
+function getConfigFile(env) {
+  if (env === "dev")
+    return path.join(CONFIG_DIR, "config.dev.json");
+  return path.join(CONFIG_DIR, "config.json");
+}
+var PROD_API_URL = "https://sensible-starfish-338.convex.site";
+var DEV_API_URL = "https://diligent-swordfish-752.convex.site";
+var PROD_CONVEX_URL = "https://sensible-starfish-338.convex.cloud";
+var DEV_CONVEX_URL = "https://diligent-swordfish-752.convex.cloud";
+var PROD_WEB_URL = "https://calabasas-web.vercel.app";
+var DEV_WEB_URL = "http://localhost:3000";
+function getConfig(env) {
+  try {
+    const configFile = getConfigFile(env);
+    if (!fs.existsSync(configFile)) {
+      return {};
+    }
+    const content = fs.readFileSync(configFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config, env) {
+  const existing = getConfig(env);
+  const merged = { ...existing, ...config };
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(getConfigFile(env), JSON.stringify(merged, null, 2));
+}
+function clearConfig(env) {
+  const configFile = getConfigFile(env);
+  if (fs.existsSync(configFile)) {
+    fs.unlinkSync(configFile);
+  }
+}
+function isAuthenticated(env) {
+  const config = getConfig(env);
+  return !!config.apiKey;
+}
+function getApiUrl(env) {
+  const config = getConfig(env);
+  return config.apiUrl || PROD_API_URL;
+}
+function getApiUrlForEnv(env) {
+  if (env === "dev")
+    return DEV_API_URL;
+  if (env === "prod")
+    return PROD_API_URL;
+  return getApiUrl();
+}
+function getWebUrlForEnv(env) {
+  if (env === "dev")
+    return DEV_WEB_URL;
+  return PROD_WEB_URL;
+}
+function getConvexUrl(env) {
+  if (env === "dev")
+    return DEV_CONVEX_URL;
+  return PROD_CONVEX_URL;
+}
+function parseEnvLocal() {
+  const envPath = path.join(process.cwd(), ".env.local");
+  if (!fs.existsSync(envPath))
+    return {};
+  const content = fs.readFileSync(envPath, "utf-8");
+  const result = {};
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1)
+      continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function resolveEnv(options) {
+  if (options.dev && options.prod) {
+    console.error("Error: Cannot use both --dev and --prod flags.");
+    process.exit(1);
+  }
+  if (options.dev)
+    return "dev";
+  if (options.prod)
+    return "prod";
+  const envLocal = parseEnvLocal();
+  const calabasasEnv = envLocal["CALABASAS_ENV"];
+  if (calabasasEnv === "dev" || calabasasEnv === "prod") {
+    return calabasasEnv;
+  }
+  if (calabasasEnv) {
+    console.error(`Error: CALABASAS_ENV in .env.local must be "dev" or "prod", got "${calabasasEnv}".`);
+    process.exit(1);
+  }
+  console.error("Error: Specify --dev or --prod, or set CALABASAS_ENV in .env.local");
+  process.exit(1);
+}
+async function resolveBot(options, apiKey, apiUrl, env) {
+  if (options.bot)
+    return options.bot;
+  const envLocal = parseEnvLocal();
+  const scopedKey = env === "dev" ? "CALABASAS_BOT_ID_DEV" : "CALABASAS_BOT_ID_PROD";
+  const scopedBotId = envLocal[scopedKey];
+  if (scopedBotId)
+    return scopedBotId;
+  const legacyBotId = envLocal["CALABASAS_BOT_ID"];
+  if (legacyBotId) {
+    console.warn("Warning: CALABASAS_BOT_ID is deprecated. Use CALABASAS_BOT_ID_DEV and CALABASAS_BOT_ID_PROD instead.");
+    return legacyBotId;
+  }
+  const response = await fetch(`${apiUrl}/api/cli/bots`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    }
+  });
+  if (!response.ok) {
+    console.error("Error fetching bots: " + await response.text());
+    process.exit(1);
+  }
+  const { bots } = await response.json();
+  if (!bots || bots.length === 0) {
+    console.error("No bots found. Add a bot first with `calabasas bot add`.");
+    process.exit(1);
+  }
+  if (bots.length === 1) {
+    return bots[0]._id;
+  }
+  const p = await import("@clack/prompts");
+  const selected = await p.select({
+    message: "Select a bot",
+    options: bots.map((bot) => ({
+      value: bot._id,
+      label: bot.name
+    }))
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Cancelled.");
+    process.exit(1);
+  }
+  return selected;
+}
+function appendToEnvLocal(entries) {
+  const envPath = path.join(process.cwd(), ".env.local");
+  let lines = [];
+  if (fs.existsSync(envPath)) {
+    lines = fs.readFileSync(envPath, "utf-8").split(`
+`);
+  }
+  for (const [key, value] of Object.entries(entries)) {
+    const lineIndex = lines.findIndex((l) => {
+      const trimmed = l.trim();
+      return trimmed.startsWith(`${key}=`) || trimmed.startsWith(`${key} =`);
+    });
+    if (lineIndex !== -1) {
+      lines[lineIndex] = `${key}=${value}`;
+    } else {
+      if (!lines.some((l) => l.trim() === "# Calabasas")) {
+        if (lines.length > 0 && lines[lines.length - 1].trim() !== "") {
+          lines.push("");
+        }
+        lines.push("# Calabasas");
+      }
+      lines.push(`${key}=${value}`);
+    }
+  }
+  fs.writeFileSync(envPath, lines.join(`
+`));
+}
+
+export { getConfig, saveConfig, clearConfig, isAuthenticated, getApiUrlForEnv, getWebUrlForEnv, getConvexUrl, resolveEnv, resolveBot, appendToEnvLocal };

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   resolveBot,
   resolveEnv,
   saveConfig
-} from "./index-3mz2smj0.js";
+} from "./index-qnd4rw0e.js";
 import {
   __commonJS,
   __require,
@@ -2336,7 +2336,7 @@ async function push(options) {
   const config = getConfig(env);
   const apiKey = config.apiKey;
   p4.intro("calabasas push");
-  const botId = await resolveBot(options, apiKey, apiUrl);
+  const botId = await resolveBot(options, apiKey, apiUrl, env);
   const calabasasConfig = await parseConfigFile(configPath);
   const eventConfigs = Object.keys(calabasasConfig.events ?? {}).map((eventType) => ({ eventType }));
   const s = p4.spinner();
@@ -5253,18 +5253,19 @@ async function botAdd(options) {
   p10.note(`${sharedSecret}
 
 Add this to your Convex environment as CALABASAS_SECRET`, "Shared Secret");
+  const botIdKey = env === "dev" ? "CALABASAS_BOT_ID_DEV" : "CALABASAS_BOT_ID_PROD";
   if (nonInteractive) {
-    appendToEnvLocal({ CALABASAS_ENV: env, CALABASAS_BOT_ID: botId });
+    appendToEnvLocal({ CALABASAS_ENV: env, [botIdKey]: botId });
     p10.note(`CALABASAS_ENV=${env}
-CALABASAS_BOT_ID=${botId}`, "Saved to .env.local");
+${botIdKey}=${botId}`, "Saved to .env.local");
   } else {
     const saveEnv = await p10.confirm({
-      message: "Save defaults to .env.local? (CALABASAS_ENV + CALABASAS_BOT_ID)"
+      message: `Save defaults to .env.local? (CALABASAS_ENV + ${botIdKey})`
     });
     if (!p10.isCancel(saveEnv) && saveEnv) {
-      appendToEnvLocal({ CALABASAS_ENV: env, CALABASAS_BOT_ID: botId });
+      appendToEnvLocal({ CALABASAS_ENV: env, [botIdKey]: botId });
       p10.note(`CALABASAS_ENV=${env}
-CALABASAS_BOT_ID=${botId}`, "Saved to .env.local");
+${botIdKey}=${botId}`, "Saved to .env.local");
     }
   }
   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");
@@ -5424,13 +5425,365 @@ async function botEdit(botId, options) {
   p10.outro("Bot updated successfully!");
 }
 
+// src/commands/config.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
+import * as p11 from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/lib/configSerializer.ts
+function indent(str, level) {
+  return str.split(`
+`).map((line) => line.trim() === "" ? "" : "  ".repeat(level) + line).join(`
+`);
+}
+function serializeValue(value, depth) {
+  if (value === null || value === undefined)
+    return "null";
+  if (typeof value === "boolean")
+    return String(value);
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    const allPrimitive = value.every((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean");
+    if (allPrimitive && value.length <= 5) {
+      return `[${value.map((v) => serializeValue(v, depth + 1)).join(", ")}]`;
+    }
+    const items = value.map((v) => indent(serializeValue(v, depth + 1), depth + 1));
+    return `[
+${items.join(`,
+`)}
+${"  ".repeat(depth)}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+      return "{}";
+    const lines = entries.map(([key, val]) => {
+      const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+      return `${"  ".repeat(depth + 1)}${safeKey}: ${serializeValue(val, depth + 1)},`;
+    });
+    return `{
+${lines.join(`
+`)}
+${"  ".repeat(depth)}}`;
+  }
+  return String(value);
+}
+function serializeConfig(config) {
+  const sections = [];
+  if (config.intents && config.intents.length > 0) {
+    const items = config.intents.map((name) => JSON.stringify(name)).join(", ");
+    sections.push(`  intents: [${items}],`);
+  }
+  if (config.sync) {
+    const syncLines = Object.entries(config.sync).map(([key, val]) => `    ${key}: ${val},`);
+    sections.push(`  sync: {
+${syncLines.join(`
+`)}
+  },`);
+  }
+  if (config.events) {
+    const eventKeys = Object.keys(config.events);
+    if (eventKeys.length > 0) {
+      const eventLines = eventKeys.map((key) => `    ${key}: true,`);
+      sections.push(`  events: {
+${eventLines.join(`
+`)}
+  },`);
+    }
+  }
+  if (config.commands) {
+    const commandKeys = Object.keys(config.commands);
+    if (commandKeys.length > 0) {
+      const commandLines = commandKeys.map((name) => {
+        const def = config.commands[name];
+        const serialized = serializeValue(def, 2);
+        return `    ${name}: ${serialized},`;
+      });
+      sections.push(`  commands: {
+${commandLines.join(`
+`)}
+  },`);
+    }
+  }
+  return [
+    `import { defineCalabasas } from "calabasas";`,
+    ``,
+    `export default defineCalabasas({`,
+    sections.join(`
+`),
+    `});`,
+    ``
+  ].join(`
+`);
+}
+
+// src/lib/events.ts
+var DISCORD_EVENTS_META = {
+  messageCreate: { intent: "GuildMessages", privileged: false },
+  messageUpdate: { intent: "GuildMessages", privileged: false },
+  messageDelete: { intent: "GuildMessages", privileged: false },
+  guildMemberAdd: { intent: "GuildMembers", privileged: true },
+  guildMemberRemove: { intent: "GuildMembers", privileged: true },
+  guildMemberUpdate: { intent: "GuildMembers", privileged: true },
+  interactionCreate: { intent: null, privileged: false },
+  voiceStateUpdate: { intent: "GuildVoiceStates", privileged: false },
+  presenceUpdate: { intent: "GuildPresences", privileged: true },
+  typingStart: { intent: "GuildMessageTyping", privileged: false },
+  messageReactionAdd: { intent: "GuildMessageReactions", privileged: false },
+  messageReactionRemove: { intent: "GuildMessageReactions", privileged: false }
+};
+
+// src/lib/sync.ts
+var SYNC_PROPERTIES_META = {
+  guilds: { intent: null, privileged: false, description: "Sync guild/server info" },
+  channels: { intent: null, privileged: false, description: "Sync channels" },
+  roles: { intent: null, privileged: false, description: "Sync roles" },
+  members: { intent: "GuildMembers", privileged: true, description: "Sync members" },
+  presence: { intent: "GuildPresences", privileged: true, description: "Sync online status" }
+};
+
+// src/commands/config.ts
+var ALL_EVENTS = Object.keys(DISCORD_EVENTS_META);
+var ALL_SYNC = Object.keys(SYNC_PROPERTIES_META);
+function resolveConfigPath(configOption) {
+  return path8.resolve(process.cwd(), configOption);
+}
+function validateEventNames(names) {
+  const valid = [];
+  const invalid = [];
+  for (const name of names) {
+    if (ALL_EVENTS.includes(name)) {
+      valid.push(name);
+    } else {
+      invalid.push(name);
+    }
+  }
+  return { valid, invalid };
+}
+function validateSyncNames(names) {
+  const valid = [];
+  const invalid = [];
+  for (const name of names) {
+    if (ALL_SYNC.includes(name)) {
+      valid.push(name);
+    } else {
+      invalid.push(name);
+    }
+  }
+  return { valid, invalid };
+}
+function intentHint(intent, privileged) {
+  if (!intent)
+    return "";
+  const tag = privileged ? pc2.yellow(`requires ${intent} privileged intent`) : pc2.dim(`requires ${intent} intent`);
+  return `  ${tag}`;
+}
+function listConfig(config, configPath) {
+  const relPath = path8.relative(process.cwd(), configPath);
+  console.log(`
+${pc2.bold("Calabasas Config")} ${pc2.dim(`(${relPath})`)}
+`);
+  console.log(pc2.bold("Sync:"));
+  for (const key of ALL_SYNC) {
+    const meta = SYNC_PROPERTIES_META[key];
+    const enabled = config.sync?.[key] === true;
+    const dot = enabled ? pc2.green("  ●") : pc2.dim("  ○");
+    const hint = !enabled ? intentHint(meta.intent, meta.privileged) : "";
+    console.log(`${dot} ${key}${hint}`);
+  }
+  console.log(`
+${pc2.bold("Events:")}`);
+  const enabledEvents = new Set(Object.keys(config.events ?? {}));
+  for (const key of ALL_EVENTS) {
+    const meta = DISCORD_EVENTS_META[key];
+    const enabled = enabledEvents.has(key);
+    const dot = enabled ? pc2.green("  ●") : pc2.dim("  ○");
+    const hint = !enabled ? intentHint(meta.intent, meta.privileged) : "";
+    console.log(`${dot} ${key}${hint}`);
+  }
+  const commandNames = Object.keys(config.commands ?? {});
+  if (commandNames.length > 0) {
+    console.log(`
+${pc2.bold("Commands:")}`);
+    for (const name of commandNames) {
+      console.log(`  /${name} — ${config.commands[name].description}`);
+    }
+  }
+  console.log("");
+}
+async function interactiveConfig(config, configPath) {
+  p11.intro("calabasas config");
+  const syncSelection = await p11.multiselect({
+    message: "Select sync properties to enable",
+    options: ALL_SYNC.map((key) => {
+      const meta = SYNC_PROPERTIES_META[key];
+      const hint = meta.privileged ? `${meta.description} (Privileged)` : meta.description;
+      return {
+        value: key,
+        label: meta.privileged ? pc2.yellow(key) : key,
+        hint
+      };
+    }),
+    initialValues: ALL_SYNC.filter((key) => config.sync?.[key] === true),
+    required: false
+  });
+  if (p11.isCancel(syncSelection)) {
+    p11.cancel("Cancelled.");
+    return;
+  }
+  const eventSelection = await p11.multiselect({
+    message: "Select events to enable",
+    options: ALL_EVENTS.map((key) => {
+      const meta = DISCORD_EVENTS_META[key];
+      const hint = meta.intent ? meta.privileged ? `${meta.intent} (Privileged)` : meta.intent : "No intent required";
+      return {
+        value: key,
+        label: meta.privileged ? pc2.yellow(key) : key,
+        hint
+      };
+    }),
+    initialValues: Object.keys(config.events ?? {}),
+    required: false
+  });
+  if (p11.isCancel(eventSelection)) {
+    p11.cancel("Cancelled.");
+    return;
+  }
+  const selectedSync = new Set(syncSelection);
+  const selectedEvents = new Set(eventSelection);
+  const newConfig = { ...config };
+  const newSync = {};
+  for (const key of ALL_SYNC) {
+    newSync[key] = selectedSync.has(key);
+  }
+  newConfig.sync = newSync;
+  const newEvents = {};
+  for (const key of selectedEvents) {
+    newEvents[key] = true;
+  }
+  newConfig.events = newEvents;
+  const oldSync = config.sync ?? {};
+  const oldEvents = new Set(Object.keys(config.events ?? {}));
+  const syncChanged = ALL_SYNC.some((key) => oldSync[key] === true !== selectedSync.has(key));
+  const eventsChanged = selectedEvents.size !== oldEvents.size || [...selectedEvents].some((e) => !oldEvents.has(e));
+  if (!syncChanged && !eventsChanged) {
+    p11.outro("No changes.");
+    return;
+  }
+  const changes = [];
+  for (const key of ALL_SYNC) {
+    const was = oldSync[key] === true;
+    const now = selectedSync.has(key);
+    if (was && !now)
+      changes.push(`sync.${key}: ${pc2.red("enabled → disabled")}`);
+    if (!was && now)
+      changes.push(`sync.${key}: ${pc2.green("disabled → enabled")}`);
+  }
+  for (const key of ALL_EVENTS) {
+    const was = oldEvents.has(key);
+    const now = selectedEvents.has(key);
+    if (was && !now)
+      changes.push(`events.${key}: ${pc2.red("enabled → disabled")}`);
+    if (!was && now)
+      changes.push(`events.${key}: ${pc2.green("disabled → enabled")}`);
+  }
+  p11.note(changes.join(`
+`), "Changes");
+  const source = serializeConfig(newConfig);
+  fs8.writeFileSync(configPath, source);
+  p11.log.info(pc2.dim("Note: Comments in the original file are not preserved."));
+  p11.outro(`Updated ${path8.relative(process.cwd(), configPath)}. Run ${pc2.cyan("`calabasas generate`")} to regenerate code.`);
+}
+async function config(options) {
+  const configPath = resolveConfigPath(options.config);
+  if (!fs8.existsSync(configPath)) {
+    console.error(`Error: Config file not found: ${configPath}`);
+    console.error(`
+Run ${pc2.cyan("`calabasas init`")} first.`);
+    process.exit(1);
+  }
+  const currentConfig = await parseConfigFile(configPath);
+  if (options.list) {
+    listConfig(currentConfig, configPath);
+    return;
+  }
+  const hasFlags = options.addEvent?.length || options.removeEvent?.length || options.addSync?.length || options.removeSync?.length;
+  if (hasFlags) {
+    if (options.addEvent?.length) {
+      const { invalid } = validateEventNames(options.addEvent);
+      if (invalid.length > 0) {
+        console.error(`Error: Unknown event names: ${invalid.join(", ")}`);
+        console.error(`Valid events: ${ALL_EVENTS.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    if (options.removeEvent?.length) {
+      const { invalid } = validateEventNames(options.removeEvent);
+      if (invalid.length > 0) {
+        console.error(`Error: Unknown event names: ${invalid.join(", ")}`);
+        console.error(`Valid events: ${ALL_EVENTS.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    if (options.addSync?.length) {
+      const { invalid } = validateSyncNames(options.addSync);
+      if (invalid.length > 0) {
+        console.error(`Error: Unknown sync properties: ${invalid.join(", ")}`);
+        console.error(`Valid properties: ${ALL_SYNC.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    if (options.removeSync?.length) {
+      const { invalid } = validateSyncNames(options.removeSync);
+      if (invalid.length > 0) {
+        console.error(`Error: Unknown sync properties: ${invalid.join(", ")}`);
+        console.error(`Valid properties: ${ALL_SYNC.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    const newConfig = { ...currentConfig };
+    if (options.addSync?.length || options.removeSync?.length) {
+      const sync = { ...currentConfig.sync };
+      for (const name of options.addSync ?? []) {
+        sync[name] = true;
+      }
+      for (const name of options.removeSync ?? []) {
+        sync[name] = false;
+      }
+      newConfig.sync = sync;
+    }
+    if (options.addEvent?.length || options.removeEvent?.length) {
+      const events = { ...currentConfig.events };
+      for (const name of options.addEvent ?? []) {
+        events[name] = true;
+      }
+      for (const name of options.removeEvent ?? []) {
+        delete events[name];
+      }
+      newConfig.events = events;
+    }
+    const source = serializeConfig(newConfig);
+    fs8.writeFileSync(configPath, source);
+    console.log(`Updated ${path8.relative(process.cwd(), configPath)}.`);
+    console.log(`Run ${pc2.cyan("`calabasas generate`")} to regenerate code.`);
+    return;
+  }
+  await interactiveConfig(currentConfig, configPath);
+}
+
 // src/index.ts
 var dashboard = async (...args) => {
-  const mod = await import("./dashboard-hggessbt.js");
+  const mod = await import("./dashboard-r2cptf7m.js");
   return mod.dashboard(args[0]);
 };
 var logs = async (...args) => {
-  const mod = await import("./logs-t9qswyv5.js");
+  const mod = await import("./logs-452qgkw7.js");
   return mod.logs(args[0], args[1]);
 };
 var program2 = new Command;
@@ -5443,6 +5796,7 @@ program2.command("generate").description("Generate type-safe Discord handlers an
 program2.command("skill").description("Generate Calabasas documentation for AI assistants").option("--dev", "Use development environment").option("--prod", "Use production environment").option("-f, --file <path>", "Target file path (e.g. CLAUDE.md)").option("-y, --yes", "Auto-confirm replacing existing guidelines").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("config").description("View and modify your Calabasas config").option("-c, --config <path>", "Path to config file", "convex/calabasas/config.ts").option("-l, --list", "List current and available config options").option("--add-event <events...>", "Enable event handlers").option("--remove-event <events...>", "Disable event handlers").option("--add-sync <properties...>", "Enable sync properties").option("--remove-sync <properties...>", "Disable sync properties").action(config);
 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/dist/logs-452qgkw7.js

@@ -0,0 +1,70 @@
+import {
+  LogViewer
+} from "./index-f8td7thj.js";
+import {
+  getApiUrlForEnv,
+  getConfig,
+  getConvexUrl,
+  isAuthenticated,
+  resolveBot,
+  resolveEnv
+} from "./index-qnd4rw0e.js";
+import"./index-8gymgyxd.js";
+import"./index-tre7d3f1.js";
+import {
+  __toESM
+} from "./index-sdksp5px.js";
+import {
+  render_default,
+  use_app_default,
+  use_input_default
+} from "./index-4rn9k8et.js";
+import {
+  ConvexProvider,
+  createConvexClient,
+  require_jsx_dev_runtime
+} from "./convex-1z1jsz1n.js";
+import"./index-vmy4gfe1.js";
+
+// src/commands/logs.tsx
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function LogsApp({ apiKey, botId, limit }) {
+  const { exit } = use_app_default();
+  use_input_default((input) => {
+    if (input === "q") {
+      exit();
+    }
+  });
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(LogViewer, {
+    apiKey,
+    botId,
+    limit
+  }, undefined, false, undefined, this);
+}
+async function logs(botId, options) {
+  const env = resolveEnv(options);
+  if (!isAuthenticated(env)) {
+    console.log("Not logged in. Run `calabasas login` first.");
+    return;
+  }
+  const config = getConfig(env);
+  const apiKey = config.apiKey;
+  const apiUrl = getApiUrlForEnv(env);
+  botId = await resolveBot({ bot: botId }, apiKey, apiUrl, env);
+  const limit = options.limit ? parseInt(options.limit, 10) : 50;
+  const convexUrl = getConvexUrl(env);
+  const client = createConvexClient(convexUrl);
+  const { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime.jsxDEV(ConvexProvider, {
+    client,
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(LogsApp, {
+      apiKey,
+      botId,
+      limit
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this));
+  await waitUntilExit();
+  await client.close();
+}
+export {
+  logs
+};

package/package.json

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