@zaflun/lumio-cli 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zaflun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# @zaflun/lumio-cli
+
+The official CLI for building, testing, and deploying [Lumio](https://lumio.vision) extensions.
+
+## Installation
+
+```bash
+npm install -g @zaflun/lumio-cli
+```
+
+## Quick Start
+
+```bash
+# Log in to Lumio
+lumio login
+
+# Create a new extension
+lumio init my-widget
+
+# Start development
+cd my-widget
+npm install
+lumio dev
+
+# Build and deploy
+lumio build
+lumio deploy -v 1.0.0
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `lumio login` | Authenticate via browser (PKCE) or token (`--token`) |
+| `lumio logout` | Remove local credentials |
+| `lumio whoami` | Show current user and account |
+| `lumio init [name]` | Create a new extension project (interactive wizard) |
+| `lumio dev` | Start local dev server with hot-reload |
+| `lumio build` | Bundle extension for deployment |
+| `lumio deploy` | Upload extension version (flags: `-v`, `-d`, `--breaking`, `--draft`) |
+| `lumio env set <KEY> <VALUE>` | Set a server-side secret |
+| `lumio env list` | List secret keys |
+| `lumio env delete <KEY>` | Delete a secret |
+| `lumio run <type:name>` | Execute a server function locally |
+| `lumio status` | Show review status of latest version |
+| `lumio logs` | Stream server function logs |
+| `lumio dashboard` | Open extension dashboard in browser |
+
+## CI/CD
+
+```bash
+# Token-based login for CI
+lumio login --token $LUMIO_API_TOKEN
+
+# Deploy in CI
+lumio deploy -v $VERSION -d "Automated release"
+```
+
+## Team Support
+
+When you have developer teams, `lumio init` asks who owns the extension:
+
+```
+? Who owns this extension?
+  ❯ Personal (Solo Developer)
+    Team: Zaflun GmbH
+```
+
+## Documentation
+
+- [CLI Reference](https://developers.lumio.vision/cli/install)
+- [Publishing Guide](https://developers.lumio.vision/publishing/submission-wizard)
+- [Full Docs](https://developers.lumio.vision)
+
+## License
+
+MIT © [zaflun](https://withzaflun.com)

package/bin/lumio.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+
+declare function createProgram(): Command;
+
+declare class CredentialStore {
+    readonly credentialsPath: string;
+    constructor();
+    getToken(): string | null;
+    getApiUrl(): string;
+    isAuthenticated(): boolean;
+    saveToken(token: string, apiUrl?: string): void;
+    clear(): void;
+    private readCredentials;
+}
+
+declare class LumioApiClient {
+    readonly baseUrl: string;
+    private readonly token;
+    constructor(baseUrl: string, token: string);
+    url(endpoint: string): string;
+    authHeaders(): Record<string, string>;
+    uploadHeaders(): Record<string, string>;
+    get<T>(endpoint: string): Promise<T>;
+    post<T>(endpoint: string, body?: unknown): Promise<T>;
+    put<T>(endpoint: string, body?: unknown): Promise<T>;
+    delete<T>(endpoint: string): Promise<T>;
+    uploadFile(endpoint: string, formData: FormData): Promise<unknown>;
+    static isCI(): boolean;
+}
+
+export { CredentialStore, LumioApiClient, createProgram };

package/dist/index.js

@@ -0,0 +1,800 @@
+// src/program.ts
+import { Command } from "commander";
+
+// src/auth/credential-store.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var DEFAULT_API_URL = "https://api.lumio.vision";
+var CredentialStore = class {
+  credentialsPath;
+  constructor() {
+    this.credentialsPath = path.join(os.homedir(), ".lumio", "credentials");
+  }
+  getToken() {
+    const creds = this.readCredentials();
+    return creds?.token ?? null;
+  }
+  getApiUrl() {
+    const creds = this.readCredentials();
+    return creds?.api_url ?? DEFAULT_API_URL;
+  }
+  isAuthenticated() {
+    return this.getToken() !== null;
+  }
+  saveToken(token, apiUrl) {
+    const dir = path.dirname(this.credentialsPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const credentials = {
+      token,
+      api_url: apiUrl ?? DEFAULT_API_URL
+    };
+    fs.writeFileSync(
+      this.credentialsPath,
+      JSON.stringify(credentials, null, 2),
+      { mode: 384 }
+    );
+  }
+  clear() {
+    if (fs.existsSync(this.credentialsPath)) {
+      fs.unlinkSync(this.credentialsPath);
+    }
+  }
+  readCredentials() {
+    if (!fs.existsSync(this.credentialsPath)) {
+      return null;
+    }
+    try {
+      const content = fs.readFileSync(this.credentialsPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/commands/login.ts
+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();
+    if (options.token) {
+      store.saveToken(options.token, options.apiUrl);
+      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);
+  });
+}
+
+// src/commands/logout.ts
+function registerLogout(program2) {
+  program2.command("logout").description("Remove local auth credentials").action(() => {
+    const store = new CredentialStore();
+    if (!store.isAuthenticated()) {
+      console.log("Not logged in.");
+      return;
+    }
+    store.clear();
+    console.log("Logged out. Credentials removed.");
+  });
+}
+
+// src/api/client.ts
+var LumioApiClient = class {
+  baseUrl;
+  token;
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.token = token;
+  }
+  url(endpoint) {
+    return `${this.baseUrl}${endpoint}`;
+  }
+  authHeaders() {
+    return {
+      "Authorization": `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  uploadHeaders() {
+    return {
+      "Authorization": `Bearer ${this.token}`
+    };
+  }
+  async get(endpoint) {
+    const response = await fetch(this.url(endpoint), {
+      method: "GET",
+      headers: this.authHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`API error ${response.status}: ${await response.text()}`);
+    }
+    return response.json();
+  }
+  async post(endpoint, body) {
+    const response = await fetch(this.url(endpoint), {
+      method: "POST",
+      headers: this.authHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      throw new Error(`API error ${response.status}: ${await response.text()}`);
+    }
+    return response.json();
+  }
+  async put(endpoint, body) {
+    const response = await fetch(this.url(endpoint), {
+      method: "PUT",
+      headers: this.authHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      throw new Error(`API error ${response.status}: ${await response.text()}`);
+    }
+    return response.json();
+  }
+  async delete(endpoint) {
+    const response = await fetch(this.url(endpoint), {
+      method: "DELETE",
+      headers: this.authHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`API error ${response.status}: ${await response.text()}`);
+    }
+    return response.json();
+  }
+  async uploadFile(endpoint, formData) {
+    const response = await fetch(this.url(endpoint), {
+      method: "POST",
+      headers: this.uploadHeaders(),
+      body: formData
+    });
+    if (!response.ok) {
+      throw new Error(`Upload error ${response.status}: ${await response.text()}`);
+    }
+    return response.json();
+  }
+  static isCI() {
+    return process.env.CI === "true" || process.env.CI === "1" || !!process.env.GITHUB_ACTIONS;
+  }
+};
+
+// src/commands/whoami.ts
+function registerWhoami(program2) {
+  program2.command("whoami").description("Show current authenticated user and account").action(async () => {
+    const store = new CredentialStore();
+    const token = store.getToken();
+    if (!token) {
+      console.error("Not logged in. Run `lumio login` first.");
+      process.exit(1);
+    }
+    const client = new LumioApiClient(store.getApiUrl(), token);
+    try {
+      const me = await client.get("/v1/users/me");
+      console.log(`User: ${me.email}`);
+      console.log(`Account: ${me.account_name}`);
+      console.log(`API: ${store.getApiUrl()}`);
+    } catch (err) {
+      console.error("Failed to fetch user info:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/init.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function registerInit(program2) {
+  program2.command("init").argument("[name]", "Extension project name").description("Create a new extension project with interactive wizard").action(async (name) => {
+    const store = new CredentialStore();
+    const token = store.getToken();
+    if (!token) {
+      console.error("Not logged in. Run `lumio login` first.");
+      process.exit(1);
+    }
+    const { default: inquirer } = await import("inquirer");
+    const client = new LumioApiClient(store.getApiUrl(), token);
+    let ownerType = "developer";
+    let teamId = null;
+    try {
+      const teams = await client.get("/v1/developer/teams");
+      if (teams.data.length > 0) {
+        const ownerChoice = await inquirer.prompt([
+          {
+            type: "list",
+            name: "owner",
+            message: "Who owns this extension?",
+            choices: [
+              { name: "Personal (Solo Developer)", value: "developer" },
+              ...teams.data.map((t) => ({ name: `Team: ${t.name}`, value: `team:${t.id}` }))
+            ]
+          }
+        ]);
+        if (ownerChoice.owner.startsWith("team:")) {
+          ownerType = "team";
+          teamId = ownerChoice.owner.replace("team:", "");
+        }
+      }
+    } catch {
+    }
+    const answers = 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 }
+    ]);
+    const createBody = {
+      name: answers.name,
+      description: answers.description,
+      category: answers.category
+    };
+    if (ownerType === "team" && teamId) {
+      createBody.team_id = teamId;
+    }
+    const extension = await client.post("/v1/developer/extensions", createBody);
+    console.log(`Extension ID: ${extension.id}`);
+    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",
+      extensionId: extension.id,
+      name: answers.name,
+      description: answers.description,
+      category: answers.category,
+      version: "0.1.0",
+      targets: answers.targets,
+      server: answers.server,
+      permissions: [],
+      egress: { allowHosts: [], allowPorts: [443] },
+      visibility: "private",
+      pricing: { type: "free" }
+    };
+    fs2.writeFileSync(
+      path2.join(projectDir, "lumio.config.json"),
+      JSON.stringify(config, null, 2)
+    );
+    const pkg = {
+      name: answers.name.toLowerCase().replace(/\s+/g, "-"),
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      dependencies: {
+        "@zaflun/lumio-sdk": "latest",
+        "react": "^19.1.0",
+        "react-dom": "^19.1.0"
+      },
+      devDependencies: {
+        "typescript": "^5.8.3",
+        "@types/react": "^19.1.0"
+      }
+    };
+    fs2.writeFileSync(
+      path2.join(projectDir, "package.json"),
+      JSON.stringify(pkg, null, 2)
+    );
+    const changelog = `# Changelog
+
+## [0.1.0] - ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+
+### Added
+- Initial release
+`;
+    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";
+
+function App() {
+  return (
+    <CompactView title="${answers.name}">
+      <Text content="Hello from ${target}!" />
+    </CompactView>
+  );
+}
+
+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);
+    }
+    console.log(`
+Done! Created ${projectDir}/`);
+    console.log("Run `lumio dev` to start developing.");
+  });
+}
+
+// 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";
+
+// src/config/parser.ts
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function parseConfigFile(jsonString) {
+  const raw = JSON.parse(jsonString);
+  return {
+    extensionId: raw.extensionId ?? "",
+    name: raw.name ?? "",
+    description: raw.description,
+    category: raw.category ?? "widget",
+    version: raw.version ?? "0.1.0",
+    targets: raw.targets ?? ["editor"],
+    server: raw.server ?? false,
+    permissions: raw.permissions ?? [],
+    egress: {
+      allowHosts: raw.egress?.allowHosts ?? [],
+      allowPorts: raw.egress?.allowPorts ?? []
+    },
+    fonts: raw.fonts,
+    visibility: raw.visibility ?? "private",
+    pricing: raw.pricing ?? { type: "free" }
+  };
+}
+function validateConfig(config) {
+  if (!config.extensionId) {
+    throw new ConfigError("extensionId is required. Run `lumio init` or create an extension at the dashboard.");
+  }
+  if (!config.name) {
+    throw new ConfigError("name is required in lumio.config.json");
+  }
+  if (!config.targets || config.targets.length === 0) {
+    throw new ConfigError("At least one target is required (editor, layer, or interactive)");
+  }
+  if (!config.version) {
+    throw new ConfigError("version is required in lumio.config.json");
+  }
+}
+
+// src/commands/build.ts
+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)) {
+      console.error("lumio.config.json not found. Run `lumio init` first.");
+      process.exit(1);
+    }
+    const configJson = fs3.readFileSync(configPath, "utf-8");
+    const config = parseConfigFile(configJson);
+    validateConfig(config);
+    const changelogPath = path3.resolve("CHANGELOG.md");
+    if (!fs3.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 { build } = await import("esbuild");
+    for (const target of config.targets) {
+      const entryPoint = path3.resolve("src", `${target}.tsx`);
+      if (!fs3.existsSync(entryPoint)) {
+        console.warn(`Warning: Entry point ${entryPoint} not found, skipping target "${target}".`);
+        continue;
+      }
+      await build({
+        entryPoints: [entryPoint],
+        bundle: true,
+        minify: true,
+        format: "esm",
+        outfile: path3.join(distDir, `${target}.js`),
+        jsx: "automatic",
+        target: "es2022",
+        external: [],
+        define: {
+          "process.env.NODE_ENV": '"production"'
+        }
+      });
+      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 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" });
+    }
+    await archive.finalize();
+    console.log("  Archive: dist/source.tar.gz");
+    console.log("Build complete.");
+  });
+}
+
+// src/commands/deploy.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+
+// src/changelog/parser.ts
+var VERSION_HEADER_REGEX = /^## \[([^\]]+)\](?:\s*-\s*(\d{4}-\d{2}-\d{2}))?/;
+function parseChangelog(markdown) {
+  const lines = markdown.split("\n");
+  const entries = [];
+  let currentEntry = null;
+  const contentLines = [];
+  for (const line of lines) {
+    const match = line.match(VERSION_HEADER_REGEX);
+    if (match) {
+      if (currentEntry) {
+        currentEntry.content = contentLines.join("\n").trim();
+        entries.push(currentEntry);
+        contentLines.length = 0;
+      }
+      currentEntry = {
+        version: match[1],
+        date: match[2] ?? null,
+        content: ""
+      };
+    } else if (currentEntry) {
+      contentLines.push(line);
+    }
+  }
+  if (currentEntry) {
+    currentEntry.content = contentLines.join("\n").trim();
+    entries.push(currentEntry);
+  }
+  return entries;
+}
+function getVersionEntry(changelog, version) {
+  const entries = parseChangelog(changelog);
+  return entries.find((e) => e.version === version) ?? null;
+}
+
+// src/commands/deploy.ts
+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) => {
+    const store = new CredentialStore();
+    const token = store.getToken();
+    if (!token) {
+      console.error("Not logged in. Run `lumio login` first.");
+      process.exit(1);
+    }
+    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 = fs4.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 entry = getVersionEntry(changelog, version);
+        if (entry) {
+          releaseNotes = entry.content;
+        } else if (!LumioApiClient.isCI()) {
+          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)) {
+      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");
+    }
+    formData.append("version", version);
+    formData.append("manifest", configJson);
+    formData.append("release_notes", releaseNotes);
+    formData.append("is_breaking", String(!!options.breaking));
+    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`.");
+      if (LumioApiClient.isCI()) {
+        process.exit(0);
+      }
+    } catch (err) {
+      console.error("Deploy failed:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/status.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+function registerStatus(program2) {
+  program2.command("status").description("Show review status of the latest version").action(async () => {
+    const store = new CredentialStore();
+    const token = store.getToken();
+    if (!token) {
+      console.error("Not logged in. Run `lumio login` first.");
+      process.exit(1);
+    }
+    const configPath = path5.resolve("lumio.config.json");
+    if (!fs5.existsSync(configPath)) {
+      console.error("lumio.config.json not found.");
+      process.exit(1);
+    }
+    const config = parseConfigFile(fs5.readFileSync(configPath, "utf-8"));
+    const client = new LumioApiClient(store.getApiUrl(), token);
+    try {
+      const versions = await client.get(
+        `/v1/developer/extensions/${config.extensionId}/versions`
+      );
+      if (versions.length === 0) {
+        console.log("No versions deployed yet.");
+        return;
+      }
+      const latest = versions[0];
+      console.log(`Extension: ${config.name}`);
+      console.log(`Version: ${latest.version}`);
+      console.log(`Status: ${latest.status}`);
+      console.log(`Uploaded: ${latest.created_at}`);
+      if (latest.reviewed_at) {
+        console.log(`Reviewed: ${latest.reviewed_at}`);
+      }
+      if (latest.review_notes) {
+        console.log(`Notes: ${latest.review_notes}`);
+      }
+    } catch (err) {
+      console.error("Failed to fetch status:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/logs.ts
+import * as fs6 from "fs";
+import * as path6 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();
+    const token = store.getToken();
+    if (!token) {
+      console.error("Not logged in. Run `lumio login` first.");
+      process.exit(1);
+    }
+    const configPath = path6.resolve("lumio.config.json");
+    if (!fs6.existsSync(configPath)) {
+      console.error("lumio.config.json not found.");
+      process.exit(1);
+    }
+    const config = parseConfigFile(fs6.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}...`);
+    console.log("Press Ctrl+C to stop.\n");
+    try {
+      const eventsource = await import("eventsource");
+      const EventSource = "default" in eventsource ? eventsource.default : eventsource;
+      const es = new EventSource(logsUrl, {
+        headers: { "Authorization": `Bearer ${token}` }
+      });
+      es.onmessage = (event) => {
+        try {
+          const log = JSON.parse(event.data);
+          const timestamp = new Date(log.timestamp).toISOString();
+          const level = log.level?.toUpperCase() ?? "INFO";
+          console.log(`[${timestamp}] ${level}: ${log.message}`);
+        } catch {
+          console.log(event.data);
+        }
+      };
+      es.onerror = () => {
+        console.error("Connection lost. Reconnecting...");
+      };
+      process.on("SIGINT", () => {
+        es.close();
+        console.log("\nLog streaming stopped.");
+        process.exit(0);
+      });
+    } catch (err) {
+      console.error("Failed to connect to log stream:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/env.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+function validateSecretKey(key) {
+  return key.length > 0 && /^[A-Z0-9_]+$/.test(key);
+}
+function formatSecretList(secrets) {
+  if (secrets.length === 0) return "No secrets configured.";
+  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)) {
+    console.error("lumio.config.json not found. Run `lumio init` first.");
+    process.exit(1);
+  }
+  return parseConfigFile(fs7.readFileSync(configPath, "utf-8"));
+}
+function requireClient() {
+  const store = new CredentialStore();
+  const token = store.getToken();
+  if (!token) {
+    console.error("Not logged in. Run `lumio login` first.");
+    process.exit(1);
+  }
+  return new LumioApiClient(store.getApiUrl(), token);
+}
+function registerEnv(program2) {
+  const envCmd = program2.command("env").description("Manage server-side secrets for the extension");
+  envCmd.command("set <key> <value>").description("Set a secret (POST /v1/developer/extensions/{id}/secrets)").action(async (key, value) => {
+    if (!validateSecretKey(key)) {
+      console.error(
+        "Invalid key format. Use uppercase letters, numbers, and underscores only (e.g. API_KEY)."
+      );
+      process.exit(1);
+    }
+    const config = loadConfig();
+    const client = requireClient();
+    await client.post(`/v1/developer/extensions/${config.extensionId}/secrets`, { key, value });
+    console.log(`Secret ${key} set.`);
+  });
+  envCmd.command("list").description("List all secrets (keys only, no values)").action(async () => {
+    const config = loadConfig();
+    const client = requireClient();
+    const secrets = await client.get(
+      `/v1/developer/extensions/${config.extensionId}/secrets`
+    );
+    console.log(formatSecretList(secrets));
+  });
+  envCmd.command("delete <key>").description("Delete a secret").action(async (key) => {
+    const config = loadConfig();
+    const client = requireClient();
+    await client.delete(`/v1/developer/extensions/${config.extensionId}/secrets/${key}`);
+    console.log(`Secret ${key} deleted.`);
+  });
+}
+
+// src/commands/run.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
+function parseFunctionRef(ref) {
+  const colonIndex = ref.indexOf(":");
+  if (colonIndex === -1) {
+    throw new Error("Invalid function reference. Use format: query:functionName");
+  }
+  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}"`);
+  }
+  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) => {
+    const fnRef = parseFunctionRef(typeAndName);
+    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);
+    }
+    const config = parseConfigFile(fs8.readFileSync(configPath, "utf-8"));
+    const store = new CredentialStore();
+    const token = store.getToken();
+    if (!token) {
+      console.error("Not logged in. Run `lumio login` first.");
+      process.exit(1);
+    }
+    const client = new LumioApiClient(store.getApiUrl(), token);
+    const args = argsJson ? JSON.parse(argsJson) : {};
+    try {
+      const result = await client.post(
+        `/v1/extension-installs/${config.extensionId}/execute/${fnRef.name}`,
+        { type: fnRef.type, args }
+      );
+      console.log(JSON.stringify(result, null, 2));
+    } catch (err) {
+      console.error("Function execution failed:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/dashboard.ts
+import * as fs9 from "fs";
+import * as path9 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)) {
+      console.error("lumio.config.json not found. Run `lumio init` first.");
+      process.exit(1);
+    }
+    const config = parseConfigFile(fs9.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}...`);
+    const { default: open } = await import("open");
+    await open(url);
+  });
+}
+
+// src/program.ts
+function createProgram() {
+  const program2 = new Command();
+  program2.name("lumio");
+  program2.description("Lumio Extension CLI -- Build, test, and deploy Lumio extensions");
+  program2.version("2026.5.1");
+  registerLogin(program2);
+  registerLogout(program2);
+  registerWhoami(program2);
+  registerInit(program2);
+  registerDev(program2);
+  registerBuild(program2);
+  registerDeploy(program2);
+  registerStatus(program2);
+  registerLogs(program2);
+  registerEnv(program2);
+  registerRun(program2);
+  registerDashboard(program2);
+  return program2;
+}
+
+// src/index.ts
+var program = createProgram();
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+export {
+  CredentialStore,
+  LumioApiClient,
+  createProgram
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@zaflun/lumio-cli",
+  "version": "0.1.0",
+  "description": "Lumio Extension CLI — Build, test, and deploy Lumio extensions",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "lumio": "bin/lumio.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "templates"
+  ],
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "esbuild": "^0.25.4",
+    "eventsource": "^3.0.6",
+    "inquirer": "^12.6.0",
+    "open": "^10.1.2",
+    "ora": "^8.2.0",
+    "@zaflun/lumio-extension-types": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/archiver": "^6.0.3",
+    "@types/eventsource": "^1.1.15",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.4",
+    "tsup": "^8.4.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zaflun/lumio.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": {
+    "name": "zaflun",
+    "email": "developers@zaflun.com",
+    "url": "https://withzaflun.com"
+  },
+  "homepage": "https://developers.lumio.vision",
+  "bugs": {
+    "url": "https://github.com/zaflun/lumio/issues",
+    "email": "developers@zaflun.com"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  }
+}