@glasshome/widget-cli 0.2.1 → 0.3.1

package/README.md

@@ -27,13 +27,25 @@ bunx @glasshome/widget-cli create
 | `build` | Build all widgets |
 | `connect <url>` | Connect to a running dashboard for live testing |
 | `validate [name]` | Validate all widgets or a specific one |
-| `publish` | Build and publish to GlassHome Hub |
-| `login [hub-url]` | Authenticate with GlassHome Hub |
+| `publish [hub-url]` | Select and publish a widget to GlassHome Hub |
+| `login [hub-url]` | Authenticate with GlassHome Hub (required before publish) |
 | `info [name]` | Show widget metadata and bundle info |
 | `upgrade` | Upgrade @glasshome/widget-sdk to latest version |
 
 Running `glasshome-widget` with no command inside a widget project shows help. Outside a widget project, it starts the create wizard.
 
+## Publishing
+
+```bash
+# Login first (one-time)
+glasshome-widget login
+
+# Then publish
+glasshome-widget publish
+```
+
+The CLI prompts you to select a widget, choose a version bump, then builds and publishes. Each widget tracks its own version in its `manifest.json`.
+
 ## Documentation
 
 Full docs at [glasshome.app/docs](https://glasshome.app/docs)

package/bin/cli.ts

@@ -26,7 +26,7 @@ Commands:
   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 [hub-url]      Build all widgets and publish to Hub
+  publish [hub-url]      Build and publish a widget 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glasshome/widget-cli",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "CLI for creating and managing GlassHome widgets",
   "type": "module",
   "bin": {

package/src/commands/info.ts

@@ -44,8 +44,8 @@ export async function runInfo(cwd: string, widgetName?: string): Promise<void> {
       const manifest = readManifest(cwd, name);
       log.info(`  Tag:         ${manifest.tag}`);
       log.info(`  Name:        ${manifest.name}`);
-      log.info(`  Type:        ${manifest.type}`);
-      log.info(`  Size:        ${manifest.size}`);
+      log.info(`  Min Size:    ${manifest.minSize.w}×${manifest.minSize.h}`);
+      log.info(`  Max Size:    ${manifest.maxSize.w}×${manifest.maxSize.h}`);
       log.info(`  SDK Version: ${manifest.sdkVersion}`);
       if (manifest.version) {
         log.info(`  Version:     ${manifest.version}`);

package/src/commands/publish.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { cancel, isCancel, log, multiselect, select, spinner } from "@clack/prompts";
+import { cancel, isCancel, log, select, spinner } from "@clack/prompts";
 import semver from "semver";
 import { getHubUrl, getToken } from "../utils/auth";
 import { confirmPublish, fetchScopes, requestPublish, uploadToR2 } from "../utils/hub-api";
@@ -15,97 +15,23 @@ import {
 import { runLogin } from "./login";
 
 export async function runPublish(cwd: string, hubUrlOverride?: string): Promise<void> {
-  // Step 1: Validate all widgets
-  log.info("Running validation...");
+  const s = spinner();
+
+  // Step 1: Validate (quiet)
   const { runValidate } = await import("./validate");
-  const valid = await runValidate(cwd);
+  const valid = await runValidate(cwd, undefined, { quiet: true });
   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}`, hint: "fails if already published" },
-      {
-        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
+  // Step 2: Authenticate
   const hubUrl = hubUrlOverride ?? getHubUrl();
-  log.info(`Hub: ${hubUrl}`);
+  if (hubUrlOverride) log.info(`Hub: ${hubUrl}`);
   let token = await getToken(hubUrl);
 
   if (!token) {
-    log.warn("Not authenticated with Hub. Starting login...");
+    log.warn("Not authenticated. Starting login...");
     try {
       await runLogin(hubUrl);
     } catch (err) {
@@ -114,12 +40,12 @@ export async function runPublish(cwd: string, hubUrlOverride?: string): Promise<
     }
     token = await getToken(hubUrl);
     if (!token) {
-      log.error("Authentication failed. Run `bun widget login` manually.");
+      log.error("Authentication failed. Run `glasshome-widget login` manually.");
       process.exit(1);
     }
   }
 
-  // Fetch available scopes from hub
+  // Step 3: Select scope
   const scopes = await fetchScopes(hubUrl, token!);
   if (scopes.length === 0) {
     log.error("No publishing scopes available. Ensure your account is properly set up.");
@@ -148,19 +74,24 @@ export async function runPublish(cwd: string, hubUrlOverride?: string): Promise<
     scope = choice as string;
   }
 
-  // Step 7: Select widgets to publish
+  // Step 4: Select widget
+  const widgets = discoverWidgets(cwd);
   const widgetOptions = widgets.map((name) => {
     const manifest = readManifest(cwd, name);
+    let sizeInfo = "";
+    try {
+      const info = getWidgetBundleInfo(cwd, name);
+      sizeInfo = ` — ${formatBytes(info.raw)}`;
+    } catch {}
     return {
       value: name,
-      label: `${manifest.tag} (${manifest.minSize.w}x${manifest.minSize.h} - ${manifest.maxSize.w}x${manifest.maxSize.h})`,
+      label: `${manifest.tag}${sizeInfo}`,
     };
   });
 
-  const selected = await multiselect({
-    message: "Select widgets to publish:",
+  const selected = await select({
+    message: "Select widget to publish:",
     options: widgetOptions,
-    initialValues: widgets,
   });
 
   if (isCancel(selected)) {
@@ -168,100 +99,101 @@ export async function runPublish(cwd: string, hubUrlOverride?: string): Promise<
     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 }> = [];
+  const widgetName = selected as string;
+  const manifest = readManifest(cwd, widgetName);
 
-  for (const widgetName of selectedWidgets) {
-    const manifest = readManifest(cwd, widgetName);
-    const distPath = resolve(cwd, "dist", `${widgetName}.js`);
+  // Step 5: Version bump (per-widget, from manifest)
+  const currentVersion = manifest.version ?? "0.0.0";
 
-    let bundleBuffer: Buffer;
-    try {
-      bundleBuffer = Buffer.from(readFileSync(distPath));
-    } catch {
-      log.error(`Bundle not found: dist/${widgetName}.js`);
-      continue;
-    }
+  const bump = await select({
+    message: `${manifest.tag} version: ${currentVersion}. Bump?`,
+    options: [
+      { value: "keep", label: `Keep ${currentVersion}`, hint: "fails if already published" },
+      { value: "patch", label: `Patch (${semver.inc(currentVersion, "patch")})` },
+      { value: "minor", label: `Minor (${semver.inc(currentVersion, "minor")})` },
+      { value: "major", label: `Major (${semver.inc(currentVersion, "major")})` },
+    ],
+  });
 
-    // Compute SHA-256 hash
-    const sha256Hash = createHash("sha256").update(bundleBuffer).digest("hex");
+  if (isCancel(bump)) {
+    cancel("Publish cancelled.");
+    process.exit(0);
+  }
 
-    s.start(`Publishing ${manifest.tag}@${version}...`);
+  let version = currentVersion;
+  if (bump !== "keep") {
+    version = semver.inc(currentVersion, bump as "patch" | "minor" | "major") ?? currentVersion;
+    manifest.version = version;
+    writeManifest(cwd, widgetName, manifest);
+  }
 
-    // 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;
-    }
+  // Step 6: Build (async so spinner animates)
+  s.start("Building widget...");
+  const buildProc = Bun.spawn(["bun", "run", "build"], { cwd, stdout: "pipe", stderr: "pipe" });
+  const buildExit = await buildProc.exited;
+  if (buildExit !== 0) {
+    const stderr = await new Response(buildProc.stderr).text();
+    s.stop("Build failed");
+    log.error(stderr);
+    process.exit(1);
+  }
+  s.stop("Build complete");
 
-    // 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;
-    }
+  // Step 7: Publish
+  const distPath = resolve(cwd, "dist", `${widgetName}.js`);
 
-    // 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}`);
-    }
+  let bundleBuffer: Buffer;
+  try {
+    bundleBuffer = Buffer.from(readFileSync(distPath));
+  } catch {
+    log.error(`Bundle not found: dist/${widgetName}.js`);
+    process.exit(1);
   }
 
-  // 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}`);
+  const sha256Hash = createHash("sha256").update(bundleBuffer).digest("hex");
+
+  s.start(`Publishing ${manifest.tag}@${version}...`);
+
+  let publishData: Awaited<ReturnType<typeof requestPublish>>;
+  try {
+    publishData = await requestPublish(hubUrl, token!, {
+      scope,
+      name: widgetName,
+      displayName: manifest.name,
+      description: manifest.description,
+      icon: manifest.icon,
+      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(`${manifest.tag}@${version} already published — bump version to republish`);
+      process.exit(0);
     }
+    s.stop(`Publish failed: ${err.message}`);
+    process.exit(1);
   }
 
-  if (skipped.length > 0) {
-    log.warn(`Skipped ${skipped.length} widget(s):`);
-    for (const w of skipped) {
-      log.info(`  ${w.name}: ${w.reason}`);
-    }
+  s.message(`Uploading ${manifest.tag} to CDN...`);
+  try {
+    await uploadToR2(publishData.uploadUrl, bundleBuffer);
+  } catch (err: any) {
+    s.stop(`Upload failed: ${err.message}`);
+    process.exit(1);
   }
 
-  if (published.length === 0 && skipped.length === 0) {
-    log.error("No widgets were published.");
+  s.message(`Confirming ${manifest.tag}...`);
+  try {
+    const result = await confirmPublish(hubUrl, token!, publishData.versionId);
+    s.stop(`Published ${manifest.tag}@${version}`);
+    log.info(`CDN: ${result.bundleUrl}`);
+  } catch (err: any) {
+    s.stop(`Confirmation failed: ${err.message}`);
+    process.exit(1);
   }
 }

package/src/commands/validate.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { log, spinner } from "@clack/prompts";
+import { WidgetManifestSchema } from "@glasshome/widget-sdk/schemas";
 import {
   discoverWidgets,
   formatBytes,
@@ -22,54 +23,43 @@ 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");
+  // Validate core manifest shape using the shared schema
+  const result = WidgetManifestSchema.safeParse(manifest);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      const path = issue.path.length > 0 ? issue.path.join(".") : "manifest";
+      errors.push(`${path}: ${issue.message}`);
+    }
+  }
 
-  // Tag format
+  // Tag format (stricter than schema — enforces kebab-case with at least one hyphen)
   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") {
+      if ((manifest.schema as Record<string, unknown>).type !== "object") {
         warnings.push('Schema type should be "object"');
       }
-      if (!manifest.schema.properties || typeof manifest.schema.properties !== "object") {
+      if (
+        !(manifest.schema as Record<string, unknown>).properties ||
+        typeof (manifest.schema as Record<string, unknown>).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>);
+    if (manifest.defaultConfig && (manifest.schema as Record<string, unknown>).properties) {
+      const schemaKeys = Object.keys(
+        (manifest.schema as Record<string, unknown>).properties as Record<string, unknown>,
+      );
       const configKeys = Object.keys(manifest.defaultConfig);
       for (const key of configKeys) {
         if (!schemaKeys.includes(key)) {
@@ -86,7 +76,12 @@ function validateManifest(manifest: WidgetManifest): ValidationResult {
   };
 }
 
-export async function runValidate(cwd: string, widgetName?: string): Promise<boolean> {
+export async function runValidate(
+  cwd: string,
+  widgetName?: string,
+  options?: { quiet?: boolean },
+): Promise<boolean> {
+  const quiet = options?.quiet ?? false;
   const widgets = discoverWidgets(cwd);
 
   if (widgets.length === 0) {
@@ -106,10 +101,12 @@ export async function runValidate(cwd: string, widgetName?: string): Promise<boo
   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) {
+    const proc = Bun.spawn(["bun", "run", "build"], { cwd, stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
       s.stop("Build failed");
-      log.error(proc.stderr.toString());
+      log.error(stderr);
       return false;
     }
     s.stop("Build complete");
@@ -117,15 +114,19 @@ export async function runValidate(cwd: string, widgetName?: string): Promise<boo
 
   let allPassed = true;
 
+  const failed: string[] = [];
+
   for (const name of toValidate) {
-    log.info(`\nValidating widget: ${name}`);
+    if (!quiet) 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)}`);
+      if (!quiet)
+        log.error(`  Failed to read manifest: ${err instanceof Error ? err.message : String(err)}`);
+      failed.push(name);
       allPassed = false;
       continue;
     }
@@ -134,11 +135,11 @@ export async function runValidate(cwd: string, widgetName?: string): Promise<boo
 
     if (result.errors.length > 0) {
       for (const err of result.errors) {
-        log.error(`  - ${err}`);
+        if (!quiet) log.error(`  - ${err}`);
       }
     }
 
-    if (result.warnings.length > 0) {
+    if (!quiet && result.warnings.length > 0) {
       for (const warn of result.warnings) {
         log.warn(`  - ${warn}`);
       }
@@ -147,9 +148,10 @@ export async function runValidate(cwd: string, widgetName?: string): Promise<boo
     // Check bundle exists
     const bundlePath = resolve(cwd, "dist", `${name}.js`);
     if (!existsSync(bundlePath)) {
-      log.error(`  - dist/${name}.js not found`);
+      if (!quiet) log.error(`  - dist/${name}.js not found`);
       allPassed = false;
-    } else {
+      failed.push(name);
+    } else if (!quiet) {
       try {
         const info = getWidgetBundleInfo(cwd, name);
         log.info(`  Bundle: ${formatBytes(info.raw)} (${formatBytes(info.gzip)} gzipped)`);
@@ -159,9 +161,10 @@ export async function runValidate(cwd: string, widgetName?: string): Promise<boo
     }
 
     if (result.passed) {
-      log.success(`  ${name}: passed`);
+      if (!quiet) log.success(`  ${name}: passed`);
     } else {
-      log.error(`  ${name}: failed`);
+      if (!quiet) log.error(`  ${name}: failed`);
+      failed.push(name);
       allPassed = false;
     }
   }
@@ -169,23 +172,31 @@ export async function runValidate(cwd: string, widgetName?: string): Promise<boo
   // Validate registry.json
   const registry = readRegistry(cwd);
   if (!registry) {
-    log.error("\ndist/registry.json not found");
+    if (!quiet) 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`);
+        if (!quiet) log.error(`  Widget "${name}" not listed in registry.json`);
         allPassed = false;
       }
     }
-    log.info(`\nRegistry: ${registry.widgets.length} widget(s)`);
+    if (!quiet) log.info(`\nRegistry: ${registry.widgets.length} widget(s)`);
   }
 
-  if (allPassed) {
-    log.success("\nAll checks passed");
+  if (quiet) {
+    if (allPassed) {
+      log.success(`Validated ${toValidate.length} widget(s)`);
+    } else {
+      log.error(`Validation failed for: ${failed.join(", ")}`);
+    }
   } else {
-    log.error("\nValidation failed");
+    if (allPassed) {
+      log.success("\nAll checks passed");
+    } else {
+      log.error("\nValidation failed");
+    }
   }
 
   return allPassed;

package/src/utils/auth.ts

@@ -88,9 +88,12 @@ export function clearToken(): void {
 
 export function getHubUrl(): string {
   const stored = getStoredAuth()?.hubUrl;
-  // Ignore localhost URLs from local dev sessions
-  if (stored && !stored.includes("localhost") && !stored.includes("127.0.0.1")) {
-    return stored;
+  if (stored) {
+    if (stored.includes("localhost") || stored.includes("127.0.0.1")) {
+      clearToken();
+    } else {
+      return stored;
+    }
   }
   return "https://glasshome.app";
 }

package/src/utils/hub-api.ts

@@ -15,14 +15,16 @@ export async function fetchScopes(hubUrl: string, token: string): Promise<Publis
   return data.scopes;
 }
 
+import type { GridSize } from "@glasshome/widget-sdk";
+
 interface PublishRequestParams {
   scope: string;
   name: string;
   displayName: string;
   description?: string;
   icon?: string;
-  minSize: { w: number; h: number };
-  maxSize: { w: number; h: number };
+  minSize: GridSize;
+  maxSize: GridSize;
   sdkVersion: string;
   version: string;
   bundleSize: number;
@@ -62,8 +64,15 @@ export async function requestPublish(
   }
 
   if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Publish request failed (${res.status}): ${text}`);
+    let detail: string;
+    try {
+      const body = await res.text();
+      const json = JSON.parse(body);
+      detail = json.error || json.message || body;
+    } catch {
+      detail = `HTTP ${res.status} ${res.statusText}`;
+    }
+    throw Object.assign(new Error(detail), { status: res.status });
   }
 
   return res.json() as Promise<PublishRequestResponse>;
@@ -84,8 +93,15 @@ export async function confirmPublish(
   });
 
   if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Publish confirm failed (${res.status}): ${text}`);
+    let detail: string;
+    try {
+      const body = await res.text();
+      const json = JSON.parse(body);
+      detail = json.error || json.message || body;
+    } catch {
+      detail = `HTTP ${res.status} ${res.statusText}`;
+    }
+    throw Object.assign(new Error(detail), { status: res.status });
   }
 
   return res.json() as Promise<PublishConfirmResponse>;

package/src/utils/manifest.ts

@@ -1,18 +1,9 @@
 import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { gzipSync } from "node:zlib";
+import type { WidgetManifest as SdkWidgetManifest } from "@glasshome/widget-sdk";
 
-export interface WidgetManifest {
-  tag: string;
-  name: string;
-  minSize: { w: number; h: number };
-  maxSize: { w: number; h: number };
-  sdkVersion: string;
-  version?: string;
-  description?: string;
-  schema?: Record<string, unknown>;
-  defaultConfig?: Record<string, unknown>;
-}
+export type WidgetManifest = SdkWidgetManifest & { version?: string };
 
 export interface Registry {
   version: number;
@@ -27,49 +18,6 @@ export interface BundleInfo {
   text: string;
 }
 
-// ---------------------------------------------------------------------------
-// Legacy single-widget helpers (kept for backward compat)
-// ---------------------------------------------------------------------------
-
-/**
- * Extract the widget manifest from the built dist/index.js bundle
- * by dynamic-importing it and reading the registered custom element's metadata.
- */
-export async function extractManifest(cwd: string): Promise<WidgetManifest> {
-  const distPath = resolve(cwd, "dist/index.js");
-  if (!existsSync(distPath)) {
-    throw new Error(
-      "dist/index.js not found. Run `bun run build` first or let the command build for you.",
-    );
-  }
-
-  // Dynamic import the bundle — it self-registers a custom element via @glasshome/widget-sdk's defineWidget.
-  // The SDK's defineWidget stores manifest on the custom element class.
-  const mod = await import(distPath);
-
-  // The module default export or the manifest property contains widget metadata
-  const manifest: WidgetManifest | undefined = mod.manifest ?? mod.default?.manifest;
-
-  if (!manifest) {
-    throw new Error(
-      "Could not extract manifest from dist/index.js. Ensure your widget uses defineWidget() from @glasshome/widget-sdk.",
-    );
-  }
-
-  return manifest;
-}
-
-/**
- * Read the raw bundle text and compute sizes.
- */
-export function getBundleInfo(cwd: string): BundleInfo {
-  const distPath = resolve(cwd, "dist/index.js");
-  const text = readFileSync(distPath, "utf-8");
-  const raw = Buffer.byteLength(text, "utf-8");
-  const gzip = gzipSync(text).byteLength;
-  return { raw, gzip, text };
-}
-
 export function formatBytes(bytes: number): string {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;