@glasshome/widget-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GlassHome Labs
+
+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,35 @@
+# @glasshome/widget-cli
+
+CLI for creating and managing GlassHome widgets.
+
+## Install
+
+```bash
+bun add -g @glasshome/widget-cli
+```
+
+## Quick Start
+
+```bash
+bunx @glasshome/widget-cli create my-widget
+cd my-widget
+bun install
+bun run dev
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `create <name>` | Scaffold a new widget project |
+| `validate` | Validate widget manifest and bundle |
+| `info` | Show widget metadata |
+| `publish` | Publish widget to the registry |
+
+## Documentation
+
+Full docs at [glasshome.app/docs](https://glasshome.app/docs)
+
+## License
+
+MIT

package/bin/cli.ts

@@ -0,0 +1,141 @@
+#!/usr/bin/env bun
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { intro, log, outro } from "@clack/prompts";
+
+function resolveWidgetDir(): string {
+  if (explicitDir) {
+    const dir = resolve(process.cwd(), explicitDir);
+    if (existsSync(resolve(dir, "src"))) return dir;
+    log.error(`No src/ directory found in ${dir}`);
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  if (existsSync(resolve(cwd, "src"))) return cwd;
+  const sibling = resolve(cwd, "../widgets");
+  if (existsSync(resolve(sibling, "src"))) return sibling;
+  return cwd;
+}
+
+const HELP = `
+glasshome-widget <command> [--dir <path>] [options]
+
+Commands:
+  add                    Add a new widget to the project
+  build                  Build all widgets (per-widget, self-contained bundles)
+  connect <url>          Connect to a running dashboard for live testing
+  validate [name]        Validate all widgets or a specific one
+  publish                Build all widgets and publish to Hub
+  login [hub-url]        Authenticate with GlassHome Hub
+  info [name]            Show widget metadata and bundle info
+  upgrade                Upgrade @glasshome/widget-sdk to latest version
+  help                   Show this help message
+
+Examples:
+  glasshome-widget add
+  glasshome-widget build
+  glasshome-widget connect http://localhost:3333
+  glasshome-widget validate
+  glasshome-widget validate clock
+  glasshome-widget info
+  glasshome-widget info clock
+  glasshome-widget publish
+  glasshome-widget login
+  glasshome-widget login https://my-hub.example.com
+  glasshome-widget upgrade
+  glasshome-widget publish --dir packages/widgets
+`.trim();
+
+const rawArgs = process.argv.slice(2);
+const dirFlagIdx = rawArgs.indexOf("--dir");
+let explicitDir: string | undefined;
+if (dirFlagIdx !== -1) {
+  explicitDir = rawArgs[dirFlagIdx + 1];
+  rawArgs.splice(dirFlagIdx, 2);
+}
+const [command, ...args] = rawArgs;
+
+if (!command || command === "help" || command === "--help" || command === "-h") {
+  console.log(HELP);
+  process.exit(0);
+}
+
+intro(`glasshome-widget ${command}`);
+
+switch (command) {
+  case "add": {
+    const { runAdd } = await import("../src/commands/add");
+    await runAdd(resolveWidgetDir());
+    outro("Done");
+    break;
+  }
+
+  case "build": {
+    const { runBuild } = await import("../src/commands/build");
+    await runBuild(resolveWidgetDir());
+    outro("Done");
+    break;
+  }
+
+  case "connect": {
+    const url = args[0];
+    if (!url) {
+      log.error("Missing required argument: <url>");
+      log.info("Usage: glasshome-widget connect <dashboard-api-url>");
+      process.exit(1);
+    }
+    const { runConnect } = await import("../src/commands/connect");
+    await runConnect(url, resolveWidgetDir());
+    break;
+  }
+
+  case "validate": {
+    const widgetName = args[0];
+    const { runValidate } = await import("../src/commands/validate");
+    const passed = await runValidate(resolveWidgetDir(), widgetName);
+    outro(passed ? "All checks passed" : "Validation failed");
+    process.exit(passed ? 0 : 1);
+    break;
+  }
+
+  case "login": {
+    const loginHubUrl = args[0];
+    const { runLogin } = await import("../src/commands/login");
+    try {
+      await runLogin(loginHubUrl);
+      outro("Done");
+    } catch (err) {
+      log.error(err instanceof Error ? err.message : "Login failed.");
+      process.exit(1);
+    }
+    break;
+  }
+
+  case "publish": {
+    const { runPublish } = await import("../src/commands/publish");
+    await runPublish(resolveWidgetDir());
+    outro("Done");
+    break;
+  }
+
+  case "info": {
+    const widgetName = args[0];
+    const { runInfo } = await import("../src/commands/info");
+    await runInfo(resolveWidgetDir(), widgetName);
+    outro("");
+    break;
+  }
+
+  case "upgrade": {
+    const { runUpgrade } = await import("../src/commands/upgrade");
+    await runUpgrade(resolveWidgetDir());
+    outro("Done");
+    break;
+  }
+
+  default: {
+    log.error(`Unknown command: ${command}`);
+    console.log(HELP);
+    process.exit(1);
+  }
+}

package/bin/create.ts

@@ -0,0 +1,220 @@
+#!/usr/bin/env bun
+import {
+  cpSync,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { cancel, confirm, intro, isCancel, log, outro, spinner, text } from "@clack/prompts";
+import { promptWidgetDetails, scaffoldWidget } from "../src/commands/add";
+
+const templateDir = resolve(import.meta.dir, "../template");
+
+/** Walk up from cwd looking for a package.json with a `workspaces` field. */
+function findMonorepoRoot(from: string): string | null {
+  let dir = resolve(from);
+  const root = (dir.match(/^[A-Za-z]:\\/) ?? ["/"])[0];
+  while (true) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.workspaces) return dir;
+      } catch {}
+    }
+    const parent = dirname(dir);
+    if (parent === dir || parent === root) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/** Check if cwd is inside an existing git repository. */
+function isInsideGitRepo(from: string): boolean {
+  const result = Bun.spawnSync(["git", "rev-parse", "--is-inside-work-tree"], {
+    cwd: from,
+    stderr: "pipe",
+  });
+  return result.exitCode === 0;
+}
+
+intro("Create GlassHome Widget Project");
+
+// ---- Project-level prompts ----
+
+const projectName = await text({
+  message: "Project name",
+  placeholder: "my-widgets",
+  defaultValue: "my-widgets",
+  validate(value) {
+    if (!value) return "Name is required";
+    if (/\s/.test(value)) return "Name cannot contain spaces";
+    if (!/^[a-z]/.test(value)) return "Name must start with a lowercase letter";
+    if (!/^[a-z][a-z0-9-]*$/.test(value))
+      return "Name must be lowercase alphanumeric with optional hyphens";
+  },
+});
+
+if (isCancel(projectName)) {
+  cancel("Operation cancelled.");
+  process.exit(0);
+}
+
+const projectDescription = await text({
+  message: "Project description (optional)",
+  placeholder: "My GlassHome widget collection",
+  defaultValue: "",
+});
+
+if (isCancel(projectDescription)) {
+  cancel("Operation cancelled.");
+  process.exit(0);
+}
+
+// ---- First widget prompts ----
+
+log.info("Let's set up your first widget:");
+
+const widgetDetails = await promptWidgetDetails();
+if (!widgetDetails) process.exit(0);
+
+const targetDir = resolve(process.cwd(), projectName as string);
+
+if (existsSync(targetDir)) {
+  cancel(`Directory "${projectName}" already exists.`);
+  process.exit(1);
+}
+
+const s = spinner();
+s.start("Scaffolding widget project...");
+
+try {
+  // Copy template to target
+  cpSync(templateDir, targetDir, { recursive: true });
+
+  // Strip .template suffixes (used to prevent IDE type-checking of template files)
+  function processDir(dir: string) {
+    for (const entry of readdirSync(dir)) {
+      const fullPath = join(dir, entry);
+      if (statSync(fullPath).isDirectory()) {
+        processDir(fullPath);
+        continue;
+      }
+      if (entry.endsWith(".template")) {
+        renameSync(fullPath, join(dir, entry.replace(/\.template$/, "")));
+      }
+    }
+  }
+  processDir(targetDir);
+
+  // Remove the template's src/index.tsx (it will be placed into a widget subdir)
+  const oldSrcIndex = join(targetDir, "src/index.tsx");
+  if (existsSync(oldSrcIndex)) {
+    rmSync(oldSrcIndex);
+  }
+
+  const projectDesc =
+    (projectDescription as string) || `A GlassHome widget project: ${projectName}`;
+
+  // Replace project-level placeholders in package.json
+  const pkgPath = join(targetDir, "package.json");
+  let pkgContent = readFileSync(pkgPath, "utf-8");
+  pkgContent = pkgContent.replace(/PROJECT_NAME/g, projectName as string);
+  pkgContent = pkgContent.replace(/PROJECT_DESCRIPTION/g, projectDesc);
+  writeFileSync(pkgPath, pkgContent);
+
+  // Replace project-level placeholders in README.md
+  const readmePath = join(targetDir, "README.md");
+  let readmeContent = readFileSync(readmePath, "utf-8");
+  readmeContent = readmeContent.replace(/PROJECT_NAME/g, projectName as string);
+  readmeContent = readmeContent.replace(/PROJECT_DESCRIPTION/g, projectDesc);
+  writeFileSync(readmePath, readmeContent);
+
+  // Create the first widget in src/{widgetName}/
+  scaffoldWidget(targetDir, widgetDetails);
+
+  s.stop("Widget project created!");
+
+  // Post-scaffold: auto-install
+  const monorepoRoot = findMonorepoRoot(process.cwd());
+  const installCwd = monorepoRoot ?? targetDir;
+  const installHint = monorepoRoot ? " (from monorepo root)" : "";
+
+  const shouldInstall = await confirm({
+    message: `Install dependencies?${installHint}`,
+    initialValue: true,
+  });
+
+  if (!isCancel(shouldInstall) && shouldInstall) {
+    const installSpinner = spinner();
+    installSpinner.start("Installing dependencies...");
+    const installProc = Bun.spawnSync(["bun", "install"], { cwd: installCwd });
+    if (installProc.exitCode === 0) {
+      installSpinner.stop("Dependencies installed");
+    } else {
+      installSpinner.stop(
+        monorepoRoot
+          ? "Install failed — run `bun install` from the monorepo root"
+          : "Install failed — you can run `bun install` manually",
+      );
+    }
+  }
+
+  // Post-scaffold: git init (skip when already inside a git repo)
+  const inGitRepo = isInsideGitRepo(process.cwd());
+
+  if (inGitRepo) {
+    log.info("Skipping git init — already in a git repository");
+  } else {
+    const shouldGit = await confirm({
+      message: "Initialize git repository?",
+      initialValue: true,
+    });
+
+    if (!isCancel(shouldGit) && shouldGit) {
+      const gitSpinner = spinner();
+      gitSpinner.start("Initializing git repository...");
+      const initProc = Bun.spawnSync(["git", "init"], { cwd: targetDir });
+      if (initProc.exitCode === 0) {
+        Bun.spawnSync(["git", "add", "-A"], { cwd: targetDir });
+        Bun.spawnSync(["git", "commit", "-m", "Initial widget scaffold"], { cwd: targetDir });
+        gitSpinner.stop("Git repository initialized");
+      } else {
+        gitSpinner.stop("Git init failed — you can run `git init` manually");
+      }
+    }
+  }
+
+  // Enhanced outro with next-steps guide
+  log.info("");
+  log.step("Next steps:");
+  if (monorepoRoot) {
+    log.info("  bun install              Run from monorepo root to link workspace packages");
+    log.info(`  cd ${projectName}`);
+  } else {
+    log.info(`  cd ${projectName}`);
+    if (isCancel(shouldInstall) || !shouldInstall) {
+      log.info("  bun install");
+    }
+  }
+  log.info("  bun widget connect <url>   Connect to a running dashboard for live testing");
+  log.info("  bun widget add             Add another widget to the project");
+  log.info("  bun run build              Build all widgets + generate registry.json");
+  log.info("  bun widget validate        Validate all widgets");
+  log.info("  bun widget publish         Build & publish to GlassHome Hub");
+  log.info("  bun widget info            Show widget metadata");
+  log.info("  bun widget upgrade         Upgrade @glasshome/widget-sdk");
+
+  outro("Happy building!");
+} catch (err) {
+  s.stop("Failed to scaffold widget project.");
+  // Rollback: remove partially created directory
+  rmSync(targetDir, { recursive: true, force: true });
+  cancel(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@glasshome/widget-cli",
+  "version": "0.1.0",
+  "description": "CLI for creating and managing GlassHome widgets",
+  "type": "module",
+  "bin": {
+    "create-glasshome-widget": "bin/create.ts",
+    "glasshome-widget": "bin/cli.ts"
+  },
+  "scripts": {
+    "create": "bun bin/create.ts",
+    "cli": "bun bin/cli.ts"
+  },
+  "files": [
+    "bin",
+    "src",
+    "template"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "@glasshome/widget-sdk": "^0.1.0",
+    "open": "^11.0.0",
+    "semver": "^7.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/glasshome/widget-cli.git"
+  },
+  "keywords": [
+    "glasshome",
+    "widget",
+    "cli",
+    "scaffold",
+    "home-assistant",
+    "dashboard",
+    "smart-home"
+  ],
+  "homepage": "https://github.com/glasshome/widget-cli#readme",
+  "bugs": {
+    "url": "https://github.com/glasshome/widget-cli/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "author": "GlassHome Labs",
+  "license": "MIT"
+}

package/src/commands/add.ts

@@ -0,0 +1,136 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { cancel, isCancel, log, text } from "@clack/prompts";
+
+/** Capitalize kebab-case into PascalCase for component names. */
+function capitalize(str: string): string {
+  return str
+    .split("-")
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}
+
+/** Create the widget source files in src/{widgetName}/. */
+export function scaffoldWidget(
+  cwd: string,
+  opts: {
+    widgetName: string;
+    tag: string;
+    description: string;
+  },
+): void {
+  const { widgetName, tag, description } = opts;
+  const widgetDir = resolve(cwd, "src", widgetName);
+
+  if (existsSync(widgetDir)) {
+    throw new Error(`src/${widgetName}/ already exists`);
+  }
+
+  mkdirSync(widgetDir, { recursive: true });
+
+  const displayName = capitalize(widgetName);
+  const widgetDescription = description || `A GlassHome dashboard widget: ${widgetName}`;
+
+  // Read index.tsx template from the template directory
+  const templateDir = resolve(import.meta.dir, "../../template");
+  let srcContent = readFileSync(resolve(templateDir, "src/index.tsx.template"), "utf-8");
+  srcContent = srcContent.replace(/WIDGET_TAG/g, tag);
+  srcContent = srcContent.replace(/WIDGET_NAME/g, displayName);
+  writeFileSync(resolve(widgetDir, "index.tsx"), srcContent);
+
+  // Generate manifest.json
+  const manifest = {
+    tag,
+    name: displayName,
+    description: widgetDescription,
+    minSize: { w: 1, h: 1 },
+    maxSize: { w: 4, h: 4 },
+    sdkVersion: "^0.2.0",
+    version: "0.1.0",
+  };
+  writeFileSync(resolve(widgetDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+}
+
+/** Interactive prompts for widget details. Returns null if cancelled. */
+export async function promptWidgetDetails(defaults?: { widgetName?: string }): Promise<{
+  widgetName: string;
+  tag: string;
+  description: string;
+} | null> {
+  const widgetName = await text({
+    message: "Widget name",
+    placeholder: "clock",
+    defaultValue: defaults?.widgetName,
+    validate(value) {
+      if (!value) return "Name is required";
+      if (/\s/.test(value)) return "Name cannot contain spaces";
+      if (!/^[a-z]/.test(value)) return "Name must start with a lowercase letter";
+      if (!/^[a-z][a-z0-9-]*$/.test(value))
+        return "Name must be lowercase alphanumeric with optional hyphens";
+    },
+  });
+  if (isCancel(widgetName)) {
+    cancel("Operation cancelled.");
+    return null;
+  }
+
+  const tag = await text({
+    message: "Custom element tag",
+    placeholder: `glasshome-${widgetName}`,
+    defaultValue: `glasshome-${widgetName}`,
+    validate(value) {
+      if (!value) return "Tag is required";
+      if (!/^[a-z]/.test(value)) return "Tag must start with a lowercase letter";
+      if (!value.includes("-")) return "Custom element tags must contain a hyphen";
+      if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)+$/.test(value))
+        return "Tag must be lowercase alphanumeric with hyphens (e.g. glasshome-my-widget)";
+    },
+  });
+  if (isCancel(tag)) {
+    cancel("Operation cancelled.");
+    return null;
+  }
+
+  const description = await text({
+    message: "Description (optional)",
+    placeholder: "A GlassHome dashboard widget",
+    defaultValue: "",
+  });
+  if (isCancel(description)) {
+    cancel("Operation cancelled.");
+    return null;
+  }
+
+  return {
+    widgetName: widgetName as string,
+    tag: tag as string,
+    description: description as string,
+  };
+}
+
+export async function runAdd(cwd: string): Promise<void> {
+  // Verify project structure
+  const srcDir = resolve(cwd, "src");
+  if (!existsSync(srcDir)) {
+    log.error("No src/ directory found. Are you in a GlassHome widget project?");
+    process.exit(1);
+  }
+
+  const details = await promptWidgetDetails();
+  if (!details) process.exit(0);
+
+  const widgetDir = resolve(srcDir, details.widgetName);
+  if (existsSync(widgetDir)) {
+    log.error(`src/${details.widgetName}/ already exists.`);
+    process.exit(1);
+  }
+
+  try {
+    scaffoldWidget(cwd, details);
+    log.success(`Widget "${details.widgetName}" added at src/${details.widgetName}/`);
+    log.info("Run `bun run build` to include it in the registry.");
+  } catch (err) {
+    log.error(`Failed to add widget: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}

package/src/commands/build.ts

@@ -0,0 +1,22 @@
+import { log, spinner } from "@clack/prompts";
+import { buildWidgets } from "@glasshome/widget-sdk/vite";
+
+export async function runBuild(cwd: string): Promise<void> {
+  const s = spinner();
+  s.start("Building widgets...");
+
+  try {
+    const solid = (await import("vite-plugin-solid")).default;
+    process.chdir(cwd);
+    await buildWidgets({
+      srcDir: "src",
+      outDir: "dist",
+      plugins: [solid()],
+    });
+    s.stop("Build complete");
+  } catch (err) {
+    s.stop("Build failed");
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}