@zaflun/lumio-cli 0.3.0 → 0.5.2

package/dist/index.js

@@ -295,7 +295,7 @@ function registerInit(program2) {
         type: "list",
         name: "category",
         message: "Category:",
-        choices: ["widget", "extension", "overlay", "bot_module", "integration", "theme"]
+        choices: ["widget", "extension", "overlay", "bot_module", "integration", "theme", "automation_node"]
       }
     ]);
     const answers = { ...baseAnswers, targets: [], server: false };
@@ -311,6 +311,39 @@ function registerInit(program2) {
       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([
         {
@@ -325,6 +358,66 @@ function registerInit(program2) {
       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,
@@ -351,6 +444,23 @@ function registerInit(program2) {
       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 = {
@@ -361,29 +471,88 @@ function registerInit(program2) {
         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]}
@@ -393,15 +562,83 @@ function registerInit(program2) {
 `;
     fs2.writeFileSync(path2.join(projectDir, "CHANGELOG.md"), changelog);
     fs2.mkdirSync(path2.join(projectDir, "src"), { recursive: true });
+    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) {
-        const content = `import { Lumio, CompactView, Text } from "@zaflun/lumio-sdk";
+        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 (
@@ -443,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",
@@ -458,8 +695,18 @@ function parseConfigFile(jsonString) {
     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) {
@@ -473,6 +720,27 @@ function validateConfig(config) {
     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)");
   }
@@ -553,11 +821,120 @@ async function runBotModuleDevServer(config) {
   });
 }
 
+// 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").action(async (options) => {
+  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 || fs3.existsSync(configPath)) {
+    if (options.botModule || options.automationNode || fs3.existsSync(configPath)) {
       const configExists = fs3.existsSync(configPath);
       if (configExists) {
         const config = parseConfigFile(fs3.readFileSync(configPath, "utf-8"));
@@ -565,7 +942,11 @@ function registerDev(program2) {
           await runBotModuleDevServer(config);
           return;
         }
-      } else if (options.botModule) {
+        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);
       }
@@ -581,6 +962,9 @@ function registerDev(program2) {
 // 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 = path4.resolve("lumio.config.json");
@@ -602,6 +986,34 @@ function registerBuild(program2) {
     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 = path4.resolve("src", `${target}.tsx`);
       if (!fs4.existsSync(entryPoint)) {
@@ -612,11 +1024,39 @@ function registerBuild(program2) {
         entryPoints: [entryPoint],
         bundle: true,
         minify: true,
-        format: "esm",
-        outfile: path4.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"'
         }
@@ -628,15 +1068,19 @@ function registerBuild(program2) {
     const output = fs4.createWriteStream(sourceArchivePath);
     const archive = archiver("tar", { gzip: true });
     archive.pipe(output);
-    archive.directory("src/", "src");
-    if ((config.server || config.category === "bot_module") && fs4.existsSync("server")) {
-      archive.directory("server/", "server");
-    }
-    archive.file("lumio.config.json", { name: "lumio.config.json" });
-    archive.file("package.json", { name: "package.json" });
-    if (fs4.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.");
@@ -683,12 +1127,59 @@ 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 = path5.resolve("lumio.config.json");
@@ -699,6 +1190,34 @@ function registerDeploy(program2) {
     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) {
@@ -708,44 +1227,97 @@ function registerDeploy(program2) {
         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 = path5.resolve("dist");
     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 = path5.join(distDir, "source.tar.gz");
-    if (fs5.existsSync(sourceArchive)) {
-      const sourceBuffer = fs5.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);
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaflun/lumio-cli",
-  "version": "0.3.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.3.0"
+    "@zaflun/lumio-extension-types": "0.3.2"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",