ht-skills 0.2.5 → 0.2.7

package/lib/cli.js

@@ -157,6 +157,15 @@ async function setStoredRegistryAuth(registry, value, { homeDir = os.homedir() }
   await saveCliConfig(config, homeDir);
 }
 
+async function clearStoredRegistryAuth(registry, { homeDir = os.homedir() } = {}) {
+  const config = await loadCliConfig(homeDir);
+  if (!config.registries || typeof config.registries !== "object") {
+    return;
+  }
+  delete config.registries[getRegistryConfigKey(registry)];
+  await saveCliConfig(config, homeDir);
+}
+
 async function resolveAuthToken(registry, flags, { homeDir = os.homedir() } = {}) {
   const inlineToken = String(flags.token || "").trim();
   if (inlineToken) {
@@ -174,6 +183,79 @@ async function getRequiredAuthToken(registry, flags, { homeDir = os.homedir() }
   return token;
 }
 
+function isInteractiveSession(deps = {}) {
+  return typeof deps.isInteractive === "boolean"
+    ? deps.isInteractive
+    : Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+async function validateAuthToken(registry, token, deps = {}) {
+  const requestJsonImpl = deps.requestJson || requestJson;
+  try {
+    const payload = await requestJsonImpl(`${registry}/auth/me`, {
+      headers: withBearerToken({}, token),
+    });
+    if (!payload || payload.authenticated !== true) {
+      return null;
+    }
+    return payload;
+  } catch (error) {
+    if (Number(error?.status || 0) === 401) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function ensureValidAuthToken(registry, flags, deps = {}) {
+  const log = deps.log || ((message) => console.log(message));
+  const homeDir = deps.homeDir || os.homedir();
+  const loginImpl = deps.cmdLogin || cmdLogin;
+  const interactive = isInteractiveSession(deps);
+  const explicitToken = String(flags.token || "").trim();
+
+  let token = await resolveAuthToken(registry, flags, { homeDir });
+  if (!token) {
+    if (!interactive) {
+      throw new Error(`No saved login for ${registry}. Run "ht-skills login --registry ${registry}" first.`);
+    }
+    log(`Login required for ${registry}. Starting browser sign-in...`);
+    await loginImpl({ ...flags, registry }, deps);
+    token = await getRequiredAuthToken(registry, flags, { homeDir });
+  }
+
+  const authState = await validateAuthToken(registry, token, deps);
+  if (authState) {
+    return {
+      token,
+      authState,
+    };
+  }
+
+  if (explicitToken) {
+    throw new Error(`The provided token for ${registry} is invalid or expired.`);
+  }
+
+  await clearStoredRegistryAuth(registry, { homeDir });
+
+  if (!interactive) {
+    throw new Error(`Saved login for ${registry} is invalid or expired. Run "ht-skills login --registry ${registry}" first.`);
+  }
+
+  log(`Saved login for ${registry} is invalid or expired. Starting browser sign-in...`);
+  await loginImpl({ ...flags, registry }, deps);
+  token = await getRequiredAuthToken(registry, flags, { homeDir });
+  const refreshedAuthState = await validateAuthToken(registry, token, deps);
+  if (!refreshedAuthState) {
+    throw new Error(`Login completed but ${registry} did not accept the refreshed token.`);
+  }
+
+  return {
+    token,
+    authState: refreshedAuthState,
+  };
+}
+
 function withBearerToken(headers = {}, token = null) {
   if (!token) return { ...headers };
   return {
@@ -186,6 +268,17 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function formatBytes(bytes) {
+  const value = Number(bytes || 0);
+  if (value >= 1024 * 1024) {
+    return `${(value / (1024 * 1024)).toFixed(2)} MB`;
+  }
+  if (value >= 1024) {
+    return `${(value / 1024).toFixed(2)} KB`;
+  }
+  return `${value} B`;
+}
+
 function openBrowserUrl(url) {
   const safeUrl = String(url || "").trim();
   if (!safeUrl) {
@@ -726,6 +819,64 @@ function formatSearchCard(item, { index = 0, colorize = (text) => text, width =
   return [title, blank, firstLine, ...detailRendered, blank, bottom].join("\n");
 }
 
+const PUBLISH_FLOW_STEPS = [
+  { id: "auth", label: "Login" },
+  { id: "pack", label: "Pack" },
+  { id: "inspect", label: "Inspect" },
+  { id: "submit", label: "Submit" },
+];
+
+function getPublishStepStatusLabel(status) {
+  switch (status) {
+    case "done":
+      return "Done";
+    case "active":
+      return "Active";
+    case "error":
+      return "Error";
+    default:
+      return "Pending";
+  }
+}
+
+function renderPublishFlowCard(flowState, { colorize = (text) => text, width = 80 } = {}) {
+  const maxInnerWidth = Math.max(28, width - 6);
+  const lines = PUBLISH_FLOW_STEPS.map((step, index) => {
+    const status = flowState?.[step.id] || "pending";
+    const symbol = status === "done"
+      ? colorize("●", "success")
+      : status === "active"
+        ? colorize("◉", "accent")
+        : status === "error"
+          ? colorize("▲", "warn")
+          : colorize("○", "muted");
+    const label = status === "done"
+      ? colorize(step.label, "success")
+      : status === "active"
+        ? colorize(step.label, "accent")
+        : status === "error"
+          ? colorize(step.label, "warn")
+          : step.label;
+    const statusLabel = colorize(getPublishStepStatusLabel(status), status === "pending" ? "muted" : status === "error" ? "warn" : status === "active" ? "accent" : "success");
+    const plainLine = `${index + 1}. ${step.label}  ${getPublishStepStatusLabel(status)}`;
+    const paddedWidth = Math.max(0, maxInnerWidth - getDisplayWidth(plainLine));
+    return `│ ${symbol} ${label}${" ".repeat(paddedWidth)} ${statusLabel} │`;
+  });
+
+  const contentWidth = Math.max(
+    28,
+    ...PUBLISH_FLOW_STEPS.map((step, index) => getDisplayWidth(`${index + 1}. ${step.label}  Pending`)),
+  );
+  const title = `◇  ${colorize("Publish Flow", "accent")} ${colorize("─".repeat(Math.max(0, contentWidth - getDisplayWidth("Publish Flow") - 1)), "muted")}╮`;
+  const normalizedLines = lines.map((line) => {
+    const plainWidth = getDisplayWidth(line);
+    const targetWidth = contentWidth + 4;
+    return plainWidth < targetWidth ? `${line.slice(0, -2)}${" ".repeat(targetWidth - plainWidth)} │` : line;
+  });
+  const bottom = `╰${"─".repeat(contentWidth + 2)}╯`;
+  return [title, ...normalizedLines, bottom].join("\n");
+}
+
 function printFallbackIntro({ registry, slug, version, skillName, skillDescription, installTargets }, log = console.log) {
   log("");
   log("ht-skills");
@@ -755,6 +906,19 @@ function printFallbackSearchIntro({ registry, query, limit }, log = console.log)
   log("");
 }
 
+function printFallbackPublishIntro({ registry, skillDir, archiveName, visibility }, log = console.log) {
+  log("");
+  log(renderGradientBanner());
+  log("");
+  log("Publish");
+  log("");
+  log(`Source: ${registry}`);
+  log(`Directory: ${skillDir}`);
+  log(`Archive: ${archiveName}`);
+  log(`Access: ${visibility}`);
+  log("");
+}
+
 async function loadTerminalUi() {
   const [{ intro, outro, note, multiselect, select, spinner, isCancel, cancel }, pcModule] = await Promise.all([
     import("@clack/prompts"),
@@ -1345,14 +1509,90 @@ async function cmdLogin(flags, deps = {}) {
 async function cmdPublish(flags, deps = {}) {
   const requestJsonImpl = deps.requestJson || requestJson;
   const log = deps.log || ((message) => console.log(message));
-  const homeDir = deps.homeDir || os.homedir();
   const registry = getRegistryUrl(flags);
   const skillDir = path.resolve(flags._[0] || ".");
-  const token = await getRequiredAuthToken(registry, flags, { homeDir });
+  const visibility = String(flags.access || flags.visibility || "public").trim().toLowerCase() || "public";
   const archiveName = `${path.basename(skillDir) || "skill"}.zip`;
-  const archiveBuffer = await createZipFromDirectory(skillDir);
+  const isInteractive = isInteractiveSession(deps);
+  const canUseFancyUi = Boolean(isInteractive && !deps.disableUi);
+  const ui = deps.ui || (canUseFancyUi ? await loadTerminalUi().catch(() => null) : null);
+  const colorize = ui ? createUiColorizer(ui.pc) : (text) => String(text);
+  const outputWidth = getOutputWidth(deps.outputWidth);
   const pollIntervalMs = Math.max(500, Number(flags["poll-interval"] || deps.pollIntervalMs || DEFAULT_PUBLISH_POLL_MS));
+  const flowState = {
+    auth: "pending",
+    pack: "pending",
+    inspect: "pending",
+    submit: "pending",
+  };
+
+  const renderPublishFlow = () => {
+    if (!ui) return;
+    // eslint-disable-next-line no-console
+    console.log(renderPublishFlowCard(flowState, {
+      colorize,
+      width: Math.max(44, Math.min(outputWidth - 4, 72)),
+    }));
+  };
+
+  if (ui) {
+    // eslint-disable-next-line no-console
+    console.log(`\n${renderGradientBanner()}\n`);
+    ui.intro(ui.pc.bgCyan(ui.pc.black(" ht-skills ")));
+    ui.note(
+      [
+        `${colorize("Source", "muted")}: ${registry}`,
+        `${colorize("Directory", "muted")}: ${skillDir}`,
+        `${colorize("Archive", "muted")}: ${archiveName}`,
+        `${colorize("Access", "muted")}: ${visibility}`,
+      ].join("\n"),
+      "Publish",
+    );
+    renderPublishFlow();
+  } else {
+    printFallbackPublishIntro({ registry, skillDir, archiveName, visibility }, log);
+  }
+
+  const authSpinner = ui ? ui.spinner() : null;
+  flowState.auth = "active";
+  renderPublishFlow();
+  if (authSpinner) {
+    authSpinner.start("Checking login");
+  } else {
+    log(`Checking login for ${registry}...`);
+  }
+  const { token } = await ensureValidAuthToken(registry, flags, deps);
+  flowState.auth = "done";
+  renderPublishFlow();
+  if (authSpinner) {
+    authSpinner.stop("Login confirmed");
+  }
 
+  const packSpinner = ui ? ui.spinner() : null;
+  flowState.pack = "active";
+  renderPublishFlow();
+  if (packSpinner) {
+    packSpinner.start(`Packing ${path.basename(skillDir) || skillDir}`);
+  } else {
+    log(`Packing skill directory: ${skillDir}`);
+  }
+  const archiveBuffer = await createZipFromDirectory(skillDir);
+  flowState.pack = "done";
+  renderPublishFlow();
+  if (packSpinner) {
+    packSpinner.stop(`Created ${archiveName} (${formatBytes(archiveBuffer.length)})`);
+  } else {
+    log(`Created archive ${archiveName} (${formatBytes(archiveBuffer.length)})`);
+  }
+
+  const uploadSpinner = ui ? ui.spinner() : null;
+  flowState.inspect = "active";
+  renderPublishFlow();
+  if (uploadSpinner) {
+    uploadSpinner.start("Uploading archive for package inspection");
+  } else {
+    log("Uploading archive for package inspection...");
+  }
   const job = await requestJsonImpl(
     `${registry}/api/skills/inspect-package-jobs/upload?archive_name=${encodeURIComponent(archiveName)}`,
     {
@@ -1368,8 +1608,18 @@ async function cmdPublish(flags, deps = {}) {
   if (!jobId) {
     throw new Error("registry did not return an inspection job id");
   }
+  if (uploadSpinner) {
+    uploadSpinner.stop(`Inspection job created (${jobId})`);
+  } else {
+    log(`Inspection job created: ${jobId}`);
+  }
 
   let inspection = job;
+  let lastProgressKey = "";
+  const inspectSpinner = ui ? ui.spinner() : null;
+  if (inspectSpinner) {
+    inspectSpinner.start("Inspecting archive");
+  }
   while (inspection.status !== "succeeded" && inspection.status !== "failed") {
     await sleep(pollIntervalMs);
     inspection = await requestJsonImpl(
@@ -1378,18 +1628,47 @@ async function cmdPublish(flags, deps = {}) {
         headers: withBearerToken({}, token),
       },
     );
+
+    const step = String(inspection.progress?.step || inspection.result?.step || "").trim();
+    const percent = inspection.progress?.percent;
+    const progressKey = `${inspection.status}:${step}:${percent}`;
+    if (progressKey !== lastProgressKey) {
+      lastProgressKey = progressKey;
+      const progressLabel = step
+        ? `${step}${typeof percent === "number" ? ` ${percent}%` : ""}`
+        : inspection.status;
+      if (inspectSpinner) {
+        inspectSpinner.message(`Inspecting archive (${progressLabel})`);
+      } else {
+        log(`Inspection in progress: ${progressLabel}`);
+      }
+    }
   }
 
   if (inspection.status !== "succeeded") {
+    flowState.inspect = "error";
+    renderPublishFlow();
+    if (inspectSpinner) {
+      inspectSpinner.stop("Inspection failed");
+    }
     throw new Error(inspection.error || "skill archive inspection failed");
   }
+  flowState.inspect = "done";
+  renderPublishFlow();
+  if (inspectSpinner) {
+    inspectSpinner.stop("Inspection passed");
+  } else {
+    log("Inspection passed.");
+  }
 
   const preview = inspection.result || {};
   if (!preview.valid || !preview.preview_token) {
     throw new Error(summarizePreviewErrors(preview));
   }
+  if (!ui) {
+    log(`Preview token created: ${preview.preview_token}`);
+  }
 
-  const visibility = String(flags.access || flags.visibility || "public").trim().toLowerCase() || "public";
   const body = {
     preview_token: preview.preview_token,
     visibility,
@@ -1404,6 +1683,14 @@ async function cmdPublish(flags, deps = {}) {
     body.publish_now = true;
   }
 
+  const submitSpinner = ui ? ui.spinner() : null;
+  flowState.submit = "active";
+  renderPublishFlow();
+  if (submitSpinner) {
+    submitSpinner.start(`Submitting review request (${visibility})`);
+  } else {
+    log(`Submitting review request with access=${visibility}...`);
+  }
   const result = await requestJsonImpl(`${registry}/api/skills/submit`, {
     method: "POST",
     headers: withBearerToken({
@@ -1411,8 +1698,15 @@ async function cmdPublish(flags, deps = {}) {
     }, token),
     body: JSON.stringify(body),
   });
+  flowState.submit = "done";
+  renderPublishFlow();
+  if (submitSpinner) {
+    submitSpinner.stop(`Review submission created (${result.submission_id || "pending"})`);
+  } else {
+    log(`Review submission created: ${result.submission_id || "(no submission id returned)"}`);
+  }
 
-  log(JSON.stringify({
+  const summaryPayload = {
     status: result.status,
     submission_id: result.submission_id || null,
     created_at: result.created_at || null,
@@ -1420,7 +1714,22 @@ async function cmdPublish(flags, deps = {}) {
     publication: result.publication || null,
     preview_token: preview.preview_token,
     archive_name: archiveName,
-  }, null, 2));
+  };
+
+  if (ui) {
+    ui.note(
+      [
+        `${colorize("Status", "muted")}: ${result.status || "pending"}`,
+        `${colorize("Submission", "muted")}: ${result.submission_id || "-"}`,
+        `${colorize("Preview", "muted")}: ${preview.preview_token}`,
+        `${colorize("Access", "muted")}: ${summaryPayload.visibility || visibility}`,
+      ].join("\n"),
+      "Published",
+    );
+    ui.outro(`Submitted ${ui.pc.cyan(archiveName)} for review.`);
+  } else {
+    log(JSON.stringify(summaryPayload, null, 2));
+  }
 
   return result;
 }
@@ -1428,11 +1737,10 @@ async function cmdPublish(flags, deps = {}) {
 async function cmdSubmit(flags, deps = {}) {
   const requestJsonImpl = deps.requestJson || requestJson;
   const log = deps.log || ((message) => console.log(message));
-  const homeDir = deps.homeDir || os.homedir();
   const skillDirArg = flags._[0] || ".";
   const skillDir = path.resolve(skillDirArg);
   const registry = getRegistryUrl(flags);
-  const token = await getRequiredAuthToken(registry, flags, { homeDir });
+  const { token } = await ensureValidAuthToken(registry, flags, deps);
   const manifestPath = path.resolve(flags.manifest || path.join(skillDir, "skill.json"));
   const manifestRaw = await fs.readFile(manifestPath, "utf8");
   const manifest = JSON.parse(manifestRaw);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ht-skills",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "CLI for installing and submitting skills from HT Skills Marketplace.",
   "type": "commonjs",
   "bin": {