@glasshome/widget-cli 0.1.0

package/src/commands/publish.ts

@@ -0,0 +1,266 @@
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { cancel, isCancel, log, multiselect, select, spinner } from "@clack/prompts";
+import semver from "semver";
+import { getHubUrl, getToken } from "../utils/auth";
+import { confirmPublish, fetchScopes, requestPublish, uploadToR2 } from "../utils/hub-api";
+import {
+  discoverWidgets,
+  formatBytes,
+  getWidgetBundleInfo,
+  readManifest,
+  writeManifest,
+} from "../utils/manifest";
+import { runLogin } from "./login";
+
+export async function runPublish(cwd: string): Promise<void> {
+  // Step 1: Validate all widgets
+  log.info("Running validation...");
+  const { runValidate } = await import("./validate");
+  const valid = await runValidate(cwd);
+  if (!valid) {
+    log.error("Fix validation errors before publishing.");
+    process.exit(1);
+  }
+
+  // Step 2: Read package.json
+  const pkgPath = resolve(cwd, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const currentVersion = pkg.version ?? "0.0.0";
+
+  // Step 3: Version bump prompt
+  const bump = await select({
+    message: `Current version: ${currentVersion}. Bump version?`,
+    options: [
+      { value: "keep", label: `Keep ${currentVersion}` },
+      {
+        value: "patch",
+        label: `Patch (${semver.inc(currentVersion, "patch")})`,
+      },
+      {
+        value: "minor",
+        label: `Minor (${semver.inc(currentVersion, "minor")})`,
+      },
+      {
+        value: "major",
+        label: `Major (${semver.inc(currentVersion, "major")})`,
+      },
+    ],
+  });
+
+  if (isCancel(bump)) {
+    cancel("Publish cancelled.");
+    process.exit(0);
+  }
+
+  let version = currentVersion;
+  if (bump !== "keep") {
+    version = semver.inc(currentVersion, bump as "patch" | "minor" | "major") ?? currentVersion;
+
+    pkg.version = version;
+    writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+
+    const allWidgets = discoverWidgets(cwd);
+    for (const name of allWidgets) {
+      const manifest = readManifest(cwd, name);
+      manifest.version = version;
+      writeManifest(cwd, name, manifest);
+    }
+
+    log.info(`Version bumped to ${version}`);
+  }
+
+  // Step 4: Rebuild
+  const s = spinner();
+  s.start("Building widgets...");
+  const buildProc = Bun.spawnSync(["bun", "run", "build"], { cwd });
+  if (buildProc.exitCode !== 0) {
+    s.stop("Build failed");
+    log.error(buildProc.stderr.toString());
+    process.exit(1);
+  }
+  s.stop("Build complete");
+
+  // Step 5: Show summary
+  const widgets = discoverWidgets(cwd);
+  log.success(`Ready for publishing: ${pkg.name}@${version}`);
+  log.info("");
+
+  for (const name of widgets) {
+    const manifest = readManifest(cwd, name);
+    let sizeInfo = "";
+    try {
+      const info = getWidgetBundleInfo(cwd, name);
+      sizeInfo = ` — ${formatBytes(info.raw)} (${formatBytes(info.gzip)} gzipped)`;
+    } catch {}
+    log.info(
+      `  ${manifest.tag} [${manifest.minSize.w}x${manifest.minSize.h} - ${manifest.maxSize.w}x${manifest.maxSize.h}]${sizeInfo}`,
+    );
+  }
+
+  // Step 6: Authenticate with Hub
+  const hubUrl = getHubUrl();
+  let token = await getToken(hubUrl);
+
+  if (!token) {
+    log.warn("Not authenticated with Hub. Starting login...");
+    try {
+      await runLogin(hubUrl);
+    } catch (err) {
+      log.error(err instanceof Error ? err.message : "Login failed.");
+      process.exit(1);
+    }
+    token = await getToken(hubUrl);
+    if (!token) {
+      log.error("Authentication failed. Run `bun widget login` manually.");
+      process.exit(1);
+    }
+  }
+
+  // Fetch available scopes from hub
+  const scopes = await fetchScopes(hubUrl, token!);
+  if (scopes.length === 0) {
+    log.error("No publishing scopes available. Ensure your account is properly set up.");
+    process.exit(1);
+  }
+
+  let scope: string;
+  if (scopes.length === 1) {
+    const only = scopes[0]!;
+    scope = only.name;
+    log.info(`Publishing as @${scope} (${only.type})`);
+  } else {
+    const choice = await select({
+      message: "Publish under which scope?",
+      options: scopes.map((s) => ({
+        value: s.name,
+        label: s.type === "personal" ? `@${s.name} (personal)` : `@${s.name} (${s.displayName})`,
+      })),
+    });
+
+    if (isCancel(choice)) {
+      cancel("Publish cancelled.");
+      process.exit(0);
+    }
+
+    scope = choice as string;
+  }
+
+  // Step 7: Select widgets to publish
+  const widgetOptions = widgets.map((name) => {
+    const manifest = readManifest(cwd, name);
+    return {
+      value: name,
+      label: `${manifest.tag} (${manifest.minSize.w}x${manifest.minSize.h} - ${manifest.maxSize.w}x${manifest.maxSize.h})`,
+    };
+  });
+
+  const selected = await multiselect({
+    message: "Select widgets to publish:",
+    options: widgetOptions,
+    initialValues: widgets,
+  });
+
+  if (isCancel(selected)) {
+    cancel("Publish cancelled.");
+    process.exit(0);
+  }
+
+  const selectedWidgets = selected as string[];
+  if (selectedWidgets.length === 0) {
+    log.warn("No widgets selected.");
+    return;
+  }
+
+  // Step 8: Publish each selected widget
+  const published: Array<{ name: string; cdnUrl: string }> = [];
+  const skipped: Array<{ name: string; reason: string }> = [];
+
+  for (const widgetName of selectedWidgets) {
+    const manifest = readManifest(cwd, widgetName);
+    const distPath = resolve(cwd, "dist", `${widgetName}.js`);
+
+    let bundleBuffer: Buffer;
+    try {
+      bundleBuffer = Buffer.from(readFileSync(distPath));
+    } catch {
+      log.error(`Bundle not found: dist/${widgetName}.js`);
+      continue;
+    }
+
+    // Compute SHA-256 hash
+    const sha256Hash = createHash("sha256").update(bundleBuffer).digest("hex");
+
+    s.start(`Publishing ${manifest.tag}@${version}...`);
+
+    // Request publish (get presigned URL)
+    let publishData: Awaited<ReturnType<typeof requestPublish>>;
+    try {
+      publishData = await requestPublish(hubUrl, token!, {
+        scope,
+        name: widgetName,
+        displayName: manifest.name,
+        description: manifest.description,
+        minSize: manifest.minSize,
+        maxSize: manifest.maxSize,
+        sdkVersion: manifest.sdkVersion,
+        version,
+        bundleSize: bundleBuffer.byteLength,
+        sha256Hash,
+        manifestJson: JSON.stringify(manifest),
+      });
+    } catch (err: any) {
+      if (err.status === 409) {
+        s.stop(`Skipped ${manifest.tag}@${version}`);
+        log.warn(`${manifest.tag}@${version}: already published (immutable)`);
+        skipped.push({ name: manifest.tag, reason: "version already exists" });
+        continue;
+      }
+      s.stop(`Failed ${manifest.tag}`);
+      log.error(`${manifest.tag}: ${err.message}`);
+      continue;
+    }
+
+    // Upload to R2
+    s.message(`Uploading ${manifest.tag} to CDN...`);
+    try {
+      await uploadToR2(publishData.uploadUrl, bundleBuffer);
+    } catch (err: any) {
+      s.stop(`Upload failed for ${manifest.tag}`);
+      log.error(`${manifest.tag}: ${err.message}`);
+      continue;
+    }
+
+    // Confirm publish
+    s.message(`Confirming ${manifest.tag}...`);
+    try {
+      const result = await confirmPublish(hubUrl, token!, publishData.versionId);
+      s.stop(`Published ${manifest.tag}@${version}`);
+      published.push({ name: manifest.tag, cdnUrl: result.bundleUrl });
+    } catch (err: any) {
+      s.stop(`Confirm failed for ${manifest.tag}`);
+      log.error(`${manifest.tag}: ${err.message}`);
+    }
+  }
+
+  // Step 9: Summary
+  log.info("");
+  if (published.length > 0) {
+    log.success(`Published ${published.length} widget(s):`);
+    for (const w of published) {
+      log.info(`  ${w.name} -> ${w.cdnUrl}`);
+    }
+  }
+
+  if (skipped.length > 0) {
+    log.warn(`Skipped ${skipped.length} widget(s):`);
+    for (const w of skipped) {
+      log.info(`  ${w.name}: ${w.reason}`);
+    }
+  }
+
+  if (published.length === 0 && skipped.length === 0) {
+    log.error("No widgets were published.");
+  }
+}

package/src/commands/upgrade.ts

@@ -0,0 +1,134 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { log, spinner } from "@clack/prompts";
+import { discoverWidgets, readManifest, writeManifest } from "../utils/manifest";
+import { runValidate } from "./validate";
+
+/** 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;
+}
+
+/** Find @glasshome/widget-sdk version from workspace resolution or node_modules. */
+function findWorkspaceSdkVersion(monorepoRoot: string): string | null {
+  const sdkPkgPaths = [
+    join(monorepoRoot, "widget-sdk/package.json"),
+    join(monorepoRoot, "node_modules/@glasshome/widget-sdk/package.json"),
+  ];
+
+  for (const sdkPath of sdkPkgPaths) {
+    if (existsSync(sdkPath)) {
+      try {
+        const sdkPkg = JSON.parse(readFileSync(sdkPath, "utf-8"));
+        if (sdkPkg.version) return sdkPkg.version;
+      } catch {}
+    }
+  }
+  return null;
+}
+
+/** Update sdkVersion in all manifest.json files. */
+function syncManifestSdkVersions(cwd: string, newVersion: string): void {
+  const widgets = discoverWidgets(cwd);
+  if (widgets.length === 0) return;
+
+  const sdkRange = `^${newVersion}`;
+  for (const name of widgets) {
+    const manifest = readManifest(cwd, name);
+    if (manifest.sdkVersion !== sdkRange) {
+      manifest.sdkVersion = sdkRange;
+      writeManifest(cwd, name, manifest);
+    }
+  }
+  log.info(`Updated sdkVersion to ${sdkRange} in ${widgets.length} manifest(s)`);
+}
+
+export async function runUpgrade(cwd: string): Promise<void> {
+  const pkgPath = resolve(cwd, "package.json");
+  if (!existsSync(pkgPath)) {
+    log.error("No package.json found in current directory.");
+    process.exit(1);
+  }
+
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const currentVersion =
+    pkg.peerDependencies?.["@glasshome/widget-sdk"] ??
+    pkg.devDependencies?.["@glasshome/widget-sdk"] ??
+    pkg.dependencies?.["@glasshome/widget-sdk"];
+
+  if (!currentVersion) {
+    log.error("@glasshome/widget-sdk is not listed in dependencies or peerDependencies.");
+    process.exit(1);
+  }
+
+  log.info(`Current @glasshome/widget-sdk version: ${currentVersion}`);
+
+  const monorepoRoot = findMonorepoRoot(cwd);
+
+  if (monorepoRoot) {
+    // Workspace mode: read SDK version from workspace, sync with bun install
+    const sdkVersion = findWorkspaceSdkVersion(monorepoRoot);
+
+    if (!sdkVersion) {
+      log.warn(
+        "Could not find @glasshome/widget-sdk in the workspace. Run `bun install` from the monorepo root.",
+      );
+      return;
+    }
+
+    const cleanCurrent = currentVersion.replace(/^[\^~]/, "");
+    if (cleanCurrent === sdkVersion) {
+      log.success(`Already up to date with workspace SDK (${sdkVersion})`);
+      // Still sync manifests in case they're out of date
+      syncManifestSdkVersions(cwd, sdkVersion);
+      return;
+    }
+
+    log.info(`Workspace SDK version: ${sdkVersion}`);
+
+    const s = spinner();
+    s.start("Syncing workspace dependencies...");
+    const installProc = Bun.spawnSync(["bun", "install"], { cwd: monorepoRoot });
+    if (installProc.exitCode !== 0) {
+      s.stop("Install failed");
+      log.error(installProc.stderr.toString());
+      process.exit(1);
+    }
+    s.stop("Dependencies synced");
+
+    // Sync sdkVersion in all manifest.json files
+    syncManifestSdkVersions(cwd, sdkVersion);
+
+    // Run validate to check compatibility
+    log.info("Checking compatibility...");
+    const valid = await runValidate(cwd);
+    if (valid) {
+      log.success(`Synced with workspace @glasshome/widget-sdk@${sdkVersion}`);
+    } else {
+      log.warn(`Synced to ${sdkVersion} but validation has warnings/errors. Check above.`);
+    }
+  } else {
+    // Standalone mode: can't fetch from npm (private package), guide user
+    log.info("@glasshome/widget-sdk is a workspace package and is not published to npm.");
+    log.info("");
+    log.step("To upgrade:");
+    log.info("  1. Update the @glasshome/widget-sdk version in your package.json peerDependencies");
+    log.info("  2. Run `bun install` to install the new version");
+    log.info("  3. Run `bun widget upgrade` again to sync manifest files");
+    log.info("  4. Run `bun widget validate` to check compatibility");
+  }
+}

package/src/commands/validate.ts

@@ -0,0 +1,192 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { log, spinner } from "@clack/prompts";
+import {
+  discoverWidgets,
+  formatBytes,
+  getWidgetBundleInfo,
+  readManifest,
+  readRegistry,
+  type WidgetManifest,
+} from "../utils/manifest";
+
+const TAG_REGEX = /^[a-z][a-z0-9]*(-[a-z0-9]+)+$/;
+
+interface ValidationResult {
+  passed: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+function validateManifest(manifest: WidgetManifest): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  // Required fields
+  if (!manifest.tag) errors.push("Missing required field: tag");
+  if (!manifest.name) errors.push("Missing required field: name");
+  if (!manifest.sdkVersion) errors.push("Missing required field: sdkVersion");
+
+  // Tag format
+  if (manifest.tag && !TAG_REGEX.test(manifest.tag)) {
+    errors.push(
+      `Invalid tag format "${manifest.tag}" — must match ${TAG_REGEX} (e.g. glasshome-my-widget)`,
+    );
+  }
+
+  // minSize validation
+  if (
+    !manifest.minSize ||
+    typeof manifest.minSize !== "object" ||
+    typeof manifest.minSize.w !== "number" ||
+    typeof manifest.minSize.h !== "number"
+  ) {
+    errors.push("minSize must be an object with numeric w and h properties");
+  }
+
+  // maxSize validation
+  if (
+    !manifest.maxSize ||
+    typeof manifest.maxSize !== "object" ||
+    typeof manifest.maxSize.w !== "number" ||
+    typeof manifest.maxSize.h !== "number"
+  ) {
+    errors.push("maxSize must be an object with numeric w and h properties");
+  }
+
+  // Schema validation
+  if (manifest.schema) {
+    if (typeof manifest.schema !== "object") {
+      errors.push("Schema must be an object");
+    } else {
+      if (manifest.schema.type !== "object") {
+        warnings.push('Schema type should be "object"');
+      }
+      if (!manifest.schema.properties || typeof manifest.schema.properties !== "object") {
+        warnings.push("Schema should have a properties object");
+      }
+    }
+
+    // Check defaultConfig matches schema properties
+    if (manifest.defaultConfig && manifest.schema.properties) {
+      const schemaKeys = Object.keys(manifest.schema.properties as Record<string, unknown>);
+      const configKeys = Object.keys(manifest.defaultConfig);
+      for (const key of configKeys) {
+        if (!schemaKeys.includes(key)) {
+          warnings.push(`defaultConfig key "${key}" is not defined in schema properties`);
+        }
+      }
+    }
+  }
+
+  return {
+    passed: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+export async function runValidate(cwd: string, widgetName?: string): Promise<boolean> {
+  const widgets = discoverWidgets(cwd);
+
+  if (widgets.length === 0) {
+    log.error("No widgets found in src/. Each widget needs a manifest.json.");
+    return false;
+  }
+
+  const toValidate = widgetName ? widgets.filter((w) => w === widgetName) : widgets;
+
+  if (widgetName && toValidate.length === 0) {
+    log.error(`Widget "${widgetName}" not found. Available: ${widgets.join(", ")}`);
+    return false;
+  }
+
+  // Auto-build if dist/ is missing
+  const distDir = resolve(cwd, "dist");
+  if (!existsSync(distDir)) {
+    const s = spinner();
+    s.start("Building widgets (dist/ not found)...");
+    const proc = Bun.spawnSync(["bun", "run", "build"], { cwd });
+    if (proc.exitCode !== 0) {
+      s.stop("Build failed");
+      log.error(proc.stderr.toString());
+      return false;
+    }
+    s.stop("Build complete");
+  }
+
+  let allPassed = true;
+
+  for (const name of toValidate) {
+    log.info(`\nValidating widget: ${name}`);
+
+    // Read and validate manifest.json
+    let manifest: WidgetManifest;
+    try {
+      manifest = readManifest(cwd, name);
+    } catch (err) {
+      log.error(`  Failed to read manifest: ${err instanceof Error ? err.message : String(err)}`);
+      allPassed = false;
+      continue;
+    }
+
+    const result = validateManifest(manifest);
+
+    if (result.errors.length > 0) {
+      for (const err of result.errors) {
+        log.error(`  - ${err}`);
+      }
+    }
+
+    if (result.warnings.length > 0) {
+      for (const warn of result.warnings) {
+        log.warn(`  - ${warn}`);
+      }
+    }
+
+    // Check bundle exists
+    const bundlePath = resolve(cwd, "dist", `${name}.js`);
+    if (!existsSync(bundlePath)) {
+      log.error(`  - dist/${name}.js not found`);
+      allPassed = false;
+    } else {
+      try {
+        const info = getWidgetBundleInfo(cwd, name);
+        log.info(`  Bundle: ${formatBytes(info.raw)} (${formatBytes(info.gzip)} gzipped)`);
+      } catch {
+        // Ignore size reporting errors
+      }
+    }
+
+    if (result.passed) {
+      log.success(`  ${name}: passed`);
+    } else {
+      log.error(`  ${name}: failed`);
+      allPassed = false;
+    }
+  }
+
+  // Validate registry.json
+  const registry = readRegistry(cwd);
+  if (!registry) {
+    log.error("\ndist/registry.json not found");
+    allPassed = false;
+  } else {
+    const registryTags = new Set(registry.widgets.map((w) => w.bundleUrl));
+    for (const name of toValidate) {
+      if (!registryTags.has(`./${name}.js`)) {
+        log.error(`  Widget "${name}" not listed in registry.json`);
+        allPassed = false;
+      }
+    }
+    log.info(`\nRegistry: ${registry.widgets.length} widget(s)`);
+  }
+
+  if (allPassed) {
+    log.success("\nAll checks passed");
+  } else {
+    log.error("\nValidation failed");
+  }
+
+  return allPassed;
+}

package/src/utils/api.ts

@@ -0,0 +1,55 @@
+/**
+ * Raw HTTP helpers for calling tRPC endpoints without the client library.
+ * The API uses no transformer, so plain JSON is sent/received.
+ */
+
+interface TrpcMutationOptions {
+  apiUrl: string;
+  path: string;
+  input: Record<string, unknown>;
+}
+
+interface TrpcResult<T = unknown> {
+  result: { data: T };
+}
+
+export async function trpcMutate<T = unknown>(opts: TrpcMutationOptions): Promise<T> {
+  const url = `${opts.apiUrl.replace(/\/$/, "")}/trpc/${opts.path}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(opts.input),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`API error ${res.status}: ${text}`);
+  }
+
+  const json = (await res.json()) as TrpcResult<T>;
+  return json.result.data;
+}
+
+interface TrpcQueryOptions {
+  apiUrl: string;
+  path: string;
+  input?: Record<string, unknown>;
+}
+
+export async function trpcQuery<T = unknown>(opts: TrpcQueryOptions): Promise<T> {
+  const base = `${opts.apiUrl.replace(/\/$/, "")}/trpc/${opts.path}`;
+  const url = opts.input ? `${base}?input=${encodeURIComponent(JSON.stringify(opts.input))}` : base;
+
+  const res = await fetch(url, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" },
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`API error ${res.status}: ${text}`);
+  }
+
+  const json = (await res.json()) as TrpcResult<T>;
+  return json.result.data;
+}