@curdx/flow 3.1.0 → 3.2.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to `@curdx/flow` are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/) and the project follows [Semantic Versioning](https://semver.org/).
 
+## 3.2.0 — 2026-04-26
+
+### Added
+
+- **Version-aware install** — `flow install` now detects already-installed items with newer versions available upstream and presents a third state `↑ installed v3.0.0 → v3.2.3 available` in the multiselect. Items with updates are pre-selected by default alongside not-installed items, so a single Enter ships "install missing + upgrade outdated".
+- **Smart dispatch** — selected items route to the right operation:
+  - not installed → `install` (full)
+  - update available → `update` (incremental, via `claude plugin update <id>`)
+  - already installed but selected → reinstall confirmation prompt (uninstall + install)
+- **Marketplace cache refresh** — install flow runs `claude plugin marketplace update <name>` for each pkg's marketplace before reading `latestVersion`. Skipped per-marketplace if its cache mtime is within 1 hour. New flag `--no-refresh` to opt out entirely (CI / offline use).
+- **`flow status --json` enriched** — now includes `installedVersion`, `latestVersion`, and `updateAvailable` fields for each item, so external scripts can detect upgrade candidates without parsing the multiselect UI.
+- **`Pkg.installedVersion` / `Pkg.latestVersion` / `Pkg.marketplaces`** — optional methods on the registry interface. Implemented for `pua` and `claude-mem` (the two items whose marketplaces declare `version` in `.claude-plugin/marketplace.json`). Other items gracefully fall back to the boolean installed/not-installed display when versions aren't available.
+
+### Notes
+
+Of the 6 bundled items, only `pua` and `claude-mem` expose comparable versions. `chrome-devtools-mcp` and `frontend-design` (Anthropic official marketplace) don't declare `version` in marketplace metadata and so always render as "installed" without version. Both MCP servers (`sequential-thinking`, `context7`) have no installed-version concept (`npx -y` auto-fetches latest each launch / remote HTTP) and behave the same way.
+
 ## 3.1.0 — 2026-04-26
 
 Major rewrite preserving the same goal (one-command installer for Claude Code plugins and MCP servers) with a cleaner internal architecture and broader coverage.

package/dist/index.mjs

@@ -24,6 +24,12 @@ var messages = {
   "pkg.installed": "\u5DF2\u5B89\u88C5",
   "pkg.notInstalled": "\u672A\u5B89\u88C5",
   "pkg.unknown": "\u672A\u77E5",
+  "pkg.upToDateWithVersion": "\u5DF2\u5B89\u88C5 v{version}",
+  "pkg.updateAvailable": "\u5DF2\u5B89\u88C5 v{current} \u2192 v{latest} \u53EF\u7528",
+  "marketplace.refreshing": "\u5237\u65B0 marketplace \u7F13\u5B58\u2026",
+  "marketplace.refreshed": "\u5DF2\u5237\u65B0 {count} \u4E2A marketplace",
+  "marketplace.refreshSkipped": "marketplace \u7F13\u5B58\u4ECD\u662F\u65B0\u9C9C\u7684\uFF0C\u8DF3\u8FC7\u5237\u65B0",
+  "install.updating": '\u66F4\u65B0 "{name}" \u5230 v{version}',
   "install.selectPrompt": "\u52FE\u9009\u8981\u5B89\u88C5 / \u91CD\u88C5\u7684\u6761\u76EE\uFF08\u9ED8\u8BA4\u52FE\u9009\u672A\u5B89\u88C5\u7684\uFF09",
   "install.nothingSelected": "\u6CA1\u6709\u9009\u62E9\u4EFB\u4F55\u6761\u76EE\uFF0C\u5DF2\u9000\u51FA\u3002",
   "install.confirmReinstall": '"{name}" \u5DF2\u5B89\u88C5\uFF0C\u662F\u5426\u91CD\u65B0\u5B89\u88C5\uFF08\u5148\u5378\u8F7D\u518D\u5B89\u88C5\uFF09\uFF1F',
@@ -81,6 +87,12 @@ var messages2 = {
   "pkg.installed": "installed",
   "pkg.notInstalled": "not installed",
   "pkg.unknown": "unknown",
+  "pkg.upToDateWithVersion": "installed v{version}",
+  "pkg.updateAvailable": "v{current} \u2192 v{latest} available",
+  "marketplace.refreshing": "Refreshing marketplace caches\u2026",
+  "marketplace.refreshed": "Refreshed {count} marketplace(s)",
+  "marketplace.refreshSkipped": "Marketplace caches are fresh, skipping refresh",
+  "install.updating": 'Updating "{name}" to v{version}',
   "install.selectPrompt": "Select items to install / reinstall (not-installed are pre-selected)",
   "install.nothingSelected": "Nothing selected. Exiting.",
   "install.confirmReinstall": '"{name}" is already installed. Reinstall (uninstall then install)?',
@@ -172,6 +184,11 @@ import * as p7 from "@clack/prompts";
 import * as p3 from "@clack/prompts";
 import pc from "picocolors";
 
+// src/runner/state.ts
+import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+
 // src/runner/exec.ts
 import { x } from "tinyexec";
 async function run(cmd, args) {
@@ -298,6 +315,55 @@ async function isMcpInstalled(name) {
   const list = await listMcp();
   return list.some((m) => m.name === name);
 }
+async function findPlugin(id) {
+  const list = await listPlugins();
+  return list.find((p9) => p9.id === id);
+}
+var marketplaceJsonCache = /* @__PURE__ */ new Map();
+function marketplaceDir(name) {
+  return path.join(os.homedir(), ".claude", "plugins", "marketplaces", name);
+}
+async function readMarketplaceJson(name) {
+  if (marketplaceJsonCache.has(name)) return marketplaceJsonCache.get(name) ?? null;
+  const file = path.join(marketplaceDir(name), ".claude-plugin", "marketplace.json");
+  try {
+    const raw = await fs.readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    marketplaceJsonCache.set(name, parsed);
+    return parsed;
+  } catch {
+    marketplaceJsonCache.set(name, null);
+    return null;
+  }
+}
+async function getMarketplacePluginVersion(marketplaceName, pluginName) {
+  const m = await readMarketplaceJson(marketplaceName);
+  if (!m?.plugins) return null;
+  const entry = m.plugins.find((p9) => p9.name === pluginName);
+  return entry?.version ?? null;
+}
+var REFRESH_TTL_MS = 60 * 60 * 1e3;
+async function shouldSkipRefresh(name) {
+  try {
+    const stat = await fs.stat(marketplaceDir(name));
+    return Date.now() - stat.mtimeMs < REFRESH_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+async function refreshMarketplaces(names) {
+  const unique = [...new Set(names)];
+  const toRefresh = [];
+  for (const name of unique) {
+    if (!await shouldSkipRefresh(name)) toRefresh.push(name);
+  }
+  if (toRefresh.length === 0) return [];
+  await Promise.all(
+    toRefresh.map((name) => run("claude", ["plugin", "marketplace", "update", name]))
+  );
+  for (const name of toRefresh) marketplaceJsonCache.delete(name);
+  return toRefresh;
+}
 
 // src/registry/plugins/_helpers.ts
 async function ensureMarketplace(marketplaceName, marketplaceSource, ctx) {
@@ -325,6 +391,7 @@ async function updatePluginById(pluginId, ctx) {
 
 // src/registry/plugins/pua.ts
 var PLUGIN_ID = "pua@pua-skills";
+var PLUGIN_NAME = "pua";
 var MARKETPLACE_NAME = "pua-skills";
 var MARKETPLACE_SOURCE = "tanweai/pua";
 var pua = {
@@ -332,7 +399,14 @@ var pua = {
   name: "pua",
   description: "tanweai/pua \u2014 Chinese Claude Code skills bundle",
   type: "plugin",
+  marketplaces: () => [MARKETPLACE_NAME],
   isInstalled: () => isPluginInstalled(PLUGIN_ID),
+  installedVersion: async () => {
+    const p9 = await findPlugin(PLUGIN_ID);
+    const v = p9?.version;
+    return v && v !== "unknown" ? v : null;
+  },
+  latestVersion: () => getMarketplacePluginVersion(MARKETPLACE_NAME, PLUGIN_NAME),
   install: async (ctx) => {
     await ensureMarketplace(MARKETPLACE_NAME, MARKETPLACE_SOURCE, ctx);
     await installPluginById(PLUGIN_ID, ctx);
@@ -344,6 +418,7 @@ var pua_default = pua;
 
 // src/registry/plugins/claude-mem.ts
 var PLUGIN_ID2 = "claude-mem@thedotmack";
+var PLUGIN_NAME2 = "claude-mem";
 var MARKETPLACE_NAME2 = "thedotmack";
 var MARKETPLACE_SOURCE2 = "thedotmack/claude-mem";
 var claudeMem = {
@@ -351,7 +426,14 @@ var claudeMem = {
   name: "claude-mem",
   description: "thedotmack/claude-mem \u2014 persistent cross-session memory for Claude Code",
   type: "plugin",
+  marketplaces: () => [MARKETPLACE_NAME2],
   isInstalled: () => isPluginInstalled(PLUGIN_ID2),
+  installedVersion: async () => {
+    const p9 = await findPlugin(PLUGIN_ID2);
+    const v = p9?.version;
+    return v && v !== "unknown" ? v : null;
+  },
+  latestVersion: () => getMarketplacePluginVersion(MARKETPLACE_NAME2, PLUGIN_NAME2),
   install: async (ctx) => {
     await ensureMarketplace(MARKETPLACE_NAME2, MARKETPLACE_SOURCE2, ctx);
     await installPluginById(PLUGIN_ID2, ctx);
@@ -517,14 +599,41 @@ function findPkg(id) {
 }
 
 // src/flows/install.ts
-async function selectInteractive() {
-  const states = await Promise.all(PKGS.map(async (pkg) => ({ pkg, installed: await pkg.isInstalled() })));
-  const options = states.map(({ pkg, installed }) => ({
-    value: pkg.id,
-    label: `${pkg.name} ${pc.dim(`(${pkg.type})`)}  ${installed ? pc.green(`\u2713 ${t("pkg.installed")}`) : pc.yellow(`\u2717 ${t("pkg.notInstalled")}`)}`,
-    hint: pkg.description
-  }));
-  const initialValues = states.filter((s) => !s.installed).map((s) => s.pkg.id);
+async function deriveState(pkg) {
+  if (!await pkg.isInstalled()) return { kind: "not_installed" };
+  const [installed, latest] = await Promise.all([
+    pkg.installedVersion?.() ?? Promise.resolve(null),
+    pkg.latestVersion?.() ?? Promise.resolve(null)
+  ]);
+  if (installed && latest && installed !== latest) {
+    return { kind: "update_available", current: installed, latest };
+  }
+  return { kind: "up_to_date", version: installed };
+}
+function stateLabel(pkg, s) {
+  const head = `${pkg.name} ${pc.dim(`(${pkg.type})`)}`;
+  switch (s.kind) {
+    case "not_installed":
+      return `${head}  ${pc.yellow(`\u2717 ${t("pkg.notInstalled")}`)}`;
+    case "up_to_date":
+      return `${head}  ${pc.green(
+        s.version ? `\u2713 ${t("pkg.upToDateWithVersion", { version: s.version })}` : `\u2713 ${t("pkg.installed")}`
+      )}`;
+    case "update_available":
+      return `${head}  ${pc.cyan(
+        `\u2191 ${t("pkg.updateAvailable", { current: s.current, latest: s.latest })}`
+      )}`;
+  }
+}
+async function selectInteractive(states) {
+  const options = PKGS.map((pkg) => {
+    const s = states.get(pkg.id);
+    return { value: pkg.id, label: stateLabel(pkg, s), hint: pkg.description };
+  });
+  const initialValues = PKGS.filter((pkg) => {
+    const s = states.get(pkg.id);
+    return s.kind === "not_installed" || s.kind === "update_available";
+  }).map((pkg) => pkg.id);
   const picked = await p3.multiselect({
     message: t("install.selectPrompt"),
     options,
@@ -545,12 +654,14 @@ function selectFromIds(opts) {
   }
   return found;
 }
-async function runOne(pkg, opts, alreadyInstalled) {
-  let reinstall = false;
-  if (alreadyInstalled) {
-    if (opts.yes) {
-      reinstall = true;
-    } else {
+async function runOne(pkg, state, opts) {
+  let mode;
+  if (state.kind === "not_installed") {
+    mode = "install";
+  } else if (state.kind === "update_available") {
+    mode = "update";
+  } else {
+    if (!opts.yes) {
       const ans = await p3.confirm({
         message: t("install.confirmReinstall", { name: pkg.name }),
         initialValue: false
@@ -558,8 +669,8 @@ async function runOne(pkg, opts, alreadyInstalled) {
       if (p3.isCancel(ans) || ans === false) {
         return { id: pkg.id, status: "skip", message: t("install.skippedReinstall", { name: pkg.name }) };
       }
-      reinstall = true;
     }
+    mode = "reinstall";
   }
   if (pkg.prereqCheck) {
     const r = await pkg.prereqCheck(t);
@@ -569,19 +680,35 @@ async function runOne(pkg, opts, alreadyInstalled) {
     }
   }
   let config = {};
-  if (pkg.configPrompts) {
+  if (pkg.configPrompts && mode !== "update") {
     const cfg = await pkg.configPrompts({ t });
     if (cfg === null) return { id: pkg.id, status: "skip", message: t("app.cancelled") };
     config = cfg;
   }
-  const log4 = p3.taskLog({ title: t("install.starting", { name: pkg.name }) });
+  const titleKey = mode === "update" ? "install.updating" : "install.starting";
+  const titleVars = { name: pkg.name };
+  if (mode === "update" && state.kind === "update_available") {
+    titleVars["version"] = state.latest;
+  }
+  const log4 = p3.taskLog({ title: t(titleKey, titleVars) });
   try {
-    if (reinstall) {
+    if (mode === "reinstall") {
       log4.message(t("reinstall.uninstalling"));
       await pkg.uninstall({ log: log4, config, t });
       log4.message(t("reinstall.installing"));
+      await pkg.install({ log: log4, config, t });
+    } else if (mode === "update") {
+      if (pkg.update) {
+        await pkg.update({ log: log4, config, t });
+      } else {
+        log4.message(t("reinstall.uninstalling"));
+        await pkg.uninstall({ log: log4, config, t });
+        log4.message(t("reinstall.installing"));
+        await pkg.install({ log: log4, config, t });
+      }
+    } else {
+      await pkg.install({ log: log4, config, t });
     }
-    await pkg.install({ log: log4, config, t });
     log4.success(t("install.success", { name: pkg.name }));
     return { id: pkg.id, status: "ok" };
   } catch (err) {
@@ -606,27 +733,53 @@ function summarize(results) {
   ];
   p3.note(lines.join("\n"), t("install.summaryTitle"));
 }
+async function maybeRefreshMarketplaces(opts) {
+  if (opts.noRefresh) return;
+  const names = /* @__PURE__ */ new Set();
+  for (const pkg of PKGS) {
+    if (pkg.marketplaces) for (const n of pkg.marketplaces()) names.add(n);
+  }
+  if (names.size === 0) return;
+  const sp = p3.spinner();
+  sp.start(t("marketplace.refreshing"));
+  const refreshed = await refreshMarketplaces([...names]);
+  sp.stop(
+    refreshed.length > 0 ? t("marketplace.refreshed", { count: refreshed.length }) : t("marketplace.refreshSkipped")
+  );
+}
 async function installFlow(opts = {}) {
+  await maybeRefreshMarketplaces(opts);
   const explicit = opts.all || opts.ids && opts.ids.length > 0;
-  const targets = explicit ? selectFromIds(opts) : await selectInteractive();
-  if (targets === null) {
-    p3.cancel(t("app.cancelled"));
-    return;
-  }
-  if (targets.length === 0) {
+  const candidates = explicit ? selectFromIds(opts) : [...PKGS];
+  if (candidates.length === 0) {
     p3.log.info(t("install.nothingSelected"));
     return;
   }
-  const installedMap = /* @__PURE__ */ new Map();
+  const stateMap = /* @__PURE__ */ new Map();
   await Promise.all(
-    targets.map(async (pkg) => {
-      installedMap.set(pkg.id, await pkg.isInstalled());
+    candidates.map(async (pkg) => {
+      stateMap.set(pkg.id, await deriveState(pkg));
     })
   );
+  let targets;
+  if (explicit) {
+    targets = candidates;
+  } else {
+    const picked = await selectInteractive(stateMap);
+    if (picked === null) {
+      p3.cancel(t("app.cancelled"));
+      return;
+    }
+    targets = picked;
+  }
+  if (targets.length === 0) {
+    p3.log.info(t("install.nothingSelected"));
+    return;
+  }
   const results = [];
   for (const pkg of targets) {
-    const installed = installedMap.get(pkg.id) ?? false;
-    results.push(await runOne(pkg, opts, installed));
+    const state = stateMap.get(pkg.id) ?? { kind: "not_installed" };
+    results.push(await runOne(pkg, state, opts));
   }
   summarize(results);
 }
@@ -811,12 +964,23 @@ import * as p6 from "@clack/prompts";
 import pc4 from "picocolors";
 async function statusFlow(opts = {}) {
   const states = await Promise.all(
-    PKGS.map(async (pkg) => ({
-      id: pkg.id,
-      name: pkg.name,
-      type: pkg.type,
-      installed: await pkg.isInstalled()
-    }))
+    PKGS.map(async (pkg) => {
+      const installed = await pkg.isInstalled();
+      const installedVersion = installed && pkg.installedVersion ? await pkg.installedVersion() : null;
+      const latestVersion = pkg.latestVersion ? await pkg.latestVersion() : null;
+      const updateAvailable = Boolean(
+        installed && installedVersion && latestVersion && installedVersion !== latestVersion
+      );
+      return {
+        id: pkg.id,
+        name: pkg.name,
+        type: pkg.type,
+        installed,
+        installedVersion,
+        latestVersion,
+        updateAvailable
+      };
+    })
   );
   if (opts.json) {
     process.stdout.write(JSON.stringify(states, null, 2) + "\n");
@@ -872,18 +1036,24 @@ var sharedArgs = {
   lang: { type: "string", description: "Override language: zh or en" }
 };
 var installCmd = defineCommand({
-  meta: { name: "install", description: "Install or reinstall plugins / MCP servers" },
+  meta: { name: "install", description: "Install, reinstall, or update plugins / MCP servers" },
   args: {
     ...sharedArgs,
     all: { type: "boolean", description: "Install all known items" },
     yes: { type: "boolean", description: "Skip reinstall confirmation (assume yes)" },
+    "no-refresh": { type: "boolean", description: "Skip refreshing marketplace caches" },
     ids: { type: "positional", required: false, description: "Item ids", default: "" }
   },
   async run({ args }) {
     await initLanguage(parseLang(args.lang));
     p8.intro(t("app.intro"));
     const ids = collectPositional(args);
-    await installFlow({ ids, all: Boolean(args.all), yes: Boolean(args.yes) });
+    await installFlow({
+      ids,
+      all: Boolean(args.all),
+      yes: Boolean(args.yes),
+      noRefresh: Boolean(args["no-refresh"])
+    });
     p8.outro(t("app.outro"));
   }
 });
@@ -934,7 +1104,7 @@ var SUBCOMMANDS = /* @__PURE__ */ new Set(["install", "uninstall", "update", "st
 var root = defineCommand({
   meta: {
     name: "@curdx/flow",
-    version: "3.1.0",
+    version: "3.2.0",
     description: "Interactive installer for Claude Code plugins and MCP servers"
   },
   args: sharedArgs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curdx/flow",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Interactive installer for Claude Code plugins and MCP servers",
   "type": "module",
   "bin": "./dist/index.mjs",