@zaflun/lumio-cli 0.2.0 → 0.5.2

package/dist/index.js

@@ -75,7 +75,7 @@ function registerLogin(program2) {
     const state = crypto.randomBytes(16).toString("hex");
     const port = 9876;
     const redirectUri = `http://localhost:${port}/callback`;
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve10, reject) => {
       const server = http.createServer(async (req, res) => {
         if (!req.url?.startsWith("/callback")) {
           res.writeHead(404);
@@ -118,7 +118,7 @@ function registerLogin(program2) {
           return;
         }
         server.close();
-        resolve9();
+        resolve10();
       });
       server.listen(port, async () => {
         const pkceUrl = `${options.apiUrl}/v1/auth/cli/authorize?code_challenge=${challenge}&code_challenge_method=S256&redirect_uri=${encodeURIComponent(redirectUri)}&state=${state}`;
@@ -288,24 +288,136 @@ function registerInit(program2) {
       }
     } catch {
     }
-    const answers = await inquirer.prompt([
+    const baseAnswers = await inquirer.prompt([
       { type: "input", name: "name", message: "Extension name:", default: name },
       { type: "input", name: "description", message: "Description:" },
       {
         type: "list",
         name: "category",
         message: "Category:",
-        choices: ["widget", "extension", "overlay", "bot_module", "integration", "theme"]
-      },
-      {
-        type: "checkbox",
-        name: "targets",
-        message: "Targets:",
-        choices: ["editor", "layer", "interactive"],
-        default: ["editor", "layer"]
-      },
-      { type: "confirm", name: "server", message: "Server functions?", default: false }
+        choices: ["widget", "extension", "overlay", "bot_module", "integration", "theme", "automation_node"]
+      }
     ]);
+    const answers = { ...baseAnswers, targets: [], server: false };
+    if (answers.category === "bot_module") {
+      const { platforms } = await inquirer.prompt([{
+        type: "checkbox",
+        name: "platforms",
+        message: "Which platforms should this bot module support?",
+        choices: ["twitch", "youtube", "kick", "trovo", "discord"],
+        default: ["twitch"],
+        validate: (input) => input.length > 0 || "Select at least one platform"
+      }]);
+      answers.platforms = platforms;
+      answers.targets = [];
+      answers.server = true;
+    } else if (answers.category === "automation_node") {
+      const nodeAnswers = await inquirer.prompt([
+        {
+          type: "list",
+          name: "nodeType",
+          message: "Node type:",
+          choices: [
+            { name: "Action \u2014 perform work when the automation runs", value: "action" },
+            { name: "Trigger \u2014 start an automation from an external event", value: "trigger" },
+            { name: "Logic \u2014 conditional branching", value: "logic" }
+          ]
+        }
+      ]);
+      let triggerMode;
+      if (nodeAnswers.nodeType === "trigger") {
+        const triggerAnswers = await inquirer.prompt([
+          {
+            type: "list",
+            name: "triggerMode",
+            message: "How does this trigger receive events?",
+            choices: [
+              { name: "Webhook \u2014 receive HTTP POST from an external service", value: "webhook" },
+              { name: "Polling \u2014 periodically check an external service", value: "polling" },
+              { name: "Both \u2014 support webhook and polling", value: "both" }
+            ]
+          }
+        ]);
+        triggerMode = triggerAnswers.triggerMode;
+      }
+      answers.targets = ["editor"];
+      answers.server = true;
+      answers.nodeType = nodeAnswers.nodeType;
+      answers.triggerMode = triggerMode;
+    } else {
+      const targetAndServer = await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "targets",
+          message: "Targets:",
+          choices: ["editor", "layer", "interactive"],
+          default: ["editor", "layer"]
+        },
+        { type: "confirm", name: "server", message: "Server functions?", default: false }
+      ]);
+      answers.targets = targetAndServer.targets;
+      answers.server = targetAndServer.server;
+    }
+    let editorApproach = "schema";
+    if (answers.category !== "bot_module" && answers.category !== "automation_node") {
+      const editorChoice = await inquirer.prompt([{
+        type: "list",
+        name: "approach",
+        message: "How should the editor UI be built?",
+        choices: [
+          { name: "config_schema only \u2014 auto-generated form from schema fields (recommended)", value: "schema" },
+          { name: "editor.tsx only \u2014 fully custom React UI in sandbox", value: "custom" },
+          { name: "Both \u2014 schema fields + custom editor.tsx for advanced controls", value: "both" }
+        ],
+        default: "schema"
+      }]);
+      editorApproach = editorChoice.approach;
+      if (editorApproach === "schema") {
+        answers.targets = answers.targets.filter((t) => t !== "editor");
+      } else if (!answers.targets.includes("editor")) {
+        answers.targets.push("editor");
+      }
+    }
+    answers.editorApproach = editorApproach;
+    let includeDesigner = false;
+    if (answers.category === "widget" || answers.category === "overlay") {
+      const designerAnswer = await inquirer.prompt([{
+        type: "confirm",
+        name: "includeDesigner",
+        message: "Include a visual designer? (fullpage design editor with live preview)",
+        default: false
+      }]);
+      includeDesigner = designerAnswer.includeDesigner;
+    }
+    let useTailwind = false;
+    if (answers.category !== "bot_module") {
+      const styleAnswer = await inquirer.prompt([
+        {
+          type: "list",
+          name: "styling",
+          message: "Styling approach:",
+          choices: [
+            { name: "Tailwind CSS v4 (recommended)", value: "tailwind" },
+            { name: "Plain CSS", value: "css" },
+            { name: "Inline styles only", value: "inline" }
+          ],
+          default: "tailwind"
+        }
+      ]);
+      useTailwind = styleAnswer.styling === "tailwind";
+      answers.styling = styleAnswer.styling;
+    }
+    try {
+      await client.get("/v1/developer/profile");
+    } catch (err) {
+      if (err.status === 404) {
+        console.error(
+          "\n  You need to apply as a developer first.\n  Visit https://lumio.vision/account/developer to submit your application.\n"
+        );
+        process.exit(1);
+      }
+      throw err;
+    }
     const createBody = {
       name: answers.name,
       description: answers.description,
@@ -327,34 +439,120 @@ function registerInit(program2) {
       version: "0.1.0",
       targets: answers.targets,
       server: answers.server,
-      permissions: [],
+      permissions: answers.category === "bot_module" ? ["chat:read", "chat:send"] : [],
       egress: { allowHosts: [], allowPorts: [443] },
       visibility: "private",
       pricing: { type: "free" }
     };
+    if (editorApproach === "schema" || editorApproach === "both") {
+      config.config_schema = [
+        { key: "title", type: "string", label: "Title", default_value: answers.name, required: false, placeholder: "Enter a title..." },
+        { key: "fontSize", type: "number", label: "Font Size", default_value: 16, required: false, min: 8, max: 200, step: 1, unit: "px" },
+        { key: "color", type: "color", label: "Color", default_value: "#ffffff", required: false }
+      ];
+    }
+    if (includeDesigner) {
+      config.designer_schema = [
+        { key: "primaryColor", type: "color", label: "Primary Color", default_value: "#43F7CD", required: false },
+        { key: "backgroundColor", type: "color", label: "Background Color", default_value: "#1a1a2e", required: false },
+        { key: "fontFamily", type: "font", label: "Font Family", default_value: "Inter", required: false }
+      ];
+      if (config.config_schema && Array.isArray(config.config_schema)) {
+        config.config_schema.push({ key: "design", type: "designer", label: "Widget Designer", required: false, default_value: null });
+      }
+    }
+    if (answers.category === "bot_module") {
+      config.platforms = answers.platforms;
+      config.triggers = {
+        commands: [{ name: "hello", description: "Say hello", cooldownGlobal: 5, cooldownUser: 10, minRole: "everyone" }],
+        keywords: [],
+        patterns: [],
+        events: [],
+        timers: []
+      };
+    }
+    if (answers.category === "automation_node") {
+      const nodeType = answers.nodeType;
+      const triggerMode = answers.triggerMode;
+      config.node_type = nodeType;
+      const nodeConfig = {
+        input_schema: {
+          type: "object",
+          properties: {
+            value: { type: "string", title: "Input Value" }
+          },
+          required: ["value"]
+        },
+        output_schema: {
+          type: "object",
+          properties: {
+            result: { type: "string" }
+          }
+        }
+      };
+      if (nodeType === "trigger") {
+        nodeConfig.trigger_mode = triggerMode;
+        if (triggerMode === "polling" || triggerMode === "both") {
+          nodeConfig.poll_interval_seconds = 30;
+        }
+      }
+      nodeConfig.icon = "puzzle";
+      nodeConfig.color = "#a855f7";
+      config.node = nodeConfig;
+    }
     fs2.writeFileSync(
       path2.join(projectDir, "lumio.config.json"),
       JSON.stringify(config, null, 2)
     );
+    const isBotModule = answers.category === "bot_module";
+    const isAutomationNode = answers.category === "automation_node";
+    const needsReact = !isBotModule || isAutomationNode;
+    const lintDir = isBotModule ? "server/" : "src/";
     const pkg = {
       name: answers.name.toLowerCase().replace(/\s+/g, "-"),
       version: "0.1.0",
       private: true,
       type: "module",
+      scripts: {
+        "dev": isBotModule ? "lumio dev --bot-module" : isAutomationNode ? "lumio dev --automation-node" : "lumio dev",
+        "build": "lumio build",
+        "deploy": "lumio deploy",
+        "typecheck": "tsc --noEmit",
+        "lint": `eslint ${lintDir}`
+      },
       dependencies: {
         "@zaflun/lumio-sdk": "latest",
-        "react": "^19.1.0",
-        "react-dom": "^19.1.0"
+        ...needsReact ? { "react": "^19.2.5" } : {}
       },
       devDependencies: {
-        "typescript": "^5.8.3",
-        "@types/react": "^19.1.0"
+        "typescript": "^6.0.3",
+        ...needsReact ? { "@types/react": "^19.1.0" } : {},
+        ...useTailwind ? { "tailwindcss": "^4.3.0" } : {}
       }
     };
     fs2.writeFileSync(
       path2.join(projectDir, "package.json"),
       JSON.stringify(pkg, null, 2)
     );
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        jsx: "react-jsx",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        outDir: "dist"
+      },
+      include: answers.category === "bot_module" ? ["server/**/*"] : ["src/**/*", "server/**/*"]
+    };
+    fs2.writeFileSync(
+      path2.join(projectDir, "tsconfig.json"),
+      JSON.stringify(tsconfig, null, 2)
+    );
+    const eslintConfig = 'import eslintJs from "@eslint/js";\nimport tseslint from "typescript-eslint";\n\nexport default tseslint.config(\n  eslintJs.configs.recommended,\n  ...tseslint.configs.recommended,\n  {\n    rules: {\n      "quotes": ["error", "double", { avoidEscape: true }],\n    },\n  },\n);\n';
+    fs2.writeFileSync(path2.join(projectDir, "eslint.config.mjs"), eslintConfig);
     const changelog = `# Changelog
 
 ## [0.1.0] - ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -364,8 +562,83 @@ function registerInit(program2) {
 `;
     fs2.writeFileSync(path2.join(projectDir, "CHANGELOG.md"), changelog);
     fs2.mkdirSync(path2.join(projectDir, "src"), { recursive: true });
-    for (const target of answers.targets) {
-      const content = `import { Lumio, CompactView, Text } from "@zaflun/lumio-sdk";
+    if (useTailwind) {
+      fs2.writeFileSync(
+        path2.join(projectDir, "src", "globals.css"),
+        '@import "tailwindcss";\n'
+      );
+    } else if (needsReact && answers.styling === "css") {
+      fs2.writeFileSync(
+        path2.join(projectDir, "src", "globals.css"),
+        "/* Add your custom styles here */\n"
+      );
+    }
+    if (answers.category === "bot_module") {
+      fs2.mkdirSync(path2.join(projectDir, "server"), { recursive: true });
+      const serverFunctions = 'import { command } from "@zaflun/lumio-sdk/server";\n\nexport const hello = command("hello", async (ctx, args) => {\n  return { reply: `Hello ${ctx.user?.name ?? "stranger"}!` };\n});\n';
+      fs2.writeFileSync(path2.join(projectDir, "server", "functions.ts"), serverFunctions);
+      const schema = 'import { defineSchema } from "@zaflun/lumio-sdk/server";\n\nexport default defineSchema({});\n';
+      fs2.writeFileSync(path2.join(projectDir, "server", "schema.ts"), schema);
+    } else if (answers.category === "automation_node") {
+      fs2.mkdirSync(path2.join(projectDir, "server"), { recursive: true });
+      const nodeType = answers.nodeType;
+      const triggerMode = answers.triggerMode;
+      let serverHandler;
+      if (nodeType === "action") {
+        serverHandler = 'import { defineAutomationAction } from "@zaflun/lumio-sdk/server";\n\ndefineAutomationAction(async (ctx) => {\n  const value = ctx.inputData.value;\n\n  // TODO: Implement your action logic\n  // Use ctx.fetch() for external API calls\n  // Use ctx.cache.get/set for temporary storage\n  // Use ctx.installConfig for extension-level settings\n  // Use ctx.nodeConfig for per-node-instance settings\n\n  return {\n    output: { result: `Processed: ${value}` },\n    status: "success",\n  };\n});\n';
+      } else if (nodeType === "trigger") {
+        const parts = [];
+        if (triggerMode === "webhook" || triggerMode === "both") {
+          parts.push("  onWebhook: async (ctx) => {\n    const payload = ctx.webhookBody;\n\n    // TODO: Validate the incoming webhook payload\n    // Return { fired: false } to ignore the event\n    // Return { fired: true, output: { ... } } to trigger the automation\n\n    return {\n      fired: true,\n      output: {\n        result: JSON.stringify(payload),\n      },\n    };\n  }");
+        }
+        if (triggerMode === "polling" || triggerMode === "both") {
+          parts.push('  onPoll: async (ctx) => {\n    const lastCheck = await ctx.cache.get("last_check_ts");\n\n    // TODO: Check your external service for new events\n    // const res = await ctx.fetch("https://api.example.com/events?since=" + lastCheck);\n    // const events = await res.json();\n\n    await ctx.cache.set("last_check_ts", Date.now().toString());\n\n    // Return null or { fired: false } if no new events\n    // Return { fired: true, output: { ... } } to trigger the automation\n    return null;\n  }');
+        }
+        serverHandler = `import { defineAutomationTrigger } from "@zaflun/lumio-sdk/server";
+
+defineAutomationTrigger({
+${parts.join(",\n")}
+});
+`;
+      } else {
+        serverHandler = 'import { defineAutomationLogic } from "@zaflun/lumio-sdk/server";\n\ndefineAutomationLogic(async (ctx) => {\n  const value = ctx.inputData.value;\n  const threshold = ctx.nodeConfig.threshold ?? 50;\n\n  // TODO: Implement your branching logic\n  // Return the branch key that matches an output handle\n\n  if (Number(value) > Number(threshold)) {\n    return "above";\n  }\n  return "below";\n});\n';
+      }
+      fs2.writeFileSync(path2.join(projectDir, "server", "handler.ts"), serverHandler);
+      const editorComponent = `import { Lumio, CompactView, Text } from "@zaflun/lumio-sdk";
+import { useLumioConfig } from "@zaflun/lumio-sdk/hooks";
+
+function ConfigPanel() {
+  const [config, setConfig] = useLumioConfig();
+
+  return (
+    <CompactView title="${answers.name} \u2014 Settings">
+      <Text content="Configure your automation node here." />
+    </CompactView>
+  );
+}
+
+Lumio.render(<ConfigPanel />, { target: "editor" });
+`;
+      fs2.writeFileSync(path2.join(projectDir, "src", "editor.tsx"), editorComponent);
+    } else {
+      for (const target of answers.targets) {
+        if (target === "editor" && editorApproach === "schema") continue;
+        const isEditorTarget = target === "editor";
+        const content = isEditorTarget ? `import { Lumio, CompactView, Text } from "@zaflun/lumio-sdk";
+import { useLumioConfig } from "@zaflun/lumio-sdk";
+
+function Editor() {
+  const [config, setConfig] = useLumioConfig();
+
+  return (
+    <CompactView title="${answers.name} \u2014 Advanced">
+      <Text content="Custom editor controls go here." />
+    </CompactView>
+  );
+}
+
+export default Editor;
+` : `import { Lumio, CompactView, Text } from "@zaflun/lumio-sdk";
 
 function App() {
   return (
@@ -377,14 +650,15 @@ function App() {
 
 Lumio.render(<App />, { target: "${target}" });
 `;
-      fs2.writeFileSync(path2.join(projectDir, "src", `${target}.tsx`), content);
-    }
-    if (answers.server) {
-      fs2.mkdirSync(path2.join(projectDir, "server"), { recursive: true });
-      const schema = 'import { defineSchema, defineTable, v } from "@zaflun/lumio-sdk/server";\n\nexport default defineSchema({\n  items: defineTable({\n    text: v.string(),\n    completed: v.boolean(),\n  }).storage("instance"),\n});\n';
-      fs2.writeFileSync(path2.join(projectDir, "server", "schema.ts"), schema);
-      const functions = 'import { queryRows, insertRow, patchRow, deleteRow, arg } from "@zaflun/lumio-sdk/server";\n\nexport const getItems = queryRows("items");\nexport const addItem = insertRow("items", { text: arg("text"), completed: false }, { editorOnly: true });\nexport const toggleItem = patchRow("items", arg("id"), { completed: arg("completed") }, { editorOnly: true });\nexport const removeItem = deleteRow("items", arg("id"), { editorOnly: true });\n';
-      fs2.writeFileSync(path2.join(projectDir, "server", "functions.ts"), functions);
+        fs2.writeFileSync(path2.join(projectDir, "src", `${target}.tsx`), content);
+      }
+      if (answers.server) {
+        fs2.mkdirSync(path2.join(projectDir, "server"), { recursive: true });
+        const schema = 'import { defineSchema, defineTable, v } from "@zaflun/lumio-sdk/server";\n\nexport default defineSchema({\n  items: defineTable({\n    text: v.string(),\n    completed: v.boolean(),\n  }).storage("instance"),\n});\n';
+        fs2.writeFileSync(path2.join(projectDir, "server", "schema.ts"), schema);
+        const functions = 'import { queryRows, insertRow, patchRow, deleteRow, arg } from "@zaflun/lumio-sdk/server";\n\nexport const getItems = queryRows("items");\nexport const addItem = insertRow("items", { text: arg("text"), completed: false }, { editorOnly: true });\nexport const toggleItem = patchRow("items", arg("id"), { completed: arg("completed") }, { editorOnly: true });\nexport const removeItem = deleteRow("items", arg("id"), { editorOnly: true });\n';
+        fs2.writeFileSync(path2.join(projectDir, "server", "functions.ts"), functions);
+      }
     }
     console.log(`
 Done! Created ${projectDir}/`);
@@ -393,17 +667,6 @@ Done! Created ${projectDir}/`);
 }
 
 // src/commands/dev.ts
-function registerDev(program2) {
-  program2.command("dev").description("Start local dev server with hot-reload and mock events").option("-p, --port <port>", "Dev server port", "3100").action(async (options) => {
-    console.log(`Starting Lumio dev server on port ${options.port}...`);
-    console.log("Mock events enabled. Hot-reload active.");
-    console.log("Open http://localhost:" + options.port + " in your browser.");
-    console.log("\nDev server implementation requires @zaflun/lumio-sdk and Vite.");
-    console.log("Full implementation coming in Phase 12 (Live-Code-Editor).");
-  });
-}
-
-// src/commands/build.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
 
@@ -417,7 +680,7 @@ var ConfigError = class extends Error {
 function parseConfigFile(jsonString) {
   const raw = JSON.parse(jsonString);
   return {
-    extensionId: raw.extensionId ?? "",
+    extensionId: raw.extensionId ?? raw.extension_id ?? "",
     name: raw.name ?? "",
     description: raw.description,
     category: raw.category ?? "widget",
@@ -429,9 +692,21 @@ function parseConfigFile(jsonString) {
       allowHosts: raw.egress?.allowHosts ?? [],
       allowPorts: raw.egress?.allowPorts ?? []
     },
+    platforms: raw.platforms,
+    triggers: raw.triggers,
     fonts: raw.fonts,
+    sounds: raw.sounds,
     visibility: raw.visibility ?? "private",
-    pricing: raw.pricing ?? { type: "free" }
+    pricing: raw.pricing ?? { type: "free" },
+    nodeType: raw.node_type ?? raw.nodeType,
+    node: raw.node ? {
+      inputSchema: raw.node.input_schema ?? raw.node.inputSchema ?? {},
+      outputSchema: raw.node.output_schema ?? raw.node.outputSchema ?? {},
+      triggerMode: raw.node.trigger_mode ?? raw.node.triggerMode,
+      pollIntervalSeconds: raw.node.poll_interval_seconds ?? raw.node.pollIntervalSeconds,
+      icon: raw.node.icon,
+      color: raw.node.color
+    } : void 0
   };
 }
 function validateConfig(config) {
@@ -441,7 +716,32 @@ function validateConfig(config) {
   if (!config.name) {
     throw new ConfigError("name is required in lumio.config.json");
   }
-  if (!config.targets || config.targets.length === 0) {
+  if (config.category === "bot_module") {
+    if (!config.platforms || config.platforms.length === 0) {
+      throw new ConfigError("At least one platform is required for bot_module (twitch, youtube, kick, trovo, discord)");
+    }
+  } else if (config.category === "automation_node") {
+    if (!config.nodeType) {
+      throw new ConfigError("nodeType is required for automation_node extensions (trigger, action, or logic)");
+    }
+    if (!["trigger", "action", "logic"].includes(config.nodeType)) {
+      throw new ConfigError("nodeType must be one of: trigger, action, logic");
+    }
+    if (!config.node) {
+      throw new ConfigError("node configuration is required for automation_node extensions");
+    }
+    if (config.nodeType === "trigger" && !config.node.triggerMode) {
+      throw new ConfigError("node.triggerMode is required for trigger nodes (webhook, polling, or both)");
+    }
+    if (config.nodeType !== "trigger" && config.node.triggerMode) {
+      throw new ConfigError("node.triggerMode is only valid for trigger nodes");
+    }
+    if (config.node.pollIntervalSeconds !== void 0) {
+      if (config.node.pollIntervalSeconds < 10 || config.node.pollIntervalSeconds > 300) {
+        throw new ConfigError("node.pollIntervalSeconds must be between 10 and 300");
+      }
+    }
+  } else if (!config.targets || config.targets.length === 0) {
     throw new ConfigError("At least one target is required (editor, layer, or interactive)");
   }
   if (!config.version) {
@@ -449,28 +749,274 @@ function validateConfig(config) {
   }
 }
 
+// src/commands/dev-bot-module.ts
+import * as readline from "readline";
+import chalk from "chalk";
+function parseUserPrefix(input) {
+  const defaultUser = {
+    id: "user-001",
+    name: "dev_user",
+    displayName: "Dev User",
+    platform: "twitch",
+    role: "everyone",
+    isMod: false,
+    isVip: false,
+    isSub: false
+  };
+  if (!input.startsWith("@")) {
+    return { user: defaultUser, message: input };
+  }
+  const spaceIdx = input.indexOf(" ");
+  if (spaceIdx === -1) return { user: defaultUser, message: input };
+  const prefix = input.substring(1, spaceIdx);
+  const message = input.substring(spaceIdx + 1);
+  const parts = prefix.split(":");
+  const name = parts[parts.length - 1];
+  const rolePrefix = parts.length > 1 ? parts[0] : "everyone";
+  return {
+    user: {
+      id: `user-${name}`,
+      name,
+      displayName: name,
+      platform: "twitch",
+      role: rolePrefix,
+      isMod: rolePrefix === "mod",
+      isVip: rolePrefix === "vip",
+      isSub: ["sub", "vip", "mod", "broadcaster"].includes(rolePrefix)
+    },
+    message
+  };
+}
+async function runBotModuleDevServer(config) {
+  console.log(chalk.bold("\n\u{1F916} Bot Module Dev Server"));
+  console.log(`Extension: ${config.name}`);
+  console.log(`Platforms: ${config.platforms?.join(", ") ?? "none"}`);
+  console.log(chalk.dim("\nType chat messages. Prefix with @username or @role:username."));
+  console.log(chalk.dim("Examples: !hello  |  @sub:viewer !points 100  |  @mod:admin gg"));
+  console.log(chalk.dim("Type !quit to exit.\n"));
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk.cyan("> ")
+  });
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "!quit") {
+      rl.close();
+      return;
+    }
+    const { user, message } = parseUserPrefix(trimmed);
+    console.log(chalk.dim(`  [${user.role}:${user.name}] ${message}`));
+    console.log(chalk.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    console.log(chalk.dim("\nBot Module Dev Server stopped."));
+    process.exit(0);
+  });
+}
+
+// src/commands/dev-automation-node.ts
+import * as readline2 from "readline";
+import chalk2 from "chalk";
+async function runAutomationNodeDevServer(config) {
+  const nodeType = config.nodeType ?? "action";
+  console.log(chalk2.bold("\n\u2699\uFE0F  Automation Node Dev Server"));
+  console.log(`Extension: ${config.name}`);
+  console.log(`Node type: ${nodeType}`);
+  if (nodeType === "trigger" && config.node?.triggerMode) {
+    console.log(`Trigger mode: ${config.node.triggerMode}`);
+  }
+  console.log(chalk2.dim("\nCommands:"));
+  console.log(chalk2.dim("  /execute [json]     \u2014 Execute the node with input data"));
+  if (nodeType === "trigger") {
+    console.log(chalk2.dim("  /webhook [json]     \u2014 Simulate a webhook POST payload"));
+    console.log(chalk2.dim("  /poll               \u2014 Trigger a poll cycle"));
+  }
+  console.log(chalk2.dim("  /config [json]      \u2014 Set node instance config"));
+  console.log(chalk2.dim("  /install-config [j] \u2014 Set extension install config"));
+  console.log(chalk2.dim("  /quit               \u2014 Exit\n"));
+  let nodeConfig = {};
+  let installConfig = {};
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk2.cyan("> ")
+  });
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "/quit") {
+      rl.close();
+      return;
+    }
+    if (trimmed.startsWith("/config ")) {
+      try {
+        nodeConfig = JSON.parse(trimmed.slice("/config ".length));
+        console.log(chalk2.green("  Node config updated."));
+      } catch {
+        console.log(chalk2.red("  Invalid JSON."));
+      }
+      rl.prompt();
+      return;
+    }
+    if (trimmed.startsWith("/install-config ")) {
+      try {
+        installConfig = JSON.parse(trimmed.slice("/install-config ".length));
+        console.log(chalk2.green("  Install config updated."));
+      } catch {
+        console.log(chalk2.red("  Invalid JSON."));
+      }
+      rl.prompt();
+      return;
+    }
+    if (trimmed.startsWith("/execute")) {
+      const jsonStr = trimmed.slice("/execute".length).trim();
+      let inputData = {};
+      if (jsonStr) {
+        try {
+          inputData = JSON.parse(jsonStr);
+        } catch {
+          console.log(chalk2.red("  Invalid JSON."));
+          rl.prompt();
+          return;
+        }
+      }
+      console.log(chalk2.dim(`  [${nodeType}] Executing with input: ${JSON.stringify(inputData)}`));
+      console.log(chalk2.dim(`  [${nodeType}] Node config: ${JSON.stringify(nodeConfig)}`));
+      console.log(chalk2.dim(`  [${nodeType}] Install config: ${JSON.stringify(installConfig)}`));
+      console.log(chalk2.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
+      rl.prompt();
+      return;
+    }
+    if (nodeType === "trigger" && trimmed.startsWith("/webhook")) {
+      const jsonStr = trimmed.slice("/webhook".length).trim();
+      let body = {};
+      if (jsonStr) {
+        try {
+          body = JSON.parse(jsonStr);
+        } catch {
+          console.log(chalk2.red("  Invalid JSON."));
+          rl.prompt();
+          return;
+        }
+      }
+      console.log(chalk2.dim(`  [trigger:webhook] Received payload: ${JSON.stringify(body)}`));
+      console.log(chalk2.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
+      rl.prompt();
+      return;
+    }
+    if (nodeType === "trigger" && trimmed === "/poll") {
+      console.log(chalk2.dim("  [trigger:poll] Polling..."));
+      console.log(chalk2.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
+      rl.prompt();
+      return;
+    }
+    console.log(chalk2.dim("  Unknown command. Type /execute, /webhook, /poll, /config, or /quit."));
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    console.log(chalk2.dim("\nAutomation Node Dev Server stopped."));
+    process.exit(0);
+  });
+}
+
+// src/commands/dev.ts
+function registerDev(program2) {
+  program2.command("dev").description("Start local dev server with hot-reload and mock events").option("-p, --port <port>", "Dev server port", "3100").option("--bot-module", "Start interactive bot module chat simulator").option("--automation-node", "Start automation node dev simulator").action(async (options) => {
+    const configPath = path3.resolve("lumio.config.json");
+    if (options.botModule || options.automationNode || fs3.existsSync(configPath)) {
+      const configExists = fs3.existsSync(configPath);
+      if (configExists) {
+        const config = parseConfigFile(fs3.readFileSync(configPath, "utf-8"));
+        if (options.botModule || config.category === "bot_module") {
+          await runBotModuleDevServer(config);
+          return;
+        }
+        if (options.automationNode || config.category === "automation_node") {
+          await runAutomationNodeDevServer(config);
+          return;
+        }
+      } else if (options.botModule || options.automationNode) {
+        console.error("lumio.config.json not found. Run `lumio init` first.");
+        process.exit(1);
+      }
+    }
+    console.log(`Starting Lumio dev server on port ${options.port}...`);
+    console.log("Mock events enabled. Hot-reload active.");
+    console.log("Open http://localhost:" + options.port + " in your browser.");
+    console.log("\nDev server implementation requires @zaflun/lumio-sdk and Vite.");
+    console.log("Full implementation coming in Phase 12 (Live-Code-Editor).");
+  });
+}
+
 // src/commands/build.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
 function registerBuild(program2) {
   program2.command("build").description("Bundle extension as standalone HTML + source archive").action(async () => {
-    const configPath = path3.resolve("lumio.config.json");
-    if (!fs3.existsSync(configPath)) {
+    const configPath = path4.resolve("lumio.config.json");
+    if (!fs4.existsSync(configPath)) {
       console.error("lumio.config.json not found. Run `lumio init` first.");
       process.exit(1);
     }
-    const configJson = fs3.readFileSync(configPath, "utf-8");
+    const configJson = fs4.readFileSync(configPath, "utf-8");
     const config = parseConfigFile(configJson);
     validateConfig(config);
-    const changelogPath = path3.resolve("CHANGELOG.md");
-    if (!fs3.existsSync(changelogPath)) {
+    const changelogPath = path4.resolve("CHANGELOG.md");
+    if (!fs4.existsSync(changelogPath)) {
       console.warn("Warning: No CHANGELOG.md found. It is recommended to maintain a changelog.");
     }
     console.log(`Building ${config.name} v${config.version}...`);
-    const distDir = path3.resolve("dist");
-    fs3.mkdirSync(distDir, { recursive: true });
+    const distDir = path4.resolve("dist");
+    fs4.mkdirSync(distDir, { recursive: true });
     const { build } = await import("esbuild");
+    if (config.category === "bot_module" && config.targets.length === 0) {
+      console.log("  Bot module \u2014 no UI targets to bundle.");
+    }
+    const cssEntryFile = ["src/globals.css", "src/style.css", "src/index.css"].find((f) => fs4.existsSync(path4.resolve(f)));
+    let compiledCssPath = null;
+    if (cssEntryFile) {
+      const cssContent = fs4.readFileSync(path4.resolve(cssEntryFile), "utf-8");
+      const usesTailwind = cssContent.includes("tailwindcss") || cssContent.includes("@tailwind");
+      if (usesTailwind) {
+        console.log("  Tailwind CSS v4 detected \u2014 compiling...");
+        compiledCssPath = path4.join(distDir, "styles.css");
+        try {
+          await execFileAsync("npx", [
+            "@tailwindcss/cli",
+            "-i",
+            path4.resolve(cssEntryFile),
+            "-o",
+            compiledCssPath,
+            "--minify"
+          ], { cwd: path4.resolve(".") });
+          console.log("  Compiled: dist/styles.css");
+        } catch {
+          console.warn("  Warning: Tailwind CSS compilation failed. Install tailwindcss v4: npm add -D tailwindcss@^4.3");
+          compiledCssPath = null;
+        }
+      } else {
+        compiledCssPath = path4.join(distDir, "styles.css");
+        fs4.copyFileSync(path4.resolve(cssEntryFile), compiledCssPath);
+        console.log(`  Copied: ${cssEntryFile} \u2192 dist/styles.css`);
+      }
+    }
     for (const target of config.targets) {
-      const entryPoint = path3.resolve("src", `${target}.tsx`);
-      if (!fs3.existsSync(entryPoint)) {
+      const entryPoint = path4.resolve("src", `${target}.tsx`);
+      if (!fs4.existsSync(entryPoint)) {
         console.warn(`Warning: Entry point ${entryPoint} not found, skipping target "${target}".`);
         continue;
       }
@@ -478,11 +1024,39 @@ function registerBuild(program2) {
         entryPoints: [entryPoint],
         bundle: true,
         minify: true,
-        format: "esm",
-        outfile: path3.join(distDir, `${target}.js`),
+        format: "iife",
+        globalName: "LumioExtension",
+        footer: {
+          js: "if(typeof LumioExtension!=='undefined'&&typeof LumioExtension.default==='function'){var _L=(typeof require!=='undefined'?require('@zaflun/lumio-sdk'):{}).Lumio;if(_L)_L.render(LumioExtension.default);}"
+        },
+        outdir: distDir,
+        entryNames: `${target}`,
         jsx: "automatic",
         target: "es2022",
-        external: [],
+        loader: {
+          ".css": "css",
+          // Asset file loaders — copies to dist/assets/ with content hash
+          ".png": "file",
+          ".jpg": "file",
+          ".jpeg": "file",
+          ".gif": "file",
+          ".svg": "file",
+          ".webp": "file",
+          ".avif": "file",
+          ".ico": "file",
+          ".mp4": "file",
+          ".webm": "file",
+          ".ogg": "file",
+          ".mp3": "file",
+          ".wav": "file",
+          ".woff": "file",
+          ".woff2": "file",
+          ".ttf": "file",
+          ".otf": "file",
+          ".lottie": "file"
+        },
+        assetNames: "assets/[name]-[hash]",
+        external: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime", "@zaflun/lumio-sdk", "@zaflun/lumio-protocol"],
         define: {
           "process.env.NODE_ENV": '"production"'
         }
@@ -490,19 +1064,23 @@ function registerBuild(program2) {
       console.log(`  Built: dist/${target}.js`);
     }
     const { default: archiver } = await import("archiver");
-    const sourceArchivePath = path3.join(distDir, "source.tar.gz");
-    const output = fs3.createWriteStream(sourceArchivePath);
+    const sourceArchivePath = path4.join(distDir, "source.tar.gz");
+    const output = fs4.createWriteStream(sourceArchivePath);
     const archive = archiver("tar", { gzip: true });
     archive.pipe(output);
-    archive.directory("src/", "src");
-    if (config.server && fs3.existsSync("server")) {
-      archive.directory("server/", "server");
-    }
-    archive.file("lumio.config.json", { name: "lumio.config.json" });
-    archive.file("package.json", { name: "package.json" });
-    if (fs3.existsSync("CHANGELOG.md")) {
-      archive.file("CHANGELOG.md", { name: "CHANGELOG.md" });
-    }
+    archive.glob("**/*", {
+      cwd: path4.resolve("."),
+      ignore: [
+        "node_modules/**",
+        "dist/**",
+        ".git/**",
+        ".next/**",
+        ".lumio-dist/**",
+        "*.tgz",
+        "*.tar.gz"
+      ],
+      dot: true
+    });
     await archive.finalize();
     console.log("  Archive: dist/source.tar.gz");
     console.log("Build complete.");
@@ -510,8 +1088,8 @@ function registerBuild(program2) {
 }
 
 // src/commands/deploy.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 
 // src/changelog/parser.ts
 var VERSION_HEADER_REGEX = /^## \[([^\]]+)\](?:\s*-\s*(\d{4}-\d{2}-\d{2}))?/;
@@ -549,77 +1127,205 @@ function getVersionEntry(changelog, version) {
 }
 
 // src/commands/deploy.ts
+function collectFiles(dir, base = dir) {
+  const entries = fs5.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath, base));
+    } else if (entry.isFile()) {
+      files.push(path5.relative(base, fullPath));
+    }
+  }
+  return files;
+}
+var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([
+  "js",
+  "css",
+  "html",
+  "map",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "svg",
+  "webp",
+  "avif",
+  "ico",
+  "mp4",
+  "webm",
+  "ogg",
+  "mp3",
+  "wav",
+  "m4a",
+  "aac",
+  "flac",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "json",
+  "lottie"
+]);
+var AUDIO_EXTENSIONS = /* @__PURE__ */ new Set(["mp3", "wav", "ogg", "webm", "m4a", "aac", "flac"]);
+var LARGE_SOUND_THRESHOLD = 5 * 1024 * 1024;
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var MAX_TOTAL_SIZE = 50 * 1024 * 1024;
+var MAX_FILES = 200;
 function registerDeploy(program2) {
-  program2.command("deploy").description("Upload extension to Lumio (status: draft)").option("-v, --version <version>", "Version override").option("-d, --description <text>", "Release notes override").option("--breaking", "Mark as breaking change").option("--draft", "Explicitly mark as draft").action(async (options) => {
+  program2.command("deploy").description("Upload extension to Lumio (status: draft)").option("-v, --version <version>", "Version override").option("-d, --description <text>", "Release notes override").option("--breaking", "Mark as breaking change").option("--draft", "Explicitly mark as draft").option("--token <token>", "API token (for CI, skips login)").option("--system", "Deploy as system extension (no developer profile required)").action(async (options) => {
     const store = new CredentialStore();
-    const token = store.getToken();
+    const token = options.token ?? store.getToken();
     if (!token) {
-      console.error("Not logged in. Run `lumio login` first.");
+      console.error("Not logged in. Run `lumio login` or provide --token.");
       process.exit(1);
     }
-    const configPath = path4.resolve("lumio.config.json");
-    if (!fs4.existsSync(configPath)) {
+    const configPath = path5.resolve("lumio.config.json");
+    if (!fs5.existsSync(configPath)) {
       console.error("lumio.config.json not found. Run `lumio init` first.");
       process.exit(1);
     }
-    const configJson = fs4.readFileSync(configPath, "utf-8");
+    const configJson = fs5.readFileSync(configPath, "utf-8");
     const config = parseConfigFile(configJson);
     validateConfig(config);
+    const distDir = path5.resolve("dist");
+    if (config.sounds && config.sounds.length > 0) {
+      for (const sound of config.sounds) {
+        const soundFile = sound.file;
+        const ext = soundFile.split(".").pop()?.toLowerCase() ?? "";
+        if (!AUDIO_EXTENSIONS.has(ext)) {
+          console.error(
+            `Error: Sound file "${soundFile}" has unsupported extension ".${ext}". Allowed audio formats: ${[...AUDIO_EXTENSIONS].join(", ")}.`
+          );
+          process.exit(1);
+        }
+        const soundAbsPath = path5.join(distDir, "sounds", soundFile);
+        if (fs5.existsSync(distDir) && !fs5.existsSync(soundAbsPath)) {
+          console.error(
+            `Error: Sound file "${soundFile}" declared in lumio.config.json was not found at dist/sounds/${soundFile}. Run \`lumio build\` first.`
+          );
+          process.exit(1);
+        }
+        if (fs5.existsSync(soundAbsPath)) {
+          const stat = fs5.statSync(soundAbsPath);
+          if (stat.size > LARGE_SOUND_THRESHOLD) {
+            console.warn(
+              `  Warning: Sound file "${soundFile}" is ${(stat.size / 1024 / 1024).toFixed(1)} MB. Consider compressing large audio files to reduce load times.`
+            );
+          }
+        }
+      }
+    }
     const version = options.version ?? config.version;
     let releaseNotes = options.description ?? "";
     if (!releaseNotes) {
-      const changelogPath = path4.resolve("CHANGELOG.md");
-      if (fs4.existsSync(changelogPath)) {
-        const changelog = fs4.readFileSync(changelogPath, "utf-8");
+      const changelogPath = path5.resolve("CHANGELOG.md");
+      if (fs5.existsSync(changelogPath)) {
+        const changelog = fs5.readFileSync(changelogPath, "utf-8");
         const entry = getVersionEntry(changelog, version);
         if (entry) {
           releaseNotes = entry.content;
-        } else if (!LumioApiClient.isCI()) {
+        } else if (!LumioApiClient.isCI() && !options.system) {
           console.error(`No changelog entry found for version ${version}.`);
           console.error("Add an entry to CHANGELOG.md or use -d to provide release notes.");
           process.exit(1);
         }
       }
     }
-    const distDir = path4.resolve("dist");
-    if (!fs4.existsSync(distDir)) {
+    if (!fs5.existsSync(distDir)) {
       console.error("No dist/ directory found. Run `lumio build` first.");
       process.exit(1);
     }
     console.log(`Deploying ${config.name} v${version}...`);
-    const client = new LumioApiClient(store.getApiUrl(), token);
-    const formData = new FormData();
-    const sourceArchive = path4.join(distDir, "source.tar.gz");
-    if (fs4.existsSync(sourceArchive)) {
-      const sourceBuffer = fs4.readFileSync(sourceArchive);
-      formData.append("source", new Blob([sourceBuffer]), "source.tar.gz");
+    const apiUrl = process.env.LUMIO_API_URL ?? store.getApiUrl();
+    const client = new LumioApiClient(apiUrl, token);
+    const allFiles = collectFiles(distDir);
+    const sourceFile = "source.tar.gz";
+    const bundleFiles = allFiles.filter((f) => {
+      if (f === sourceFile) return false;
+      if (f === "bundle.zip") return false;
+      const ext = f.split(".").pop()?.toLowerCase() ?? "";
+      return ALLOWED_EXTENSIONS.has(ext);
+    });
+    if (bundleFiles.length === 0) {
+      console.error("No uploadable files found in dist/. Run `lumio build` first.");
+      process.exit(1);
+    }
+    if (bundleFiles.length > MAX_FILES) {
+      console.error(`Too many files (${bundleFiles.length}). Maximum is ${MAX_FILES}.`);
+      process.exit(1);
+    }
+    const sourceArchive = path5.join(distDir, sourceFile);
+    if (!fs5.existsSync(sourceArchive)) {
+      console.error("Error: source.tar.gz not found in dist/. Run `lumio build` first.");
+      process.exit(1);
     }
+    const formData = new FormData();
     const manifest = JSON.parse(configJson);
     manifest.version = version;
     formData.append("version", version);
     formData.append("manifest", JSON.stringify(manifest));
     formData.append("release_notes", releaseNotes);
     formData.append("is_breaking", String(!!options.breaking));
+    const sourceBuffer = fs5.readFileSync(sourceArchive);
+    if (sourceBuffer.length === 0) {
+      console.error("Error: source.tar.gz is empty. Run `lumio build` to regenerate.");
+      process.exit(1);
+    }
+    formData.append("source", new Blob([sourceBuffer]), "source.tar.gz");
+    console.log(`  Source: source.tar.gz (${(sourceBuffer.length / 1024).toFixed(1)} KB)`);
+    let totalSize = 0;
+    for (const relPath of bundleFiles) {
+      const absPath = path5.join(distDir, relPath);
+      const buffer = fs5.readFileSync(absPath);
+      if (buffer.length === 0) {
+        console.warn(`  Warning: Skipping empty file: ${relPath}`);
+        continue;
+      }
+      if (buffer.length > MAX_FILE_SIZE) {
+        console.error(`Error: File '${relPath}' exceeds ${MAX_FILE_SIZE / 1024 / 1024} MB limit.`);
+        process.exit(1);
+      }
+      totalSize += buffer.length;
+      if (totalSize > MAX_TOTAL_SIZE) {
+        console.error(`Error: Total bundle size exceeds ${MAX_TOTAL_SIZE / 1024 / 1024} MB limit.`);
+        process.exit(1);
+      }
+      formData.append("files", new Blob([buffer]), relPath);
+      console.log(`  File: ${relPath} (${(buffer.length / 1024).toFixed(1)} KB)`);
+    }
+    console.log(`  Total: ${bundleFiles.length} files (${(totalSize / 1024).toFixed(1)} KB)`);
+    console.log("  Uploading...");
     try {
-      await client.uploadFile(
-        `/v1/developer/extensions/${config.extensionId}/versions`,
-        formData
-      );
-      console.log("Upload successful. Status: draft");
-      console.log("Submit for review via the dashboard or `lumio status`.");
+      const uploadPath = options.system ? `/v1/system/extensions/${config.extensionId}/versions/upload` : `/v1/developer/extensions/${config.extensionId}/versions/upload`;
+      await client.uploadFile(uploadPath, formData);
+      console.log("\n  Upload successful. Status: draft");
+      console.log("  Submit for review via the dashboard or `lumio status`.");
       if (LumioApiClient.isCI()) {
         process.exit(0);
       }
     } catch (err) {
-      console.error("Deploy failed:", err);
+      const status = err.status;
+      const message = err.message ?? String(err);
+      console.error(`
+  Deploy failed${status ? ` (HTTP ${status})` : ""}: ${message}`);
+      if (status === 409) {
+        console.error("  This version already exists. Bump the version in lumio.config.json.");
+      } else if (status === 413) {
+        console.error("  Bundle or source archive exceeds the maximum upload size.");
+      } else if (status === 401 || status === 403) {
+        console.error("  Authentication failed. Run `lumio login` to refresh your token.");
+      }
       process.exit(1);
     }
   });
 }
 
 // src/commands/status.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 function registerStatus(program2) {
   program2.command("status").description("Show review status of the latest version").action(async () => {
     const store = new CredentialStore();
@@ -628,12 +1334,12 @@ function registerStatus(program2) {
       console.error("Not logged in. Run `lumio login` first.");
       process.exit(1);
     }
-    const configPath = path5.resolve("lumio.config.json");
-    if (!fs5.existsSync(configPath)) {
+    const configPath = path6.resolve("lumio.config.json");
+    if (!fs6.existsSync(configPath)) {
       console.error("lumio.config.json not found.");
       process.exit(1);
     }
-    const config = parseConfigFile(fs5.readFileSync(configPath, "utf-8"));
+    const config = parseConfigFile(fs6.readFileSync(configPath, "utf-8"));
     const client = new LumioApiClient(store.getApiUrl(), token);
     try {
       const versions = await client.get(
@@ -662,8 +1368,8 @@ function registerStatus(program2) {
 }
 
 // src/commands/logs.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 function registerLogs(program2) {
   program2.command("logs").description("Stream server function logs via SSE").option("-f, --follow", "Follow log output", true).option("-n, --lines <count>", "Number of recent lines", "50").action(async (options) => {
     const store = new CredentialStore();
@@ -672,12 +1378,12 @@ function registerLogs(program2) {
       console.error("Not logged in. Run `lumio login` first.");
       process.exit(1);
     }
-    const configPath = path6.resolve("lumio.config.json");
-    if (!fs6.existsSync(configPath)) {
+    const configPath = path7.resolve("lumio.config.json");
+    if (!fs7.existsSync(configPath)) {
       console.error("lumio.config.json not found.");
       process.exit(1);
     }
-    const config = parseConfigFile(fs6.readFileSync(configPath, "utf-8"));
+    const config = parseConfigFile(fs7.readFileSync(configPath, "utf-8"));
     const apiUrl = store.getApiUrl();
     const logsUrl = `${apiUrl}/v1/developer/extensions/${config.extensionId}/logs?lines=${options.lines}`;
     console.log(`Streaming logs for ${config.name}...`);
@@ -714,8 +1420,8 @@ function registerLogs(program2) {
 }
 
 // src/commands/env.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 function validateSecretKey(key) {
   return key.length > 0 && /^[A-Z0-9_]+$/.test(key);
 }
@@ -724,12 +1430,12 @@ function formatSecretList(secrets) {
   return secrets.map((s) => `  ${s.key}  (created ${s.created_at})`).join("\n");
 }
 function loadConfig() {
-  const configPath = path7.resolve("lumio.config.json");
-  if (!fs7.existsSync(configPath)) {
+  const configPath = path8.resolve("lumio.config.json");
+  if (!fs8.existsSync(configPath)) {
     console.error("lumio.config.json not found. Run `lumio init` first.");
     process.exit(1);
   }
-  return parseConfigFile(fs7.readFileSync(configPath, "utf-8"));
+  return parseConfigFile(fs8.readFileSync(configPath, "utf-8"));
 }
 function requireClient() {
   const store = new CredentialStore();
@@ -771,8 +1477,27 @@ function registerEnv(program2) {
 }
 
 // src/commands/run.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
+var VALID_FUNCTION_TYPES = [
+  "query",
+  "mutation",
+  "action",
+  "command",
+  "keyword",
+  "pattern",
+  "event",
+  "timer",
+  "moderate"
+];
+var BOT_HANDLER_TYPES = [
+  "command",
+  "keyword",
+  "pattern",
+  "event",
+  "timer",
+  "moderate"
+];
 function parseFunctionRef(ref) {
   const colonIndex = ref.indexOf(":");
   if (colonIndex === -1) {
@@ -780,20 +1505,22 @@ function parseFunctionRef(ref) {
   }
   const type = ref.slice(0, colonIndex);
   const name = ref.slice(colonIndex + 1);
-  if (!["query", "mutation", "action"].includes(type)) {
-    throw new Error(`Function type must be query, mutation, or action. Got: "${type}"`);
+  if (!VALID_FUNCTION_TYPES.includes(type)) {
+    throw new Error(
+      `Function type must be one of: ${VALID_FUNCTION_TYPES.join(", ")}. Got: "${type}"`
+    );
   }
   return { type, name };
 }
 function registerRun(program2) {
-  program2.command("run <type:name> [args]").description("Execute a server function locally (e.g. lumio run query:getPlayers)").action(async (typeAndName, argsJson) => {
+  program2.command("run <type:name> [args]").description("Execute a server function locally (e.g. lumio run query:getPlayers)").option("--user <name>", "Mock user name for bot handlers", "testuser").option("--role <role>", "Mock user role for bot handlers", "everyone").option("--message <text>", "Mock chat message for bot handlers").option("--platform <platform>", "Mock platform for bot handlers", "twitch").action(async (typeAndName, argsJson, options) => {
     const fnRef = parseFunctionRef(typeAndName);
-    const configPath = path8.resolve("lumio.config.json");
-    if (!fs8.existsSync(configPath)) {
+    const configPath = path9.resolve("lumio.config.json");
+    if (!fs9.existsSync(configPath)) {
       console.error("lumio.config.json not found. Run `lumio init` first.");
       process.exit(1);
     }
-    const config = parseConfigFile(fs8.readFileSync(configPath, "utf-8"));
+    const config = parseConfigFile(fs9.readFileSync(configPath, "utf-8"));
     const store = new CredentialStore();
     const token = store.getToken();
     if (!token) {
@@ -802,10 +1529,26 @@ function registerRun(program2) {
     }
     const client = new LumioApiClient(store.getApiUrl(), token);
     const args = argsJson ? JSON.parse(argsJson) : {};
+    const body = { type: fnRef.type, args };
+    if (BOT_HANDLER_TYPES.includes(fnRef.type)) {
+      body.user = {
+        id: "test-user-001",
+        name: options.user,
+        displayName: options.user,
+        platform: options.platform,
+        role: options.role,
+        isMod: options.role === "moderator",
+        isVip: options.role === "vip",
+        isSub: ["subscriber", "vip", "moderator", "broadcaster"].includes(options.role)
+      };
+      if (options.message) {
+        body.message = { text: options.message, platformMessageId: "test-msg-001" };
+      }
+    }
     try {
       const result = await client.post(
         `/v1/extension-installs/${config.extensionId}/execute/${fnRef.name}`,
-        { type: fnRef.type, args }
+        body
       );
       console.log(JSON.stringify(result, null, 2));
     } catch (err) {
@@ -816,16 +1559,16 @@ function registerRun(program2) {
 }
 
 // src/commands/dashboard.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 function registerDashboard(program2) {
   program2.command("dashboard").description("Open the extension dashboard in browser").action(async () => {
-    const configPath = path9.resolve("lumio.config.json");
-    if (!fs9.existsSync(configPath)) {
+    const configPath = path10.resolve("lumio.config.json");
+    if (!fs10.existsSync(configPath)) {
       console.error("lumio.config.json not found. Run `lumio init` first.");
       process.exit(1);
     }
-    const config = parseConfigFile(fs9.readFileSync(configPath, "utf-8"));
+    const config = parseConfigFile(fs10.readFileSync(configPath, "utf-8"));
     const baseUrl = process.env.LUMIO_WEB_URL ?? "https://lumio.vision";
     const url = `${baseUrl}/dashboard/extensions/${config.extensionId}`;
     console.log(`Opening ${url}...`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaflun/lumio-cli",
-  "version": "0.2.0",
+  "version": "0.5.2",
   "description": "Lumio Extension CLI — Build, test, and deploy Lumio extensions",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "inquirer": "^12.6.0",
     "open": "^10.1.2",
     "ora": "^8.2.0",
-    "@zaflun/lumio-extension-types": "0.1.0"
+    "@zaflun/lumio-extension-types": "0.3.2"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",