@zaflun/lumio-cli 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,6 +1,10 @@
 // src/program.ts
 import { Command } from "commander";
 
+// src/commands/login.ts
+import * as http from "http";
+import * as crypto from "crypto";
+
 // src/auth/credential-store.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -54,6 +58,11 @@ var CredentialStore = class {
 };
 
 // src/commands/login.ts
+function generatePkceChallenge() {
+  const verifier = crypto.randomBytes(32).toString("base64url");
+  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
 function registerLogin(program2) {
   program2.command("login").description("Authenticate with Lumio via browser (PKCE) or token").option("--token <token>", "Authenticate with an API token (for CI/CD)").option("--api-url <url>", "Custom API URL", "https://api.lumio.vision").action(async (options) => {
     const store = new CredentialStore();
@@ -62,12 +71,69 @@ function registerLogin(program2) {
       console.log("Authenticated with token.");
       return;
     }
-    console.log("Opening browser for authentication...");
-    const { default: open } = await import("open");
-    const pkceUrl = `${options.apiUrl}/v1/auth/cli/authorize`;
-    await open(pkceUrl);
-    console.log("Waiting for authentication callback...");
-    console.log("If the browser did not open, visit:", pkceUrl);
+    const { verifier, challenge } = generatePkceChallenge();
+    const state = crypto.randomBytes(16).toString("hex");
+    const port = 9876;
+    const redirectUri = `http://localhost:${port}/callback`;
+    await new Promise((resolve10, reject) => {
+      const server = http.createServer(async (req, res) => {
+        if (!req.url?.startsWith("/callback")) {
+          res.writeHead(404);
+          res.end();
+          return;
+        }
+        const url = new URL(req.url, `http://localhost:${port}`);
+        const code = url.searchParams.get("code");
+        const returnedState = url.searchParams.get("state");
+        if (returnedState !== state || !code) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end("<html><body><h2>Authentication failed.</h2><p>Invalid state or missing code. You can close this window.</p></body></html>");
+          server.close();
+          reject(new Error("Authentication failed: invalid state or missing code"));
+          return;
+        }
+        try {
+          const tokenRes = await fetch(`${options.apiUrl}/v1/auth/cli/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              grant_type: "authorization_code",
+              code,
+              redirect_uri: redirectUri,
+              code_verifier: verifier
+            })
+          });
+          if (!tokenRes.ok) {
+            throw new Error(`Token exchange failed: ${tokenRes.status}`);
+          }
+          const tokenData = await tokenRes.json();
+          store.saveToken(tokenData.access_token, options.apiUrl);
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end("<html><body><h2>Authenticated!</h2><p>You can close this window and return to the CLI.</p></body></html>");
+        } catch (e) {
+          res.writeHead(500, { "Content-Type": "text/html" });
+          res.end("<html><body><h2>Authentication failed.</h2><p>Token exchange error. You can close this window.</p></body></html>");
+          server.close();
+          reject(e);
+          return;
+        }
+        server.close();
+        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}`;
+        console.log("Opening browser for authentication...");
+        const { default: open } = await import("open");
+        await open(pkceUrl);
+        console.log("Waiting for authentication callback...");
+        console.log("If the browser did not open, visit:", pkceUrl);
+      });
+      setTimeout(() => {
+        server.close();
+        reject(new Error("Authentication timed out after 120 seconds"));
+      }, 12e4);
+    });
+    console.log("Authenticated successfully.");
   });
 }
 
@@ -222,7 +288,7 @@ 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:" },
       {
@@ -230,16 +296,35 @@ function registerInit(program2) {
         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 }
+      }
     ]);
+    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 {
+      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;
+    }
     const createBody = {
       name: answers.name,
       description: answers.description,
@@ -253,7 +338,7 @@ function registerInit(program2) {
     const projectDir = path2.resolve(answers.name.toLowerCase().replace(/\s+/g, "-"));
     fs2.mkdirSync(projectDir, { recursive: true });
     const config = {
-      $schema: "https://docs.lumio.vision/schemas/lumio.config.schema.json",
+      $schema: "https://lumio.vision/schemas/lumio.config.schema.json",
       extensionId: extension.id,
       name: answers.name,
       description: answers.description,
@@ -261,11 +346,21 @@ 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 (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: []
+      };
+    }
     fs2.writeFileSync(
       path2.join(projectDir, "lumio.config.json"),
       JSON.stringify(config, null, 2)
@@ -298,8 +393,15 @@ 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 (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 {
+      for (const target of answers.targets) {
+        const content = `import { Lumio, CompactView, Text } from "@zaflun/lumio-sdk";
 
 function App() {
   return (
@@ -311,14 +413,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}/`);
@@ -327,17 +430,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";
 
@@ -363,6 +455,8 @@ function parseConfigFile(jsonString) {
       allowHosts: raw.egress?.allowHosts ?? [],
       allowPorts: raw.egress?.allowPorts ?? []
     },
+    platforms: raw.platforms,
+    triggers: raw.triggers,
     fonts: raw.fonts,
     visibility: raw.visibility ?? "private",
     pricing: raw.pricing ?? { type: "free" }
@@ -375,7 +469,11 @@ 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.targets || config.targets.length === 0) {
     throw new ConfigError("At least one target is required (editor, layer, or interactive)");
   }
   if (!config.version) {
@@ -383,28 +481,130 @@ 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.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) => {
+    const configPath = path3.resolve("lumio.config.json");
+    if (options.botModule || 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;
+        }
+      } else if (options.botModule) {
+        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";
 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.");
+    }
     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;
       }
@@ -413,7 +613,7 @@ function registerBuild(program2) {
         bundle: true,
         minify: true,
         format: "esm",
-        outfile: path3.join(distDir, `${target}.js`),
+        outfile: path4.join(distDir, `${target}.js`),
         jsx: "automatic",
         target: "es2022",
         external: [],
@@ -424,17 +624,17 @@ 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")) {
+    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 (fs3.existsSync("CHANGELOG.md")) {
+    if (fs4.existsSync("CHANGELOG.md")) {
       archive.file("CHANGELOG.md", { name: "CHANGELOG.md" });
     }
     await archive.finalize();
@@ -444,8 +644,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}))?/;
@@ -491,20 +691,20 @@ function registerDeploy(program2) {
       console.error("Not logged in. Run `lumio login` first.");
       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 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;
@@ -515,21 +715,23 @@ function registerDeploy(program2) {
         }
       }
     }
-    const distDir = path4.resolve("dist");
-    if (!fs4.existsSync(distDir)) {
+    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 = path4.join(distDir, "source.tar.gz");
-    if (fs4.existsSync(sourceArchive)) {
-      const sourceBuffer = fs4.readFileSync(sourceArchive);
+    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 manifest = JSON.parse(configJson);
+    manifest.version = version;
     formData.append("version", version);
-    formData.append("manifest", configJson);
+    formData.append("manifest", JSON.stringify(manifest));
     formData.append("release_notes", releaseNotes);
     formData.append("is_breaking", String(!!options.breaking));
     try {
@@ -550,8 +752,8 @@ function registerDeploy(program2) {
 }
 
 // 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();
@@ -560,12 +762,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(
@@ -594,8 +796,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();
@@ -604,12 +806,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}...`);
@@ -646,8 +848,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);
 }
@@ -656,12 +858,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();
@@ -703,8 +905,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) {
@@ -712,20 +933,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) {
@@ -734,10 +957,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) {
@@ -748,16 +987,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.1.0",
+  "version": "0.3.0",
   "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.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",